feat: implement payment service with error handling and validation

Add new payment service with repository, error handling, and validation
Add exceptions package with database and validation utilities
Update database package with new schema and zod types
Add turbo start script for development

packages/exceptions/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "@repo/exceptions",
+  "version": "0.0.0",
+  "main": "./src/index.ts",
+  "types": "./src/index.ts",
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "dependencies": {
+    "neverthrow": "^8.2.0",
+    "zod": "^4.0.2"
+  },
+  "devDependencies": {
+    "@repo/typescript-config": "*",
+    "typescript": "^5.0.0"
+  }
+}

packages/exceptions/src/constructors.ts

@@ -0,0 +1,35 @@
+import { AppError, DatabaseError, ErrorCode, ValidationError } from './types';
+
+export const createAppError = <T>(
+  code: T,
+  message: string,
+  details?: Record<string, unknown>,
+  cause?: Error
+): AppError<T> => ({
+  code,
+  message,
+  details,
+  cause,
+});
+
+export const createValidationError = (
+  field: string,
+  value: unknown,
+  message: string
+): ValidationError => ({
+  code: ErrorCode.VALIDATION_ERROR,
+  message,
+  field,
+  value,
+});
+
+export const databaseError = (
+  operation: string,
+  cause?: Error
+): DatabaseError =>
+  createAppError(
+    ErrorCode.DATABASE_ERROR,
+    `Database error during ${operation}`,
+    undefined,
+    cause
+  );

packages/exceptions/src/index.ts

@@ -0,0 +1,3 @@
+export * from './types';
+export * from './constructors';
+export * from './utils';

packages/exceptions/src/types.ts

@@ -0,0 +1,21 @@
+export enum ErrorCode {
+  // System errors
+  DATABASE_ERROR = 'DATABASE_ERROR',
+  VALIDATION_ERROR = 'VALIDATION_ERROR',
+  UNKNOWN_ERROR = 'UNKNOWN_ERROR',
+}
+
+export type AppError<T> = {
+  readonly code: T;
+  readonly message: string;
+  readonly details?: Record<string, unknown>;
+  readonly cause?: Error;
+};
+
+export type ValidationError = AppError<ErrorCode.VALIDATION_ERROR> & {
+  readonly code: ErrorCode.VALIDATION_ERROR;
+  readonly field: string;
+  readonly value: unknown;
+};
+
+export type DatabaseError = AppError<ErrorCode.DATABASE_ERROR>;

packages/exceptions/src/utils/database.ts

@@ -0,0 +1,25 @@
+import { ResultAsync, err, ok } from 'neverthrow';
+import { AppError } from '../types';
+
+/**
+ * Wraps a database operation in a Result type to handle errors gracefully
+ * @param operation - The database operation to execute
+ * @param errorFactory - Function to create a custom error if the operation fails
+ * @returns Result containing the operation result or error
+ */
+export const wrapDbOperation = <T, E extends AppError<unknown>>(
+  operation: () => Promise<T>,
+  errorFactory: (error: unknown) => E
+): ResultAsync<T, E> => {
+  return ResultAsync.fromPromise(operation(), errorFactory);
+};
+
+export const wrapDbOperationWithNull = <T, E extends AppError<unknown>>(
+  operation: () => Promise<T | null>,
+  notFoundError: E,
+  dbErrorFactory: (error: unknown) => E
+): ResultAsync<T, E> => {
+  return ResultAsync.fromPromise(operation(), (error) =>
+    dbErrorFactory(error)
+  ).andThen((result) => (result === null ? err(notFoundError) : ok(result)));
+};

packages/exceptions/src/utils/index.ts

@@ -0,0 +1,2 @@
+export * from './database';
+export * from './validation';

packages/exceptions/src/utils/validation.ts

@@ -0,0 +1,10 @@
+import { err, ok, Result } from 'neverthrow';
+import { output, ZodError, ZodObject } from 'zod';
+
+export const safeParse =
+  <T extends ZodObject>(schema: T) =>
+  <D>(data: D): Result<output<T>, ZodError<output<T>>> => {
+    const parseResult = schema.safeParse(data);
+
+    return parseResult.success ? ok(parseResult.data) : err(parseResult.error);
+  };