@fragno-dev/test 2.0.0 → 2.0.2

package/src/test-adapters/drizzle-pglite.ts

@@ -0,0 +1,162 @@
+import { existsSync } from "node:fs";
+import { rm } from "node:fs/promises";
+
+import { SqlAdapter } from "@fragno-dev/db/adapters/sql";
+import { PGLiteDriverConfig } from "@fragno-dev/db/drivers";
+import type { SimpleQueryInterface } from "@fragno-dev/db/query";
+import type { AnySchema } from "@fragno-dev/db/schema";
+import { drizzle } from "drizzle-orm/pglite";
+import { KyselyPGlite } from "kysely-pglite";
+
+import { internalFragmentDef } from "@fragno-dev/db";
+
+import { PGlite } from "@electric-sql/pglite";
+
+import type { AdapterFactoryResult, DrizzlePgliteAdapter, SchemaConfig } from "../adapters";
+
+const createCommonTestContextMethods = (
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  ormMap: Map<string | null, SimpleQueryInterface<any, any>>,
+) => ({
+  getOrm: <TSchema extends AnySchema>(namespace: string | null): SimpleQueryInterface<TSchema> => {
+    const orm = ormMap.get(namespace);
+    if (!orm) {
+      throw new Error(`No ORM found for namespace: ${String(namespace)}`);
+    }
+    return orm as SimpleQueryInterface<TSchema>;
+  },
+});
+
+const runInternalFragmentMigrations = async (
+  adapter: SqlAdapter,
+): Promise<SchemaConfig | undefined> => {
+  const dependencies = internalFragmentDef.dependencies;
+  if (!dependencies) {
+    return undefined;
+  }
+
+  const databaseDeps = dependencies({
+    config: {},
+    options: { databaseAdapter: adapter, databaseNamespace: null },
+  });
+  if (databaseDeps?.schema) {
+    const migrations = adapter.prepareMigrations(databaseDeps.schema, databaseDeps.namespace);
+    await migrations.executeWithDriver(adapter.driver, 0);
+    return { schema: databaseDeps.schema, namespace: databaseDeps.namespace };
+  }
+  return undefined;
+};
+
+const resolveSchemaName = (adapter: SqlAdapter, namespace: string | null): string | null => {
+  if (adapter.namingStrategy.namespaceScope !== "schema") {
+    return null;
+  }
+  if (!namespace || namespace.length === 0) {
+    return null;
+  }
+  return adapter.namingStrategy.namespaceToSchema(namespace);
+};
+
+export async function createDrizzlePgliteAdapter(
+  config: DrizzlePgliteAdapter,
+  schemas: SchemaConfig[],
+): Promise<AdapterFactoryResult<DrizzlePgliteAdapter>> {
+  const databasePath = config.databasePath;
+  let internalSchemaConfig: SchemaConfig | undefined;
+
+  const createDatabase = async () => {
+    const pglite = new PGlite(databasePath);
+    const { dialect } = new KyselyPGlite(pglite);
+
+    const adapter = new SqlAdapter({
+      dialect,
+      driverConfig: new PGLiteDriverConfig(),
+      uowConfig: config.uowConfig,
+    });
+
+    internalSchemaConfig = await runInternalFragmentMigrations(adapter);
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const ormMap = new Map<string | null, SimpleQueryInterface<any, any>>();
+    for (const { schema, namespace, migrateToVersion } of schemas) {
+      const preparedMigrations = adapter.prepareMigrations(schema, namespace);
+      if (migrateToVersion !== undefined) {
+        await preparedMigrations.execute(0, migrateToVersion, {
+          updateVersionInMigration: false,
+        });
+      } else {
+        await preparedMigrations.execute(0, schema.version, { updateVersionInMigration: false });
+      }
+
+      const orm = adapter.createQueryEngine(schema, namespace);
+      ormMap.set(namespace, orm);
+    }
+
+    // oxlint-disable-next-line typescript/no-explicit-any
+    const db = drizzle(pglite) as any;
+
+    return { drizzle: db, adapter, ormMap };
+  };
+
+  const { drizzle: drizzleDb, adapter, ormMap } = await createDatabase();
+
+  const resetDatabase = async () => {
+    if (databasePath && databasePath !== ":memory:") {
+      throw new Error("resetDatabase is only supported for in-memory databases");
+    }
+
+    const schemasToTruncate = internalSchemaConfig ? [internalSchemaConfig, ...schemas] : schemas;
+    const useTruncate = adapter.adapterMetadata?.databaseType === "postgresql";
+
+    for (const { schema, namespace } of schemasToTruncate) {
+      const tableNames = Object.keys(schema.tables);
+      if (useTruncate) {
+        const qualifiedTables = tableNames.map((tableName) => {
+          const physicalTableName = adapter.namingStrategy.tableName(tableName, namespace);
+          const schemaName = resolveSchemaName(adapter, namespace);
+          return schemaName ? `"${schemaName}"."${physicalTableName}"` : `"${physicalTableName}"`;
+        });
+        if (qualifiedTables.length > 0) {
+          await drizzleDb.execute(`TRUNCATE ${qualifiedTables.join(", ")} CASCADE`);
+        }
+        continue;
+      }
+
+      for (const tableName of tableNames.slice().reverse()) {
+        const physicalTableName = adapter.namingStrategy.tableName(tableName, namespace);
+        const schemaName = resolveSchemaName(adapter, namespace);
+        const qualifiedTable = schemaName
+          ? `"${schemaName}"."${physicalTableName}"`
+          : `"${physicalTableName}"`;
+        await drizzleDb.execute(`DELETE FROM ${qualifiedTable}`);
+      }
+    }
+  };
+
+  const cleanup = async () => {
+    await adapter.close();
+
+    if (databasePath && databasePath !== ":memory:" && existsSync(databasePath)) {
+      await rm(databasePath, { recursive: true, force: true });
+    }
+  };
+
+  const commonMethods = createCommonTestContextMethods(ormMap);
+
+  return {
+    testContext: {
+      get drizzle() {
+        return drizzleDb;
+      },
+      get adapter() {
+        return adapter;
+      },
+      ...commonMethods,
+      resetDatabase,
+      cleanup,
+    },
+    get adapter() {
+      return adapter;
+    },
+  };
+}

package/src/test-adapters/in-memory.ts

@@ -0,0 +1,56 @@
+import { InMemoryAdapter } from "@fragno-dev/db/adapters/in-memory";
+import type { SimpleQueryInterface } from "@fragno-dev/db/query";
+import type { AnySchema } from "@fragno-dev/db/schema";
+
+import type { AdapterFactoryResult, InMemoryAdapterConfig, SchemaConfig } from "../adapters";
+
+const createCommonTestContextMethods = (
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  ormMap: Map<string | null, SimpleQueryInterface<any, any>>,
+) => ({
+  getOrm: <TSchema extends AnySchema>(namespace: string | null): SimpleQueryInterface<TSchema> => {
+    const orm = ormMap.get(namespace);
+    if (!orm) {
+      throw new Error(`No ORM found for namespace: ${String(namespace)}`);
+    }
+    return orm as SimpleQueryInterface<TSchema>;
+  },
+});
+
+export async function createInMemoryAdapter(
+  config: InMemoryAdapterConfig,
+  schemas: SchemaConfig[],
+): Promise<AdapterFactoryResult<InMemoryAdapterConfig>> {
+  const adapter = new InMemoryAdapter(config.options);
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const ormMap = new Map<string | null, SimpleQueryInterface<any, any>>();
+  for (const { schema, namespace } of schemas) {
+    const orm = adapter.createQueryEngine(schema, namespace);
+    ormMap.set(namespace, orm);
+  }
+
+  const resetDatabase = async () => {
+    await adapter.reset();
+  };
+
+  const cleanup = async () => {
+    await adapter.close();
+  };
+
+  const commonMethods = createCommonTestContextMethods(ormMap);
+
+  return {
+    testContext: {
+      get adapter() {
+        return adapter;
+      },
+      ...commonMethods,
+      resetDatabase,
+      cleanup,
+    },
+    get adapter() {
+      return adapter;
+    },
+  };
+}

package/src/test-adapters/kysely-pglite.ts

@@ -0,0 +1,151 @@
+import { existsSync } from "node:fs";
+import { rm } from "node:fs/promises";
+
+import { SqlAdapter } from "@fragno-dev/db/adapters/sql";
+import { PGLiteDriverConfig } from "@fragno-dev/db/drivers";
+import type { SimpleQueryInterface } from "@fragno-dev/db/query";
+import type { AnySchema } from "@fragno-dev/db/schema";
+import { Kysely } from "kysely";
+import { KyselyPGlite } from "kysely-pglite";
+
+import { internalFragmentDef } from "@fragno-dev/db";
+
+import type { AdapterFactoryResult, KyselyPgliteAdapter, SchemaConfig } from "../adapters";
+
+const createCommonTestContextMethods = (
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  ormMap: Map<string | null, SimpleQueryInterface<any, any>>,
+) => ({
+  getOrm: <TSchema extends AnySchema>(namespace: string | null): SimpleQueryInterface<TSchema> => {
+    const orm = ormMap.get(namespace);
+    if (!orm) {
+      throw new Error(`No ORM found for namespace: ${String(namespace)}`);
+    }
+    return orm as SimpleQueryInterface<TSchema>;
+  },
+});
+
+const runInternalFragmentMigrations = async (
+  adapter: SqlAdapter,
+): Promise<SchemaConfig | undefined> => {
+  const dependencies = internalFragmentDef.dependencies;
+  if (!dependencies) {
+    return undefined;
+  }
+
+  const databaseDeps = dependencies({
+    config: {},
+    options: { databaseAdapter: adapter, databaseNamespace: null },
+  });
+  if (databaseDeps?.schema) {
+    const migrations = adapter.prepareMigrations(databaseDeps.schema, databaseDeps.namespace);
+    await migrations.executeWithDriver(adapter.driver, 0);
+    return { schema: databaseDeps.schema, namespace: databaseDeps.namespace };
+  }
+  return undefined;
+};
+
+const resolveSchemaName = (adapter: SqlAdapter, namespace: string | null): string | null => {
+  if (adapter.namingStrategy.namespaceScope !== "schema") {
+    return null;
+  }
+  if (!namespace || namespace.length === 0) {
+    return null;
+  }
+  return adapter.namingStrategy.namespaceToSchema(namespace);
+};
+
+export async function createKyselyPgliteAdapter(
+  config: KyselyPgliteAdapter,
+  schemas: SchemaConfig[],
+): Promise<AdapterFactoryResult<KyselyPgliteAdapter>> {
+  const databasePath = config.databasePath;
+  let internalSchemaConfig: SchemaConfig | undefined;
+
+  const createDatabase = async () => {
+    const kyselyPglite = await KyselyPGlite.create(databasePath);
+
+    // oxlint-disable-next-line typescript/no-explicit-any
+    const kysely = new Kysely<any>({
+      dialect: kyselyPglite.dialect,
+    });
+
+    const adapter = new SqlAdapter({
+      dialect: kyselyPglite.dialect,
+      driverConfig: new PGLiteDriverConfig(),
+      uowConfig: config.uowConfig,
+    });
+    internalSchemaConfig = await runInternalFragmentMigrations(adapter);
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const ormMap = new Map<string | null, SimpleQueryInterface<any, any>>();
+
+    for (const { schema, namespace, migrateToVersion } of schemas) {
+      const preparedMigrations = adapter.prepareMigrations(schema, namespace);
+      if (migrateToVersion !== undefined) {
+        await preparedMigrations.execute(0, migrateToVersion, {
+          updateVersionInMigration: false,
+        });
+      } else {
+        await preparedMigrations.execute(0, schema.version, { updateVersionInMigration: false });
+      }
+
+      const orm = adapter.createQueryEngine(schema, namespace);
+      ormMap.set(namespace, orm);
+    }
+
+    return { kysely, adapter, kyselyPglite, ormMap };
+  };
+
+  const { kysely, adapter, kyselyPglite, ormMap } = await createDatabase();
+
+  const resetDatabase = async () => {
+    if (databasePath && databasePath !== ":memory:") {
+      throw new Error("resetDatabase is only supported for in-memory databases");
+    }
+
+    const schemasToTruncate = internalSchemaConfig ? [internalSchemaConfig, ...schemas] : schemas;
+
+    for (const { schema, namespace } of schemasToTruncate) {
+      for (const tableName of Object.keys(schema.tables)) {
+        const physicalTableName = adapter.namingStrategy.tableName(tableName, namespace);
+        const schemaName = resolveSchemaName(adapter, namespace);
+        const scopedKysely = schemaName ? kysely.withSchema(schemaName) : kysely;
+        await scopedKysely.deleteFrom(physicalTableName).execute();
+      }
+    }
+  };
+
+  const cleanup = async () => {
+    await kysely.destroy();
+
+    try {
+      await kyselyPglite.client.close();
+    } catch {
+      // Ignore if already closed
+    }
+
+    if (databasePath && databasePath !== ":memory:" && existsSync(databasePath)) {
+      await rm(databasePath, { recursive: true, force: true });
+    }
+  };
+
+  const commonMethods = createCommonTestContextMethods(ormMap);
+
+  return {
+    testContext: {
+      get kysely() {
+        return kysely;
+      },
+      get adapter() {
+        return adapter;
+      },
+      ...commonMethods,
+      resetDatabase,
+      cleanup,
+    },
+    get adapter() {
+      return adapter;
+    },
+  };
+}

package/src/test-adapters/kysely-sqlite.ts

@@ -0,0 +1,119 @@
+import { SqlAdapter } from "@fragno-dev/db/adapters/sql";
+import { SQLocalDriverConfig } from "@fragno-dev/db/drivers";
+import type { SimpleQueryInterface } from "@fragno-dev/db/query";
+import type { AnySchema } from "@fragno-dev/db/schema";
+import { Kysely } from "kysely";
+import { SQLocalKysely } from "sqlocal/kysely";
+
+import { internalFragmentDef } from "@fragno-dev/db";
+
+import type { KyselySqliteAdapter, AdapterFactoryResult, SchemaConfig } from "../adapters";
+
+const createCommonTestContextMethods = (
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  ormMap: Map<string | null, SimpleQueryInterface<any, any>>,
+) => ({
+  getOrm: <TSchema extends AnySchema>(namespace: string | null): SimpleQueryInterface<TSchema> => {
+    const orm = ormMap.get(namespace);
+    if (!orm) {
+      throw new Error(`No ORM found for namespace: ${String(namespace)}`);
+    }
+    return orm as SimpleQueryInterface<TSchema>;
+  },
+});
+
+const runInternalFragmentMigrations = async (
+  adapter: SqlAdapter,
+): Promise<SchemaConfig | undefined> => {
+  const dependencies = internalFragmentDef.dependencies;
+  if (!dependencies) {
+    return undefined;
+  }
+
+  const databaseDeps = dependencies({
+    config: {},
+    options: { databaseAdapter: adapter, databaseNamespace: null },
+  });
+  if (databaseDeps?.schema) {
+    const migrations = adapter.prepareMigrations(databaseDeps.schema, databaseDeps.namespace);
+    await migrations.executeWithDriver(adapter.driver, 0);
+    return { schema: databaseDeps.schema, namespace: databaseDeps.namespace };
+  }
+  return undefined;
+};
+
+export async function createKyselySqliteAdapter(
+  config: KyselySqliteAdapter,
+  schemas: SchemaConfig[],
+): Promise<AdapterFactoryResult<KyselySqliteAdapter>> {
+  let internalSchemaConfig: SchemaConfig | undefined;
+
+  const createDatabase = async () => {
+    const { dialect } = new SQLocalKysely(":memory:");
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const kysely = new Kysely<any>({
+      dialect,
+    });
+
+    const adapter = new SqlAdapter({
+      dialect,
+      driverConfig: new SQLocalDriverConfig(),
+      uowConfig: config.uowConfig,
+    });
+    internalSchemaConfig = await runInternalFragmentMigrations(adapter);
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const ormMap = new Map<string | null, SimpleQueryInterface<any, any>>();
+    for (const { schema, namespace, migrateToVersion } of schemas) {
+      const preparedMigrations = adapter.prepareMigrations(schema, namespace);
+      if (migrateToVersion !== undefined) {
+        await preparedMigrations.execute(0, migrateToVersion, {
+          updateVersionInMigration: false,
+        });
+      } else {
+        await preparedMigrations.execute(0, schema.version, { updateVersionInMigration: false });
+      }
+
+      const orm = adapter.createQueryEngine(schema, namespace);
+      ormMap.set(namespace, orm);
+    }
+
+    return { kysely, adapter, ormMap };
+  };
+
+  let { kysely, adapter, ormMap } = await createDatabase();
+
+  const resetDatabase = async () => {
+    const schemasToTruncate = internalSchemaConfig ? [internalSchemaConfig, ...schemas] : schemas;
+
+    for (const { schema, namespace } of schemasToTruncate) {
+      for (const tableName of Object.keys(schema.tables)) {
+        const physicalTableName = adapter.namingStrategy.tableName(tableName, namespace);
+        await kysely.deleteFrom(physicalTableName).execute();
+      }
+    }
+  };
+
+  const cleanup = async () => {
+    await kysely.destroy();
+  };
+
+  const commonMethods = createCommonTestContextMethods(ormMap);
+
+  return {
+    testContext: {
+      get kysely() {
+        return kysely;
+      },
+      get adapter() {
+        return adapter;
+      },
+      ...commonMethods,
+      resetDatabase,
+      cleanup,
+    },
+    get adapter() {
+      return adapter;
+    },
+  };
+}

package/src/test-adapters/model-checker.ts

@@ -0,0 +1,58 @@
+import { InMemoryAdapter } from "@fragno-dev/db/adapters/in-memory";
+import type { SimpleQueryInterface } from "@fragno-dev/db/query";
+import type { AnySchema } from "@fragno-dev/db/schema";
+
+import type { AdapterFactoryResult, ModelCheckerAdapterConfig, SchemaConfig } from "../adapters";
+import { ModelCheckerAdapter } from "../model-checker-adapter";
+
+const createCommonTestContextMethods = (
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  ormMap: Map<string | null, SimpleQueryInterface<any, any>>,
+) => ({
+  getOrm: <TSchema extends AnySchema>(namespace: string | null): SimpleQueryInterface<TSchema> => {
+    const orm = ormMap.get(namespace);
+    if (!orm) {
+      throw new Error(`No ORM found for namespace: ${String(namespace)}`);
+    }
+    return orm as SimpleQueryInterface<TSchema>;
+  },
+});
+
+export async function createModelCheckerAdapter(
+  config: ModelCheckerAdapterConfig,
+  schemas: SchemaConfig[],
+): Promise<AdapterFactoryResult<ModelCheckerAdapterConfig>> {
+  const baseAdapter = new InMemoryAdapter(config.options);
+  const adapter = new ModelCheckerAdapter(baseAdapter);
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const ormMap = new Map<string | null, SimpleQueryInterface<any, any>>();
+  for (const { schema, namespace } of schemas) {
+    const orm = adapter.createQueryEngine(schema, namespace);
+    ormMap.set(namespace, orm);
+  }
+
+  const resetDatabase = async () => {
+    await baseAdapter.reset();
+  };
+
+  const cleanup = async () => {
+    await adapter.close();
+  };
+
+  const commonMethods = createCommonTestContextMethods(ormMap);
+
+  return {
+    testContext: {
+      get adapter() {
+        return adapter;
+      },
+      ...commonMethods,
+      resetDatabase,
+      cleanup,
+    },
+    get adapter() {
+      return adapter;
+    },
+  };
+}

package/tsconfig.json

@@ -1,5 +1,5 @@
 {
-  "extends": "@fragno-private/typescript-config/tsconfig.base.json",
+  "extends": "@fragno-private/typescript-config/tsconfig.node.json",
   "compilerOptions": {
     "outDir": "./dist",
     "rootDir": ".",

package/vitest.config.ts

@@ -1,4 +1,5 @@
 import { defineConfig, mergeConfig } from "vitest/config";
+
 import { baseConfig } from "@fragno-private/vitest-config";
 
 export default defineConfig(mergeConfig(baseConfig, {}));