Function initDrizzleClient

packages/core/fumadb/test/shared.ts:324–379

(
  factory: FumaDBFactory<Schemas>,
  version: Version,
  provider: Exclude<SQLProvider, "mssql" | "cockroachdb">,
)

}

export async function initDrizzleClient<
  Schemas extends AnySchema[],
  Version extends Schemas[number]["version"],
>(
  factory: FumaDBFactory<Schemas>,
  version: Version,
  provider: Exclude<SQLProvider, "mssql" | "cockroachdb">,
) {
  const DrizzleAPI = await import("drizzle-kit/api");
  const { drizzleAdapter } = await import("../src/adapters/drizzle");
  const test = drizzleTests.find((t) => t.provider === provider)!;

  const db = test.db({});

  const schema = factory
    .client(
      drizzleAdapter({
        db,
        provider,
      }),
    )
    .generateSchema(version);

  schema.path = path.join(import.meta.dirname, `drizzle-schema.${provider}.ts`);
  fs.writeFileSync(schema.path, schema.code);
  const drizzleSchema = await import(`${schema.path}?hash=${Date.now()}`);

  if (provider === "postgresql") {
    const { apply } = await DrizzleAPI.pushSchema(drizzleSchema, db as any);
    await apply();
  } else if (provider === "mysql") {
    const { sql } = await import("drizzle-orm");
    const prev = await DrizzleAPI.generateMySQLDrizzleJson({});
    const cur = await DrizzleAPI.generateMySQLDrizzleJson(drizzleSchema);
    const statements = await DrizzleAPI.generateMySQLMigration(prev, cur);

    for (const statement of statements) {
      await (db as any).execute(sql.raw(statement));
    }
  } else {
    // they need libsql
    const { apply } = await DrizzleAPI.pushSQLiteSchema(
      drizzleSchema,
      db as any,
    );
    await apply();
  }

  fs.rmSync(schema.path);
  return factory.client(
    drizzleAdapter({
      db: test.db(drizzleSchema),
      provider,
    }),
  );
}

export const cleanupFiles = () => {