@geekmidas/testkit 9.0.2 → 10.0.0-alpha.0

package/src/__tests__/utilities.spec.ts

@@ -1,211 +0,0 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { describe, expect, it } from 'vitest';
-import {
-	createMockContext,
-	createMockV1Event,
-	createMockV2Event,
-} from '../aws';
-import { createMockLogger } from '../logger';
-import { itWithDir } from '../os/directory';
-import { waitFor } from '../timer';
-
-describe('testkit utilities', () => {
-	describe('createMockLogger', () => {
-		it('should create a logger with all required methods', () => {
-			const logger = createMockLogger();
-
-			expect(logger.debug).toBeDefined();
-			expect(logger.info).toBeDefined();
-			expect(logger.warn).toBeDefined();
-			expect(logger.error).toBeDefined();
-			expect(logger.fatal).toBeDefined();
-			expect(logger.trace).toBeDefined();
-			expect(logger.child).toBeDefined();
-		});
-
-		it('should have mock functions that can be called', () => {
-			const logger = createMockLogger();
-
-			logger.debug('debug message');
-			logger.info({ data: 'test' }, 'info message');
-			logger.warn('warning');
-			logger.error('error');
-			logger.fatal('fatal');
-			logger.trace('trace');
-
-			expect(logger.debug).toHaveBeenCalledWith('debug message');
-			expect(logger.info).toHaveBeenCalledWith(
-				{ data: 'test' },
-				'info message',
-			);
-			expect(logger.warn).toHaveBeenCalledWith('warning');
-			expect(logger.error).toHaveBeenCalledWith('error');
-			expect(logger.fatal).toHaveBeenCalledWith('fatal');
-			expect(logger.trace).toHaveBeenCalledWith('trace');
-		});
-
-		it('should return itself from child()', () => {
-			const logger = createMockLogger();
-			const childLogger = logger.child({ module: 'test' });
-
-			expect(childLogger).toBe(logger);
-			expect(logger.child).toHaveBeenCalledWith({ module: 'test' });
-		});
-	});
-
-	describe('waitFor', () => {
-		it('should wait for the specified time', async () => {
-			const start = Date.now();
-			await waitFor(50);
-			const elapsed = Date.now() - start;
-
-			expect(elapsed).toBeGreaterThanOrEqual(40);
-			expect(elapsed).toBeLessThan(150);
-		});
-
-		it('should resolve without a value', async () => {
-			const result = await waitFor(10);
-			expect(result).toBeUndefined();
-		});
-	});
-
-	describe('AWS mock utilities', () => {
-		describe('createMockContext', () => {
-			it('should create a valid Lambda context', () => {
-				const context = createMockContext();
-
-				expect(context.awsRequestId).toBe('test-request-id');
-				expect(context.functionName).toBe('test-function');
-				expect(context.functionVersion).toBe('1');
-				expect(context.memoryLimitInMB).toBe('128');
-				expect(context.logGroupName).toBe('/aws/lambda/test-function');
-				expect(context.invokedFunctionArn).toContain('arn:aws:lambda');
-			});
-
-			it('should have mock callback functions', () => {
-				const context = createMockContext();
-
-				expect(context.done).toBeDefined();
-				expect(context.fail).toBeDefined();
-				expect(context.succeed).toBeDefined();
-
-				context.done();
-				context.fail(new Error('test'));
-				context.succeed('result');
-
-				expect(context.done).toHaveBeenCalled();
-				expect(context.fail).toHaveBeenCalled();
-				expect(context.succeed).toHaveBeenCalled();
-			});
-
-			it('should return remaining time', () => {
-				const context = createMockContext();
-				const remaining = context.getRemainingTimeInMillis();
-
-				expect(remaining).toBe(5000);
-			});
-		});
-
-		describe('createMockV1Event', () => {
-			it('should create a valid API Gateway V1 event', () => {
-				const event = createMockV1Event();
-
-				expect(event.httpMethod).toBe('GET');
-				expect(event.path).toBe('/test');
-				expect(event.headers['content-type']).toBe('application/json');
-				expect(event.requestContext.accountId).toBe('123456789012');
-				expect(event.requestContext.stage).toBe('test');
-			});
-
-			it('should allow overriding properties', () => {
-				const event = createMockV1Event({
-					httpMethod: 'POST',
-					path: '/users',
-					body: JSON.stringify({ name: 'test' }),
-					pathParameters: { id: '123' },
-					queryStringParameters: { page: '1' },
-				});
-
-				expect(event.httpMethod).toBe('POST');
-				expect(event.path).toBe('/users');
-				expect(event.body).toBe(JSON.stringify({ name: 'test' }));
-				expect(event.pathParameters).toEqual({ id: '123' });
-				expect(event.queryStringParameters).toEqual({ page: '1' });
-			});
-
-			it('should have correct identity fields', () => {
-				const event = createMockV1Event();
-
-				expect(event.requestContext.identity.sourceIp).toBe('127.0.0.1');
-				expect(event.requestContext.identity.userAgent).toBe('test-agent');
-			});
-		});
-
-		describe('createMockV2Event', () => {
-			it('should create a valid API Gateway V2 event', () => {
-				const event = createMockV2Event();
-
-				expect(event.version).toBe('2.0');
-				expect(event.routeKey).toBe('GET /test');
-				expect(event.rawPath).toBe('/test');
-				expect(event.headers['content-type']).toBe('application/json');
-				expect(event.requestContext.accountId).toBe('123456789012');
-			});
-
-			it('should allow overriding properties', () => {
-				const event = createMockV2Event({
-					routeKey: 'POST /users',
-					rawPath: '/users',
-					body: JSON.stringify({ name: 'test' }),
-					pathParameters: { id: '123' },
-					queryStringParameters: { page: '1' },
-				});
-
-				expect(event.routeKey).toBe('POST /users');
-				expect(event.rawPath).toBe('/users');
-				expect(event.body).toBe(JSON.stringify({ name: 'test' }));
-				expect(event.pathParameters).toEqual({ id: '123' });
-				expect(event.queryStringParameters).toEqual({ page: '1' });
-			});
-
-			it('should have correct HTTP context', () => {
-				const event = createMockV2Event();
-
-				expect(event.requestContext.http.method).toBe('GET');
-				expect(event.requestContext.http.path).toBe('/test');
-				expect(event.requestContext.http.sourceIp).toBe('127.0.0.1');
-				expect(event.requestContext.http.userAgent).toBe('test-agent');
-			});
-		});
-	});
-
-	describe('itWithDir', () => {
-		itWithDir('should provide a temporary directory', async ({ dir }) => {
-			expect(dir).toBeDefined();
-			expect(typeof dir).toBe('string');
-
-			// Directory should exist
-			const stat = await fs.stat(dir);
-			expect(stat.isDirectory()).toBe(true);
-		});
-
-		itWithDir(
-			'should allow creating files in the directory',
-			async ({ dir }) => {
-				const testFile = path.join(dir, 'test.txt');
-				await fs.writeFile(testFile, 'hello');
-
-				const content = await fs.readFile(testFile, 'utf-8');
-				expect(content).toBe('hello');
-			},
-		);
-
-		itWithDir('should provide unique directories per test', async ({ dir }) => {
-			// The directory should have a UUID-like name (uppercase hex)
-			const dirName = path.basename(dir);
-			expect(dirName).toMatch(/^[A-F0-9]{32}$/);
-			expect(dir.length).toBeGreaterThan(10);
-		});
-	});
-});

package/src/aws.ts

@@ -1,131 +0,0 @@
-import type {
-	APIGatewayProxyEvent,
-	APIGatewayProxyEventV2,
-	Context,
-} from 'aws-lambda';
-import { vi } from 'vitest';
-
-/**
- * Shared test utilities for AWS Lambda adapter testing
- */
-
-/**
- * Creates a mock AWS Lambda Context for testing
- */
-export function createMockContext(): Context {
-	return {
-		awsRequestId: 'test-request-id',
-		callbackWaitsForEmptyEventLoop: false,
-		functionName: 'test-function',
-		functionVersion: '1',
-		invokedFunctionArn:
-			'arn:aws:lambda:us-east-1:123456789012:function:test-function',
-		memoryLimitInMB: '128',
-		logGroupName: '/aws/lambda/test-function',
-		logStreamName: '2024/01/01/[$LATEST]abcdef123456',
-		getRemainingTimeInMillis: () => 5000,
-		done: vi.fn(),
-		fail: vi.fn(),
-		succeed: vi.fn(),
-	};
-}
-
-/**
- * Creates a mock AWS API Gateway V1 (REST API) event for testing
- */
-export function createMockV1Event(
-	overrides: Partial<APIGatewayProxyEvent> = {},
-): APIGatewayProxyEvent {
-	return {
-		body: null,
-		headers: {
-			'content-type': 'application/json',
-			'user-agent': 'test-agent',
-			host: 'test.example.com',
-		},
-		multiValueHeaders: {},
-		httpMethod: 'GET',
-		isBase64Encoded: false,
-		path: '/test',
-		pathParameters: null,
-		queryStringParameters: null,
-		multiValueQueryStringParameters: null,
-		stageVariables: null,
-		requestContext: {
-			accountId: '123456789012',
-			apiId: 'api-id',
-			authorizer: null,
-			protocol: 'HTTP/1.1',
-			httpMethod: 'GET',
-			path: '/test',
-			stage: 'test',
-			requestId: 'request-id',
-			requestTimeEpoch: 1704067200000,
-			resourceId: 'resource-id',
-			resourcePath: '/test',
-			identity: {
-				accessKey: null,
-				accountId: null,
-				apiKey: null,
-				apiKeyId: null,
-				caller: null,
-				cognitoAuthenticationProvider: null,
-				cognitoAuthenticationType: null,
-				cognitoIdentityId: null,
-				cognitoIdentityPoolId: null,
-				principalOrgId: null,
-				sourceIp: '127.0.0.1',
-				user: null,
-				userAgent: 'test-agent',
-				userArn: null,
-				clientCert: null,
-			},
-		},
-		resource: '/test',
-		...overrides,
-	};
-}
-
-/**
- * Creates a mock AWS API Gateway V2 (HTTP API) event for testing
- */
-export function createMockV2Event(
-	overrides: Partial<APIGatewayProxyEventV2> = {},
-): APIGatewayProxyEventV2 {
-	return {
-		version: '2.0',
-		routeKey: 'GET /test',
-		rawPath: '/test',
-		rawQueryString: '',
-		headers: {
-			'content-type': 'application/json',
-			'user-agent': 'test-agent',
-			host: 'test.example.com',
-		},
-		requestContext: {
-			accountId: '123456789012',
-			apiId: 'api-id',
-			domainName: 'test.example.com',
-			domainPrefix: 'api',
-			requestId: 'request-id',
-			routeKey: 'GET /test',
-			stage: 'test',
-			time: '01/Jan/2024:00:00:00 +0000',
-			timeEpoch: 1704067200000,
-			http: {
-				method: 'GET',
-				path: '/test',
-				protocol: 'HTTP/1.1',
-				sourceIp: '127.0.0.1',
-				userAgent: 'test-agent',
-			},
-		},
-		body: undefined,
-		pathParameters: undefined,
-		isBase64Encoded: false,
-		stageVariables: undefined,
-		queryStringParameters: undefined,
-		cookies: undefined,
-		...overrides,
-	};
-}

package/src/benchmark.ts

@@ -1,48 +0,0 @@
-/**
- * Generates an array of test records for benchmark data sets.
- *
- * @param count - Number of records to generate
- * @returns Array of test data objects
- */
-export function generateTestData(
-	count: number,
-): Array<{ id: string; name: string; value: number }> {
-	return Array.from({ length: count }, (_, i) => ({
-		id: `id-${i}`,
-		name: `Item ${i}`,
-		value: Math.random() * 1000,
-	}));
-}
-
-/**
- * Generates unique keys for cache benchmarks to avoid collisions.
- *
- * @param prefix - Key prefix
- * @param count - Number of keys to generate
- * @returns Array of unique cache keys
- */
-export function generateCacheKeys(prefix: string, count: number): string[] {
-	return Array.from({ length: count }, (_, i) => `${prefix}:${i}`);
-}
-
-/**
- * Generates IP addresses for rate limit benchmarks.
- *
- * @param count - Number of IPs to generate
- * @param subnet - Subnet prefix (default: '192.168.1')
- * @returns Array of IP addresses
- */
-export function generateIpAddresses(
-	count: number,
-	subnet: string = '192.168.1',
-): string[] {
-	return Array.from({ length: count }, (_, i) => `${subnet}.${i % 256}`);
-}
-
-/**
- * Creates a random IP address for rate limit benchmarks.
- */
-export function randomIpAddress(): string {
-	const octet = () => Math.floor(Math.random() * 256);
-	return `${octet()}.${octet()}.${octet()}.${octet()}`;
-}

package/src/better-auth.ts

@@ -1,310 +0,0 @@
-import {
-	createAdapterFactory,
-	type DBAdapterDebugLogOption,
-	type Where,
-} from 'better-auth/adapters';
-
-interface MemoryAdapterConfig {
-	debugLogs?: DBAdapterDebugLogOption;
-	usePlural?: boolean;
-	initialData?: Record<string, any[]>;
-}
-
-class MemoryStore {
-	constructor(
-		initialData?: Record<string, any[]>,
-		private readonly data: Map<string, any> = new Map(),
-	) {
-		if (initialData) {
-			for (const [model, records] of Object.entries(initialData)) {
-				const modelData = new Map();
-				for (const record of records) {
-					modelData.set(record.id, { ...record });
-				}
-				this.data.set(model, modelData);
-			}
-		}
-	}
-
-	getModel(modelName: string): Map<string, any> {
-		if (!this.data.has(modelName)) {
-			this.data.set(modelName, new Map());
-		}
-		return this.data.get(modelName)!;
-	}
-
-	clear() {
-		this.data.clear();
-	}
-
-	getAllData() {
-		const result: Record<string, any[]> = {};
-		for (const [model, records] of this.data.entries()) {
-			result[model] = Array.from(records.values());
-		}
-		return result;
-	}
-}
-
-function matchesWhere(record: any, where?: Where[]): boolean {
-	if (!where || where.length === 0) return true;
-
-	let result: boolean | null = null;
-
-	for (const condition of where) {
-		const { field, value, operator = 'eq', connector = 'AND' } = condition;
-		const recordValue = record[field];
-
-		let matches = false;
-
-		switch (operator) {
-			case 'eq':
-				matches = recordValue === value;
-				break;
-			case 'ne':
-				matches = recordValue !== value;
-				break;
-			case 'lt':
-				matches = value != null && recordValue < value;
-				break;
-			case 'lte':
-				matches = value != null && recordValue <= value;
-				break;
-			case 'gt':
-				matches = value != null && recordValue > value;
-				break;
-			case 'gte':
-				matches = value != null && recordValue >= value;
-				break;
-			case 'in':
-				matches =
-					Array.isArray(value) && (value as unknown[]).includes(recordValue);
-				break;
-			case 'not_in':
-				matches =
-					Array.isArray(value) && !(value as unknown[]).includes(recordValue);
-				break;
-			case 'contains':
-				matches =
-					typeof recordValue === 'string' &&
-					typeof value === 'string' &&
-					recordValue.includes(value);
-				break;
-			case 'starts_with':
-				matches =
-					typeof recordValue === 'string' &&
-					typeof value === 'string' &&
-					recordValue.startsWith(value);
-				break;
-			case 'ends_with':
-				matches =
-					typeof recordValue === 'string' &&
-					typeof value === 'string' &&
-					recordValue.endsWith(value);
-				break;
-			default:
-				matches = recordValue === value;
-		}
-
-		// Apply connector logic
-		if (result === null) {
-			result = matches;
-		} else if (connector === 'OR') {
-			result = result || matches;
-		} else {
-			// Default: AND
-			result = result && matches;
-		}
-	}
-
-	return result ?? true;
-}
-type SortBy = {
-	field: string;
-	direction: 'asc' | 'desc';
-};
-
-function applySorting(records: any[], sortBy?: SortBy): any[] {
-	if (!sortBy) return records;
-
-	const { field, direction } = sortBy;
-
-	return records.sort((a, b) => {
-		const aVal = a[field];
-		const bVal = b[field];
-
-		if (aVal === bVal) return 0;
-		if (aVal == null) return direction === 'asc' ? -1 : 1;
-		if (bVal == null) return direction === 'asc' ? 1 : -1;
-
-		const comparison = aVal < bVal ? -1 : 1;
-		return direction === 'asc' ? comparison : -comparison;
-	});
-}
-
-export const memoryAdapter = (
-	config: MemoryAdapterConfig = {},
-	store = new Map(),
-) => {
-	const storeInstance = new MemoryStore(config.initialData, store);
-
-	const adapterInstance = createAdapterFactory({
-		config: {
-			adapterId: 'memory-adapter',
-			adapterName: 'Memory Adapter',
-			usePlural: config.usePlural ?? false,
-			debugLogs: config.debugLogs ?? false,
-			supportsJSON: true,
-			supportsDates: true,
-			supportsBooleans: true,
-			supportsNumericIds: false,
-		},
-
-		// Note: The framework automatically transforms field names in both directions:
-		// - Input data is already transformed before reaching the adapter (e.g., email -> email_address)
-		// - Output data is automatically transformed after the adapter returns (e.g., email_address -> email)
-		// Therefore, we should NOT call transformInput or transformOutput ourselves.
-		adapter: ({ debugLog, getModelName, transformWhereClause }) => ({
-			create: async ({ data, model }) => {
-				debugLog('CREATE', { model, data });
-				const modelName = getModelName(model);
-				const modelData = storeInstance.getModel(modelName);
-
-				// Data is already transformed by the framework - store directly
-				const record = data as Record<string, unknown>;
-				if (!record.id) {
-					record.id = crypto.randomUUID();
-				}
-
-				const id = record.id as string;
-				modelData.set(id, { ...record });
-				return modelData.get(id);
-			},
-
-			findOne: async ({ where, model }) => {
-				debugLog('FIND_ONE', { model, where });
-				const modelName = getModelName(model);
-				const modelData = storeInstance.getModel(modelName);
-				const transformedWhere = transformWhereClause({ model, where });
-
-				for (const record of modelData.values()) {
-					if (matchesWhere(record, transformedWhere)) {
-						return record;
-					}
-				}
-				return null;
-			},
-
-			findMany: async ({ where, model, limit, offset, sortBy }) => {
-				debugLog('FIND_MANY', { model, where });
-
-				const modelName = getModelName(model);
-				const modelData = storeInstance.getModel(modelName);
-				const transformedWhere = transformWhereClause({ model, where });
-
-				let results = Array.from(modelData.values()).filter((record) =>
-					matchesWhere(record, transformedWhere),
-				);
-
-				if (sortBy) {
-					results = applySorting(results, sortBy);
-				}
-
-				if (offset) {
-					results = results.slice(offset);
-				}
-				if (limit) {
-					results = results.slice(0, limit);
-				}
-
-				return results;
-			},
-
-			update: async ({ where, update, model }) => {
-				debugLog('UPDATE', { model, where });
-
-				const modelName = getModelName(model);
-				const modelData = storeInstance.getModel(modelName);
-				const transformedWhere = transformWhereClause({ model, where });
-
-				for (const [id, record] of modelData.entries()) {
-					if (matchesWhere(record, transformedWhere)) {
-						// Update data is already transformed by the framework
-						const updated = { ...record, ...update };
-						modelData.set(id, updated);
-						return updated;
-					}
-				}
-				return null;
-			},
-
-			updateMany: async ({ where, update, model }) => {
-				debugLog('UPDATE_MANY', { model, where });
-				const modelName = getModelName(model);
-				const modelData = storeInstance.getModel(modelName);
-				const transformedWhere = transformWhereClause({ model, where });
-
-				let count = 0;
-
-				for (const [id, record] of modelData.entries()) {
-					if (matchesWhere(record, transformedWhere)) {
-						// Update data is already transformed by the framework
-						modelData.set(id, { ...record, ...update });
-						count++;
-					}
-				}
-				return count;
-			},
-
-			delete: async ({ where, model }) => {
-				debugLog('DELETE', { model, where });
-				const modelName = getModelName(model);
-				const modelData = storeInstance.getModel(modelName);
-				const transformedWhere = transformWhereClause({ model, where });
-
-				for (const [id, record] of modelData.entries()) {
-					if (matchesWhere(record, transformedWhere)) {
-						modelData.delete(id);
-						return;
-					}
-				}
-			},
-
-			deleteMany: async ({ where, model }) => {
-				debugLog('DELETE_MANY', { model, where });
-				const modelName = getModelName(model);
-				const modelData = storeInstance.getModel(modelName);
-				const transformedWhere = transformWhereClause({ model, where });
-
-				const toDelete: string[] = [];
-				for (const [id, record] of modelData.entries()) {
-					if (matchesWhere(record, transformedWhere)) {
-						toDelete.push(id);
-					}
-				}
-
-				for (const id of toDelete) {
-					modelData.delete(id);
-				}
-				return toDelete.length;
-			},
-
-			count: async ({ where, model }) => {
-				const modelName = getModelName(model);
-				const modelData = storeInstance.getModel(modelName);
-				const transformedWhere = transformWhereClause({ model, where });
-
-				return Array.from(modelData.values()).filter((record) =>
-					matchesWhere(record, transformedWhere),
-				).length;
-			},
-		}),
-	});
-
-	// Add utility methods to the adapter
-	return Object.assign(adapterInstance, {
-		clear: () => store.clear(),
-		getAllData: () => storeInstance.getAllData(),
-		getStore: () => store,
-	});
-};