@c15t/backend 1.8.0 → 2.0.0-rc.0

package/src/pkgs/migrations/types.ts

@@ -1,48 +0,0 @@
-import type {
-	AlterTableColumnAlteringBuilder,
-	CreateTableBuilder,
-} from 'kysely';
-import type { Field } from '~/pkgs/data-model';
-
-/**
- * Type representing a table to be created during migration
- */
-export interface TableToCreate {
-	table: string;
-	fields: Record<string, Field>;
-	order: number;
-}
-
-/**
- * Type representing table columns to be added during migration
- */
-export interface ColumnsToAdd {
-	table: string;
-	fields: Record<string, Field>;
-	order: number;
-}
-
-/**
- * Type for migration operations
- */
-export type MigrationOperation =
-	| AlterTableColumnAlteringBuilder
-	| CreateTableBuilder<string, string>;
-
-/**
- * Result of migration generation
- */
-export interface MigrationResult {
-	toBeCreated: TableToCreate[];
-	toBeAdded: ColumnsToAdd[];
-	runMigrations: () => Promise<void>;
-	compileMigrations: () => Promise<string>;
-}
-
-/**
- * Re-export TableSchemaDefinition from get-schema
- */
-export type {
-	SchemaDefinition,
-	TableSchemaDefinition,
-} from './get-schema/types';

package/src/pkgs/results/README.md

@@ -1,345 +0,0 @@
-# DoubleTie Results Package
-
-A comprehensive outcome handling system for TypeScript applications. This package provides consistent patterns for managing both successful results and errors, making it easier to develop robust, predictable applications.
-
-## Key Features
-
-- Complete implementation of the Result pattern (built on [neverthrow](https://github.com/supermacro/neverthrow))
-- A standardized error class (`DoubleTieError`) with rich context information
-- Standard error codes categorized by domain and purpose
-- Recovery mechanisms for handling expected errors
-- Processing pipelines for validation and data retrieval
-- Extensibility points for custom error types and domain-specific results
-
-## Installation
-
-```bash
-npm install @doubletie/results
-```
-
-## Package Structure
-
-The results package is organized into logical directories for better discoverability:
-
-- **core/** - Core functionality
-  - **error-class.ts** - Defines the `DoubleTieError` class
-  - **error-codes.ts** - Contains error code definitions and utilities
-- **results/** - Result pattern utilities
-  - **result-helpers.ts** - Utilities for working with the Result pattern
-  - **recovery-utils.ts** - Contains utilities for recovering from expected errors
-- **pipeline/** - Pipeline utilities
-  - **validation-pipeline.ts** - Defines validation pipeline for input data
-  - **retrieval-pipeline.ts** - Defines data retrieval pipeline
-- **types.ts** - Shared type definitions
-- **index.ts** - Main exports
-
-## Usage
-
-### Working with Results
-
-Using the Result pattern for comprehensive outcome handling:
-
-```typescript
-import { 
-  AppResult, 
-  ok, 
-  fail, 
-  ERROR_CODES 
-} from '@doubletie/results';
-
-function getUser(id: string): AppResult<User> {
-  const user = users.find(u => u.id === id);
-  if (!user) {
-    return fail('User not found', {
-      code: ERROR_CODES.NOT_FOUND,
-      status: 404,
-      meta: { userId: id }
-    });
-  }
-  return ok(user);
-}
-
-// Using the result
-const userResult = getUser('123');
-if (userResult.isOk()) {
-  const user = userResult.value;
-  console.log(`Found user: ${user.name}`);
-} else {
-  const error = userResult.error;
-  console.error(`Error: ${error.message} (${error.code})`);
-}
-```
-
-### Async Operations with ResultAsync
-
-For asynchronous operations:
-
-```typescript
-import { 
-  AppResultAsync, 
-  tryCatchAsync, 
-  ERROR_CODES 
-} from '@doubletie/results';
-
-async function fetchUserData(id: string): Promise<AppResultAsync<UserData>> {
-  return tryCatchAsync(
-    async () => {
-      const response = await fetch(`/api/users/${id}`);
-      if (!response.ok) {
-        throw new Error(`Failed to fetch user: ${response.statusText}`);
-      }
-      return response.json();
-    },
-    ERROR_CODES.NETWORK_ERROR
-  );
-}
-
-// Using the async result
-const userDataResult = await fetchUserData('123');
-if (userDataResult.isOk()) {
-  const userData = userDataResult.value;
-  console.log(`Found user: ${userData.name}`);
-} else {
-  const error = userDataResult.error;
-  console.error(`Error: ${error.message} (${error.code})`);
-}
-```
-
-### Converting Promises to Results
-
-You can easily wrap promises with result handling:
-
-```typescript
-import { 
-  promiseToResult, 
-  ERROR_CODES 
-} from '@doubletie/results';
-
-async function fetchData() {
-  const resultAsync = promiseToResult(
-    fetch('https://api.example.com/users')
-      .then(res => res.json()),
-    ERROR_CODES.NETWORK_ERROR
-  );
-  
-  return resultAsync;
-}
-```
-
-### Error Handling
-
-The package provides a standardized error class for consistent error handling:
-
-```typescript
-import { DoubleTieError, ERROR_CODES } from '@doubletie/results';
-
-function getUserById(id: string) {
-  const user = userRepository.findById(id);
-  if (!user) {
-    throw new DoubleTieError('User not found', {
-      code: ERROR_CODES.NOT_FOUND, 
-      status: 404,
-      meta: { userId: id }
-    });
-  }
-  return user;
-}
-```
-
-### Validation Pipelines
-
-Creating validation pipelines with Zod:
-
-```typescript
-import { validationPipeline, ERROR_CODES } from '@doubletie/results';
-import { z } from 'zod';
-
-const userSchema = z.object({
-  name: z.string().min(2),
-  email: z.string().email(),
-  age: z.number().min(18)
-});
-
-const validateUser = validationPipeline(
-  userSchema,
-  (data) => ({ ...data, createdAt: new Date() })
-);
-
-// Using the validation pipeline
-const result = validateUser(req.body);
-if (result.isOk()) {
-  const validatedUser = result.value;
-  // Proceed with validated user data
-} else {
-  // Handle validation error
-  const validationErrors = result.error.meta?.validationErrors;
-  res.status(400).json({ 
-    error: result.error.message, 
-    details: validationErrors 
-  });
-}
-```
-
-### Recovery Mechanisms
-
-Recovering from expected errors with fallbacks:
-
-```typescript
-import { 
-  withFallbackForCodes, 
-  ERROR_CODES 
-} from '@doubletie/results';
-
-const userResult = await getUserById(userId);
-const safeUserResult = withFallbackForCodes(
-  userResult,
-  [ERROR_CODES.NOT_FOUND],
-  { id: userId, name: 'Guest User', isDefault: true }
-);
-
-// Now safeUserResult will contain a default user object
-// if the original error was NOT_FOUND
-const user = safeUserResult.isOk() 
-  ? safeUserResult.value 
-  : handleOtherErrors(safeUserResult.error);
-```
-
-### Creating Custom Error Codes
-
-You can extend the error system with your own domain-specific error codes:
-
-```typescript
-import { 
-  createErrorCodes, 
-  DoubleTieError 
-} from '@doubletie/results';
-
-const BILLING_ERROR_CODES = createErrorCodes({
-  PAYMENT_FAILED: 'Payment processing failed',
-  INVOICE_NOT_FOUND: 'Invoice not found',
-  INSUFFICIENT_FUNDS: 'Insufficient funds to complete transaction',
-});
-
-// Later in your code
-throw new DoubleTieError('Credit card declined', {
-  code: BILLING_ERROR_CODES.PAYMENT_FAILED,
-  status: 400,
-  meta: { 
-    cardType: 'Visa',
-    lastFour: '1234',
-    transactionId: 'txn_123456'
-  }
-});
-```
-
-### Creating Domain-Specific Error Subclasses
-
-For better error typing and handling:
-
-```typescript
-import { DoubleTieError } from '@doubletie/results';
-import { BILLING_ERROR_CODES } from './billing-errors';
-
-const BillingError = DoubleTieError.createSubclass('BillingError');
-
-// Later in your code
-throw new BillingError('Failed to process payment', {
-  code: BILLING_ERROR_CODES.PAYMENT_FAILED,
-  status: 400,
-  meta: { transactionId: 'txn_123456' }
-});
-
-// Type checking
-try {
-  await processPayment();
-} catch (error) {
-  if (error instanceof BillingError) {
-    // Handle billing-specific errors
-  } else if (error instanceof DoubleTieError) {
-    // Handle other DoubleTie errors
-  } else {
-    // Handle unknown errors
-  }
-}
-```
-
-## Error Categories
-
-Errors are organized into categories for better management:
-
-- **validation** - Errors related to input validation
-- **authorization** - Errors related to authentication and permissions
-- **storage** - Errors related to data storage and retrieval
-- **network** - Errors related to network operations
-- **plugin** - Errors related to plugin management
-- **configuration** - Errors related to configuration issues
-- **unexpected** - Unexpected errors that don't fit other categories
-
-You can create your own categories with the `createErrorCategories` utility.
-
-## API Reference
-
-### Types
-
-#### `AppResult<T>`
-
-```typescript
-type AppResult<T> = Result<T, DoubleTieError>;
-```
-
-#### `AppResultAsync<T>`
-
-```typescript
-type AppResultAsync<T> = ResultAsync<T, DoubleTieError>;
-```
-
-#### `ErrorCodeValue`
-
-```typescript
-type ErrorCodeValue = string;
-```
-
-#### `ErrorTransformer`
-
-```typescript
-type ErrorTransformer = (error: Error) => DoubleTieError;
-```
-
-### Core Functions
-
-#### Result Helpers
-
-```typescript
-function ok<T>(value: T): AppResult<T>;
-function fail<T>(message: string, options: DoubleTieErrorOptions): AppResult<T>;
-function tryCatch<T>(fn: () => T, errorCode?: ErrorCodeValue): AppResult<T>;
-function tryCatchAsync<T>(fn: () => Promise<T>, errorCode?: ErrorCodeValue): AppResultAsync<T>;
-function promiseToResult<T>(promise: Promise<T>, errorCode?: ErrorCodeValue): AppResultAsync<T>;
-```
-
-#### Recovery Utilities
-
-```typescript
-function withFallbackForCodes<T>(result: AppResult<T>, codes: ErrorCodeValue[], defaultValue: T): AppResult<T>;
-function withFallbackForCategory<T>(result: AppResult<T>, category: string, defaultValue: T): AppResult<T>;
-```
-
-#### Pipeline Utilities
-
-```typescript
-function validationPipeline<Input, Output>(schema: ZodSchema<Input>, transformer: (data: Input) => Output): (data: unknown) => AppResult<Output>;
-function retrievalPipeline<RawData, TransformedData>(fetcher: () => Promise<RawData>, transformer: (data: RawData) => TransformedData, errorCode?: ErrorCodeValue): () => AppResultAsync<TransformedData>;
-```
-
-## Testing
-
-The results package includes comprehensive tests to ensure reliability. Run tests with:
-
-```bash
-cd packages/backend
-npx vitest run src/pkgs/results
-```
-
-## License
-
-MIT 

package/src/pkgs/results/__tests__/error-class.test.ts

@@ -1,183 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { DoubleTieError } from '../core/error-class';
-import { ERROR_CATEGORIES, ERROR_CODES } from '../core/error-codes';
-
-describe('DoubleTieError', () => {
-	describe('constructor', () => {
-		it('should create an error with the provided message and options', () => {
-			const message = 'Test error message';
-			const options = {
-				code: ERROR_CODES.BAD_REQUEST,
-				status: 400,
-				category: ERROR_CATEGORIES.VALIDATION,
-				meta: { foo: 'bar' },
-			};
-
-			const error = new DoubleTieError(message, options);
-
-			expect(error.message).toBe(message);
-			expect(error.code).toBe(ERROR_CODES.BAD_REQUEST);
-			expect(error.statusCode).toBe(400);
-			expect(error.category).toBe(ERROR_CATEGORIES.VALIDATION);
-			expect(error.meta).toEqual({ foo: 'bar' });
-			expect(error.name).toBe('DoubleTieError');
-		});
-
-		it('should use default values when not provided', () => {
-			const message = 'Test error message';
-			const options = {
-				code: ERROR_CODES.BAD_REQUEST,
-			};
-
-			const error = new DoubleTieError(message, options);
-
-			expect(error.message).toBe(message);
-			expect(error.code).toBe(ERROR_CODES.BAD_REQUEST);
-			expect(error.statusCode).toBe(500);
-			expect(error.category).toBe(ERROR_CATEGORIES.UNEXPECTED);
-			expect(error.meta).toEqual({});
-		});
-
-		it('should capture cause when provided', () => {
-			const cause = new Error('Original error');
-			const error = new DoubleTieError('Wrapped error', {
-				code: ERROR_CODES.INTERNAL_SERVER_ERROR,
-				cause,
-			});
-
-			expect(error.cause).toBe(cause);
-		});
-	});
-
-	describe('fromResponse', () => {
-		it('should create an error from a Response object', () => {
-			const response = new Response('Not found', { status: 404 });
-			const error = DoubleTieError.fromResponse(response);
-
-			expect(error).toBeInstanceOf(DoubleTieError);
-			expect(error.statusCode).toBe(404);
-			expect(error.message).toContain('HTTP error 404');
-		});
-
-		it('should extract error details from response data', () => {
-			const responseData = {
-				message: 'Resource not found',
-				code: ERROR_CODES.NOT_FOUND,
-				data: { resourceId: '123' },
-			};
-
-			const response = new Response(JSON.stringify(responseData), {
-				status: 404,
-				headers: { 'Content-Type': 'application/json' },
-			});
-
-			const error = DoubleTieError.fromResponse(response, responseData);
-
-			expect(error.message).toBe('Resource not found');
-			expect(error.code).toBe(ERROR_CODES.NOT_FOUND);
-			expect(error.statusCode).toBe(404);
-			expect(error.meta).toEqual({ resourceId: '123' });
-		});
-	});
-
-	describe('isDoubleTieError', () => {
-		it('should return true for DoubleTieError instances', () => {
-			const error = new DoubleTieError('Test error', {
-				code: ERROR_CODES.BAD_REQUEST,
-			});
-			expect(DoubleTieError.isDoubleTieError(error)).toBe(true);
-		});
-
-		it('should return false for non-DoubleTieError values', () => {
-			expect(DoubleTieError.isDoubleTieError(new Error('Regular error'))).toBe(
-				false
-			);
-			expect(DoubleTieError.isDoubleTieError('string')).toBe(false);
-			expect(DoubleTieError.isDoubleTieError(null)).toBe(false);
-			expect(DoubleTieError.isDoubleTieError(undefined)).toBe(false);
-			expect(DoubleTieError.isDoubleTieError(123)).toBe(false);
-			expect(DoubleTieError.isDoubleTieError({})).toBe(false);
-		});
-	});
-
-	describe('toJSON', () => {
-		it('should serialize error to JSON with oRPC compatible structure', () => {
-			const error = new DoubleTieError('Test error', {
-				code: ERROR_CODES.BAD_REQUEST,
-				status: 400,
-				category: ERROR_CATEGORIES.VALIDATION,
-				meta: { field: 'username' },
-			});
-
-			const errorJson = error.toJSON();
-
-			expect(errorJson.status).toBe(400);
-			expect(errorJson.message).toBe('Test error');
-			expect(errorJson.code).toBe(ERROR_CODES.BAD_REQUEST);
-			expect(errorJson.data.category).toBe(ERROR_CATEGORIES.VALIDATION);
-			expect(errorJson.data.meta).toEqual({ field: 'username' });
-			expect(errorJson.defined).toBe(true);
-		});
-
-		it('should include validation error message when present', () => {
-			const error = new DoubleTieError('Validation failed', {
-				code: ERROR_CODES.BAD_REQUEST,
-				status: 422,
-				meta: { validationErrors: 'Field X is required' },
-			});
-
-			const errorJson = error.toJSON();
-
-			expect(errorJson.message).toBe('Field X is required');
-			expect(errorJson.data.originalMessage).toBe('Validation failed');
-		});
-	});
-
-	describe('withMeta', () => {
-		it('should create a new error with combined metadata', () => {
-			const error = new DoubleTieError('Test error', {
-				code: ERROR_CODES.BAD_REQUEST,
-				meta: { field: 'username' },
-			});
-
-			const newError = error.withMeta({ reason: 'validation failed' });
-
-			expect(error.meta).toEqual({ field: 'username' });
-
-			expect(newError.meta).toEqual({
-				field: 'username',
-				reason: 'validation failed',
-			});
-
-			expect(newError.message).toBe(error.message);
-			expect(newError.code).toBe(error.code);
-			expect(newError.statusCode).toBe(error.statusCode);
-			expect(newError.category).toBe(error.category);
-		});
-	});
-
-	describe('createSubclass', () => {
-		it('should create a subclass of DoubleTieError with the specified name', () => {
-			const CustomError = DoubleTieError.createSubclass('CustomError');
-			const error = new CustomError('Custom error', {
-				code: ERROR_CODES.BAD_REQUEST,
-			});
-
-			expect(error).toBeInstanceOf(DoubleTieError);
-			expect(error).toBeInstanceOf(CustomError);
-			expect(error.name).toBe('CustomError');
-			expect(CustomError.name).toBe('CustomError');
-		});
-
-		it('should allow the subclass to be used with instanceof', () => {
-			const PaymentError = DoubleTieError.createSubclass('PaymentError');
-			const error = new PaymentError('Payment failed', {
-				code: 'PAYMENT_FAILED',
-			});
-
-			expect(error instanceof PaymentError).toBe(true);
-			expect(error instanceof DoubleTieError).toBe(true);
-			expect(error instanceof Error).toBe(true);
-		});
-	});
-});

package/src/pkgs/results/__tests__/error-codes.test.ts

@@ -1,81 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import {
-	createErrorCategories,
-	createErrorCodes,
-	ERROR_CATEGORIES,
-	ERROR_CODES,
-} from '../core/error-codes';
-
-describe('error-codes', () => {
-	describe('ERROR_CODES', () => {
-		it('should contain basic error codes', () => {
-			expect(ERROR_CODES.NOT_FOUND).toBe('Resource not found');
-			expect(ERROR_CODES.BAD_REQUEST).toBe('Bad request');
-			expect(ERROR_CODES.INTERNAL_SERVER_ERROR).toBe('Internal server error');
-		});
-
-		it('should be frozen (readonly)', () => {
-			expect(() => {
-				// @ts-expect-error - Testing runtime immutability
-				ERROR_CODES.CUSTOM_ERROR = 'Custom error';
-			}).toThrow();
-		});
-	});
-
-	describe('ERROR_CATEGORIES', () => {
-		it('should contain predefined error categories', () => {
-			expect(ERROR_CATEGORIES.VALIDATION).toBe('validation');
-			expect(ERROR_CATEGORIES.AUTHORIZATION).toBe('authorization');
-			expect(ERROR_CATEGORIES.STORAGE).toBe('storage');
-			expect(ERROR_CATEGORIES.NETWORK).toBe('network');
-			expect(ERROR_CATEGORIES.PLUGIN).toBe('plugin');
-			expect(ERROR_CATEGORIES.CONFIGURATION).toBe('configuration');
-			expect(ERROR_CATEGORIES.UNEXPECTED).toBe('unexpected');
-		});
-
-		it('should be frozen (readonly)', () => {
-			expect(() => {
-				// @ts-expect-error - Testing runtime immutability
-				ERROR_CATEGORIES.CUSTOM_CATEGORY = 'custom';
-			}).toThrow();
-		});
-	});
-
-	describe('createErrorCodes', () => {
-		it('should create a readonly object with the provided error codes', () => {
-			const BILLING_ERROR_CODES = createErrorCodes({
-				PAYMENT_FAILED: 'Payment processing failed',
-				INVOICE_NOT_FOUND: 'Invoice not found',
-			});
-
-			expect(BILLING_ERROR_CODES.PAYMENT_FAILED).toBe(
-				'Payment processing failed'
-			);
-			expect(BILLING_ERROR_CODES.INVOICE_NOT_FOUND).toBe('Invoice not found');
-
-			// Should be readonly
-			expect(() => {
-				// @ts-expect-error - Testing runtime immutability
-				BILLING_ERROR_CODES.NEW_CODE = 'New code';
-			}).toThrow();
-		});
-	});
-
-	describe('createErrorCategories', () => {
-		it('should create a readonly object with the provided error categories', () => {
-			const CUSTOM_CATEGORIES = createErrorCategories({
-				BILLING: 'billing',
-				ANALYTICS: 'analytics',
-			});
-
-			expect(CUSTOM_CATEGORIES.BILLING).toBe('billing');
-			expect(CUSTOM_CATEGORIES.ANALYTICS).toBe('analytics');
-
-			// Should be readonly
-			expect(() => {
-				// @ts-expect-error - Testing runtime immutability
-				CUSTOM_CATEGORIES.NEW_CATEGORY = 'new';
-			}).toThrow();
-		});
-	});
-});