@geekmidas/testkit 0.0.15 → 0.0.17

package/src/better-auth.ts

@@ -0,0 +1,327 @@
+import {
+  type DBAdapterDebugLogOption,
+  type Where,
+  createAdapterFactory,
+} 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 = recordValue < value;
+        break;
+      case 'lte':
+        matches = recordValue <= value;
+        break;
+      case 'gt':
+        matches = recordValue > value;
+        break;
+      case 'gte':
+        matches = recordValue >= value;
+        break;
+      case 'in':
+        matches = Array.isArray(value) && value.includes(recordValue);
+        break;
+      case 'not_in':
+        matches = Array.isArray(value) && !value.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,
+    },
+
+    adapter: ({
+      debugLog,
+      transformInput,
+      transformOutput,
+      getModelName,
+      transformWhereClause,
+    }) => ({
+      create: async ({ data, model, select }) => {
+        debugLog('CREATE', { model, data });
+        const modelName = getModelName(model);
+        const modelData = storeInstance.getModel(modelName);
+
+        const transformedData = await transformInput(data, model, 'create');
+
+        if (!transformedData.id) {
+          transformedData.id = crypto.randomUUID();
+        }
+
+        modelData.set(transformedData.id, { ...transformedData, ...data });
+
+        if (data.email_address) {
+          modelData.set(transformedData.id, {
+            ...transformedData,
+            email: data.email_address,
+          });
+        }
+        const created = modelData.get(transformedData.id);
+
+        const out = (await transformOutput(created, model, select)) as any;
+
+        return out;
+      },
+
+      findOne: async ({ where, model, select }) => {
+        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)) {
+            const t = (await transformOutput(record, model, select)) as any;
+
+            return t;
+          }
+        }
+        return null;
+      },
+
+      findMany: async ({ where, model, limit, offset, sortBy, select }) => {
+        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 Promise.all(
+          results.map(async (record) => {
+            const transformed = await transformOutput(record, model, select);
+
+            return transformed;
+          }),
+        );
+      },
+
+      update: async ({ where, update, model, select }) => {
+        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)) {
+            const transformedData = await transformInput(
+              update as any,
+              model,
+              'update',
+            );
+            const updated = { ...record, ...transformedData };
+            modelData.set(id, updated);
+            return transformOutput(updated, model, select) as any;
+          }
+        }
+        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;
+        const transformedData = await transformInput(update, model, 'update');
+
+        for (const [id, record] of modelData.entries()) {
+          if (matchesWhere(record, transformedWhere)) {
+            modelData.set(id, { ...record, ...transformedData });
+            count++;
+          }
+        }
+        return count;
+      },
+
+      delete: async ({ where, model }) => {
+        debugLog('DELETE', { model, where });
+        const modelName = getModelName(model);
+        const modelData = storeInstance.getModel(modelName);
+
+        for (const [id, record] of modelData.entries()) {
+          if (matchesWhere(record, where)) {
+            modelData.delete(id);
+            return;
+          }
+        }
+      },
+
+      deleteMany: async ({ where, model }) => {
+        debugLog('DELETE_MANY', { model, where });
+        const modelName = getModelName(model);
+        const modelData = storeInstance.getModel(modelName);
+
+        const toDelete: string[] = [];
+        for (const [id, record] of modelData.entries()) {
+          if (matchesWhere(record, where)) {
+            toDelete.push(id);
+          }
+        }
+
+        toDelete.forEach((id) => modelData.delete(id));
+        return toDelete.length;
+      },
+
+      count: async ({ where, model }) => {
+        const modelName = getModelName(model);
+        const modelData = storeInstance.getModel(modelName);
+
+        return Array.from(modelData.values()).filter((record) =>
+          matchesWhere(record, where),
+        ).length;
+      },
+    }),
+  });
+
+  // Add utility methods to the adapter
+  return Object.assign(adapterInstance, {
+    clear: () => store.clear(),
+    getAllData: () => storeInstance.getAllData(),
+    getStore: () => store,
+  });
+};

package/src/logger.ts

@@ -0,0 +1,18 @@
+import type { Logger } from '@geekmidas/logger';
+import { vi } from 'vitest';
+
+/**
+ * Creates a mock Logger for testing
+ */
+export function createMockLogger(): Logger {
+  const logger: Logger = {
+    debug: vi.fn(),
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+    fatal: vi.fn(),
+    trace: vi.fn(),
+    child: vi.fn(() => logger),
+  };
+  return logger;
+}

package/src/os/directory.ts

@@ -0,0 +1,21 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { it } from 'vitest';
+
+export const itWithDir = it.extend<DirectoryFixtures>({
+  // This fixture automatically provides a transaction to each test
+  dir: async ({}, use) => {
+    const tempDir = os.tmpdir();
+    const directoryName = crypto.randomUUID().replace(/-/g, '').toUpperCase();
+    const dir = path.join(tempDir, directoryName);
+    await fs.mkdir(dir, { recursive: true });
+    await use(dir);
+    await fs.rm(dir, { recursive: true, force: true });
+  },
+});
+
+export interface DirectoryFixtures {
+  dir: string;
+}

package/src/os/index.ts

@@ -0,0 +1 @@
+export { itWithDir } from './directory';

package/src/timer.ts

@@ -0,0 +1,3 @@
+export function waitFor(ms: number) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/dist/__tests__/Factory.spec.cjs

@@ -1,139 +0,0 @@
-const require_chunk = require('../chunk-CUT6urMc.cjs');
-const require_Factory = require('../Factory-WMhTNZ9S.cjs');
-const vitest = require_chunk.__toESM(require("vitest"));
-
-//#region src/__tests__/Factory.spec.ts
-var TestFactory = class extends require_Factory.Factory {
-	async insert(builderName, attrs) {
-		return Promise.resolve({
-			id: 1,
-			...attrs
-		});
-	}
-	async insertMany(count, builderName, attrs) {
-		const results = [];
-		for (let i = 0; i < count; i++) {
-			const newAttrs = typeof attrs === "function" ? attrs(i) : attrs;
-			results.push(await this.insert(builderName, newAttrs));
-		}
-		return results;
-	}
-	seed(seedName, attrs) {
-		return Promise.resolve({
-			seedResult: true,
-			...attrs
-		});
-	}
-};
-(0, vitest.describe)("Factory", () => {
-	(0, vitest.describe)("abstract class functionality", () => {
-		(0, vitest.it)("should be instantiable through concrete implementation", () => {
-			const factory = new TestFactory();
-			(0, vitest.expect)(factory).toBeInstanceOf(require_Factory.Factory);
-			(0, vitest.expect)(factory).toBeInstanceOf(TestFactory);
-		});
-		(0, vitest.it)("should have abstract methods defined", () => {
-			const factory = new TestFactory();
-			(0, vitest.expect)(typeof factory.insert).toBe("function");
-			(0, vitest.expect)(typeof factory.insertMany).toBe("function");
-			(0, vitest.expect)(typeof factory.seed).toBe("function");
-		});
-	});
-	(0, vitest.describe)("createSeed static method", () => {
-		(0, vitest.it)("should return the seed function unchanged", () => {
-			const seedFn = async (attrs, factory, db) => {
-				return {
-					id: 1,
-					name: "test"
-				};
-			};
-			const result = require_Factory.Factory.createSeed(seedFn);
-			(0, vitest.expect)(result).toBe(seedFn);
-			(0, vitest.expect)(typeof result).toBe("function");
-		});
-		(0, vitest.it)("should work with different seed function signatures", () => {
-			const simpleSeed = () => Promise.resolve({ simple: true });
-			const complexSeed = async (attrs, factory, db) => {
-				return {
-					name: attrs.name,
-					created: true
-				};
-			};
-			const result1 = require_Factory.Factory.createSeed(simpleSeed);
-			const result2 = require_Factory.Factory.createSeed(complexSeed);
-			(0, vitest.expect)(result1).toBe(simpleSeed);
-			(0, vitest.expect)(result2).toBe(complexSeed);
-		});
-	});
-	(0, vitest.describe)("concrete implementation behavior", () => {
-		let factory;
-		(0, vitest.beforeEach)(() => {
-			factory = new TestFactory();
-		});
-		(0, vitest.it)("should implement insert method", async () => {
-			const result = await factory.insert("testBuilder", { name: "test" });
-			(0, vitest.expect)(result).toEqual({
-				id: 1,
-				name: "test"
-			});
-		});
-		(0, vitest.it)("should implement insertMany method", async () => {
-			const results = await factory.insertMany(3, "testBuilder", { name: "test" });
-			(0, vitest.expect)(results).toHaveLength(3);
-			(0, vitest.expect)(results[0]).toEqual({
-				id: 1,
-				name: "test"
-			});
-		});
-		(0, vitest.it)("should implement insertMany with function attributes", async () => {
-			const results = await factory.insertMany(2, "testBuilder", (idx) => ({ name: `test${idx}` }));
-			(0, vitest.expect)(results).toHaveLength(2);
-			(0, vitest.expect)(results[0]).toEqual({
-				id: 1,
-				name: "test0"
-			});
-			(0, vitest.expect)(results[1]).toEqual({
-				id: 1,
-				name: "test1"
-			});
-		});
-		(0, vitest.it)("should implement seed method", async () => {
-			const result = await factory.seed("testSeed", { custom: "value" });
-			(0, vitest.expect)(result).toEqual({
-				seedResult: true,
-				custom: "value"
-			});
-		});
-	});
-	(0, vitest.describe)("type definitions", () => {
-		(0, vitest.it)("should properly type MixedFactoryBuilder", () => {
-			const syncBuilder = (attrs, factory, db) => ({ sync: true });
-			const asyncBuilder = async (attrs, factory, db) => ({ async: true });
-			(0, vitest.expect)(typeof syncBuilder).toBe("function");
-			(0, vitest.expect)(typeof asyncBuilder).toBe("function");
-		});
-		(0, vitest.it)("should properly type FactorySeed", () => {
-			const seed = async (attrs, factory, db) => ({ seeded: true });
-			(0, vitest.expect)(typeof seed).toBe("function");
-		});
-	});
-});
-(0, vitest.describe)("Factory types", () => {
-	(0, vitest.it)("should export MixedFactoryBuilder type", () => {
-		const builder = (attrs, factory, db) => {
-			return {
-				id: 1,
-				name: attrs.name
-			};
-		};
-		(0, vitest.expect)(typeof builder).toBe("function");
-	});
-	(0, vitest.it)("should export FactorySeed type", () => {
-		const seed = async (attrs, factory, db) => {
-			return { created: attrs.count };
-		};
-		(0, vitest.expect)(typeof seed).toBe("function");
-	});
-});
-
-//#endregion

package/dist/__tests__/Factory.spec.d.cts

@@ -1 +0,0 @@
-export { };

package/dist/__tests__/Factory.spec.d.mts

@@ -1 +0,0 @@
-export { };

package/dist/__tests__/Factory.spec.mjs

@@ -1,138 +0,0 @@
-import { Factory } from "../Factory-z2m01hMj.mjs";
-import { beforeEach, describe, expect, it } from "vitest";
-
-//#region src/__tests__/Factory.spec.ts
-var TestFactory = class extends Factory {
-	async insert(builderName, attrs) {
-		return Promise.resolve({
-			id: 1,
-			...attrs
-		});
-	}
-	async insertMany(count, builderName, attrs) {
-		const results = [];
-		for (let i = 0; i < count; i++) {
-			const newAttrs = typeof attrs === "function" ? attrs(i) : attrs;
-			results.push(await this.insert(builderName, newAttrs));
-		}
-		return results;
-	}
-	seed(seedName, attrs) {
-		return Promise.resolve({
-			seedResult: true,
-			...attrs
-		});
-	}
-};
-describe("Factory", () => {
-	describe("abstract class functionality", () => {
-		it("should be instantiable through concrete implementation", () => {
-			const factory = new TestFactory();
-			expect(factory).toBeInstanceOf(Factory);
-			expect(factory).toBeInstanceOf(TestFactory);
-		});
-		it("should have abstract methods defined", () => {
-			const factory = new TestFactory();
-			expect(typeof factory.insert).toBe("function");
-			expect(typeof factory.insertMany).toBe("function");
-			expect(typeof factory.seed).toBe("function");
-		});
-	});
-	describe("createSeed static method", () => {
-		it("should return the seed function unchanged", () => {
-			const seedFn = async (attrs, factory, db) => {
-				return {
-					id: 1,
-					name: "test"
-				};
-			};
-			const result = Factory.createSeed(seedFn);
-			expect(result).toBe(seedFn);
-			expect(typeof result).toBe("function");
-		});
-		it("should work with different seed function signatures", () => {
-			const simpleSeed = () => Promise.resolve({ simple: true });
-			const complexSeed = async (attrs, factory, db) => {
-				return {
-					name: attrs.name,
-					created: true
-				};
-			};
-			const result1 = Factory.createSeed(simpleSeed);
-			const result2 = Factory.createSeed(complexSeed);
-			expect(result1).toBe(simpleSeed);
-			expect(result2).toBe(complexSeed);
-		});
-	});
-	describe("concrete implementation behavior", () => {
-		let factory;
-		beforeEach(() => {
-			factory = new TestFactory();
-		});
-		it("should implement insert method", async () => {
-			const result = await factory.insert("testBuilder", { name: "test" });
-			expect(result).toEqual({
-				id: 1,
-				name: "test"
-			});
-		});
-		it("should implement insertMany method", async () => {
-			const results = await factory.insertMany(3, "testBuilder", { name: "test" });
-			expect(results).toHaveLength(3);
-			expect(results[0]).toEqual({
-				id: 1,
-				name: "test"
-			});
-		});
-		it("should implement insertMany with function attributes", async () => {
-			const results = await factory.insertMany(2, "testBuilder", (idx) => ({ name: `test${idx}` }));
-			expect(results).toHaveLength(2);
-			expect(results[0]).toEqual({
-				id: 1,
-				name: "test0"
-			});
-			expect(results[1]).toEqual({
-				id: 1,
-				name: "test1"
-			});
-		});
-		it("should implement seed method", async () => {
-			const result = await factory.seed("testSeed", { custom: "value" });
-			expect(result).toEqual({
-				seedResult: true,
-				custom: "value"
-			});
-		});
-	});
-	describe("type definitions", () => {
-		it("should properly type MixedFactoryBuilder", () => {
-			const syncBuilder = (attrs, factory, db) => ({ sync: true });
-			const asyncBuilder = async (attrs, factory, db) => ({ async: true });
-			expect(typeof syncBuilder).toBe("function");
-			expect(typeof asyncBuilder).toBe("function");
-		});
-		it("should properly type FactorySeed", () => {
-			const seed = async (attrs, factory, db) => ({ seeded: true });
-			expect(typeof seed).toBe("function");
-		});
-	});
-});
-describe("Factory types", () => {
-	it("should export MixedFactoryBuilder type", () => {
-		const builder = (attrs, factory, db) => {
-			return {
-				id: 1,
-				name: attrs.name
-			};
-		};
-		expect(typeof builder).toBe("function");
-	});
-	it("should export FactorySeed type", () => {
-		const seed = async (attrs, factory, db) => {
-			return { created: attrs.count };
-		};
-		expect(typeof seed).toBe("function");
-	});
-});
-
-//#endregion