@gencow/core 0.1.24 → 0.1.26

package/src/__tests__/helpers/pglite-migrations.ts

@@ -12,14 +12,11 @@ function listMigrationSqlFiles(migrationsDir: string): string[] {
 /**
  * Apply Drizzle-generated SQL from a folder of `.sql` files (split on `--> statement-breakpoint`).
  */
-export async function loadAndApplyMigrations(
-  client: PGlite,
-  migrationsDir: string
-): Promise<void> {
+export async function loadAndApplyMigrations(client: PGlite, migrationsDir: string): Promise<void> {
   const files = listMigrationSqlFiles(migrationsDir);
   if (files.length === 0) {
     throw new Error(
-      `No .sql migration files in ${migrationsDir} (generate migrations with your Drizzle workflow)`
+      `No .sql migration files in ${migrationsDir} (generate migrations with your Drizzle workflow)`,
     );
   }
   for (const filePath of files) {

package/src/__tests__/helpers/pglite-rls-session.ts

@@ -4,10 +4,10 @@ import type { PGlite } from "@electric-sql/pglite";
 export const DEFAULT_PGLITE_RLS_APP_ROLE = "gencow_rls_app";
 
 function quoteIdent(name: string): string {
-    if (!/^[a-z_][a-z0-9_]*$/i.test(name)) {
-        throw new Error(`Invalid SQL identifier: ${name}`);
-    }
-    return `"${name.replace(/"/g, '""')}"`;
+  if (!/^[a-z_][a-z0-9_]*$/i.test(name)) {
+    throw new Error(`Invalid SQL identifier: ${name}`);
+  }
+  return `"${name.replace(/"/g, '""')}"`;
 }
 
 /**
@@ -21,34 +21,31 @@ function quoteIdent(name: string): string {
  * Call {@link setPgliteSessionRole} on the same `PGlite` instance before running app queries.
  */
 export async function createPgliteRlsAppRole(
-    client: PGlite,
-    options?: { roleName?: string }
+  client: PGlite,
+  options?: { roleName?: string },
 ): Promise<string> {
-    const roleName = options?.roleName ?? DEFAULT_PGLITE_RLS_APP_ROLE;
-    const role = quoteIdent(roleName);
+  const roleName = options?.roleName ?? DEFAULT_PGLITE_RLS_APP_ROLE;
+  const role = quoteIdent(roleName);
 
-    await client.exec(`
+  await client.exec(`
 CREATE ROLE ${role} LOGIN;
 GRANT USAGE ON SCHEMA public TO ${role};
 GRANT SELECT, INSERT, UPDATE, DELETE ON ALL TABLES IN SCHEMA public TO ${role};
 GRANT USAGE, SELECT ON ALL SEQUENCES IN SCHEMA public TO ${role};
 `);
 
-    return roleName;
+  return roleName;
 }
 
 /**
  * Run follow-up queries in this session as the given role (must not be table owner so RLS applies).
  * The bootstrap user must be allowed to `SET ROLE` (e.g. superuser, or `GRANT rls_role TO bootstrap`).
  */
-export async function setPgliteSessionRole(
-    client: PGlite,
-    roleName: string
-): Promise<void> {
-    await client.exec(`SET ROLE ${quoteIdent(roleName)}`);
+export async function setPgliteSessionRole(client: PGlite, roleName: string): Promise<void> {
+  await client.exec(`SET ROLE ${quoteIdent(roleName)}`);
 }
 
 /** Restore session user to the original login role (typically the PGlite bootstrap user). */
 export async function resetPgliteSessionRole(client: PGlite): Promise<void> {
-    await client.exec("RESET ROLE");
+  await client.exec("RESET ROLE");
 }

package/src/__tests__/helpers/seed-like-fill.ts

@@ -1,17 +1,18 @@
 /**
  * Merge explicit partial insert rows with drizzle-seed-style values for missing columns.
- * Uses drizzle-seed's `SeedService.selectGeneratorForPostgresColumn` so new schema columns get
+ * Uses drizzle-seed's `SeedService.generatePossibleGenerators` so new schema columns get
  * the same generators as `seed()` without listing every column in test fixtures.
  */
 
 import { getTableColumns, getTableName } from "drizzle-orm";
 import type { InferInsertModel } from "drizzle-orm";
 import type { PgColumn, PgTable } from "drizzle-orm/pg-core";
+import { getTableConfig } from "drizzle-orm/pg-core";
 import { SeedService } from "drizzle-seed";
 
 type SeedSvc = InstanceType<typeof SeedService>;
-type SeedTable = Parameters<SeedSvc["selectGeneratorForPostgresColumn"]>[0];
-type SeedColumn = Parameters<SeedSvc["selectGeneratorForPostgresColumn"]>[1];
+type SeedTable = Parameters<SeedSvc["generatePossibleGenerators"]>[1][number];
+type SeedColumn = SeedTable["columns"][number];
 
 /** Fields drizzle-seed reads from ORM columns (mirrors `getPostgresInfo` in drizzle-seed). */
 type PgColumnSeedExtras = PgColumn & {
@@ -81,40 +82,40 @@ function getAllBaseColumns(baseColumn: PgColumn): NonNullable<SeedColumn["baseCo
     isUnique: baseColumn.isUnique,
     notNull: baseColumn.notNull,
     primary: baseColumn.primary,
-    baseColumn:
-      b.baseColumn === undefined ? undefined : getAllBaseColumns(b.baseColumn),
+    baseColumn: b.baseColumn === undefined ? undefined : getAllBaseColumns(b.baseColumn),
   };
 }
 
 /**
  * Drizzle `PgTable` → drizzle-seed `Table` (same shape as `getPostgresInfo` in drizzle-seed).
  */
-export function drizzlePgTableToSeedTable(
-  pgTable: PgTable,
-  schemaKey: string
-): SeedTable {
+export function drizzlePgTableToSeedTable(pgTable: PgTable, schemaKey: string): SeedTable {
   const colsMap = getTableColumns(pgTable) as Record<string, PgColumn>;
+  const tableConfig = getTableConfig(pgTable);
   const columns: SeedColumn[] = Object.entries(colsMap).map(([tsName, column]) => {
     const c = pgColumnForSeed(column);
     return {
-    name: tsName,
-    columnType: column.getSQLType(),
-    typeParams: getTypeParams(column.getSQLType()),
-    dataType: column.dataType,
-    size: c.size,
-    hasDefault: column.hasDefault,
-    default: column.default,
-    enumValues: column.enumValues,
-    isUnique: column.isUnique,
-    notNull: column.notNull,
-    primary: column.primary,
-    generatedIdentityType: column.generatedIdentity?.type,
-    baseColumn:
-      c.baseColumn === undefined ? undefined : getAllBaseColumns(c.baseColumn),
-  };
+      name: tsName,
+      columnType: column.getSQLType(),
+      typeParams: getTypeParams(column.getSQLType()),
+      dataType: column.dataType,
+      size: c.size,
+      hasDefault: column.hasDefault,
+      default: column.default,
+      enumValues: column.enumValues,
+      isUnique: column.isUnique,
+      notNull: column.notNull,
+      primary: column.primary,
+      generatedIdentityType: column.generatedIdentity?.type,
+      identity: column.generatedIdentity !== undefined,
+      baseColumn: c.baseColumn === undefined ? undefined : getAllBaseColumns(c.baseColumn),
+    };
   });
   const primaryKeys = Object.keys(colsMap).filter((k) => colsMap[k]!.primary);
-  return { name: schemaKey, columns, primaryKeys };
+  const uniqueConstraints = tableConfig.uniqueConstraints.map((uc) =>
+    uc.columns.map((c) => (c as PgColumn).name),
+  );
+  return { name: schemaKey, columns, primaryKeys, uniqueConstraints };
 }
 
 /**
@@ -127,22 +128,32 @@ export function drizzlePgTableToSeedTable(
 export function fillPartialRowsForInsert<T extends PgTable>(
   pgTable: T,
   partialRows: Array<Partial<InferInsertModel<T>>>,
-  options?: { seed?: number; version?: number; schemaKey?: string }
+  options?: { seed?: number; version?: number; schemaKey?: string },
 ): InferInsertModel<T>[] {
   const schemaKey = options?.schemaKey ?? getTableName(pgTable);
   const seedService = new SeedService();
-  /** `selectVersionOfGenerator` reads this; `seed()` sets it via `generatePossibleGenerators`. */
-  Reflect.set(seedService, "version", options?.version ?? 2);
   const seedTable = drizzlePgTableToSeedTable(pgTable, schemaKey);
   const colsMap = getTableColumns(pgTable) as Record<string, PgColumn>;
   const tsNames = Object.keys(colsMap);
   const baseSeed = options?.seed ?? 0;
   const count = partialRows.length;
 
-  const generators: Record<
-    string,
-    { generate: (args: { i: number }) => unknown }
-  > = {};
+  // Build generator map for all columns at once using the v1 API
+  const tablePossibleGens = seedService.generatePossibleGenerators(
+    "postgresql",
+    [seedTable],
+    [],
+    undefined,
+    { version: options?.version ?? 2 },
+  );
+  const colGenMap: Record<string, ReturnType<SeedSvc["selectVersionOfGenerator"]>> = {};
+  for (const colGen of tablePossibleGens[0]!.columnsPossibleGenerators) {
+    if (colGen.generator !== undefined) {
+      colGenMap[colGen.columnName] = seedService.selectVersionOfGenerator(colGen.generator);
+    }
+  }
+
+  const generators: Record<string, { generate: (args: { i: number }) => unknown }> = {};
 
   for (const tsName of tsNames) {
     const drizzleCol = colsMap[tsName]!;
@@ -153,17 +164,12 @@ export function fillPartialRowsForInsert<T extends PgTable>(
     if (!needsGen) {
       continue;
     }
-    const seedCol = seedTable.columns.find((c) => c.name === tsName);
-    if (!seedCol) {
-      throw new Error(`[seed-like-fill] column ${tsName} not in seed table`);
-    }
-    const rawGen = seedService.selectGeneratorForPostgresColumn(seedTable, seedCol);
-    if (rawGen === undefined) {
+    const gen = colGenMap[tsName];
+    if (gen === undefined) {
       throw new Error(
-        `[seed-like-fill] unsupported column type for ${schemaKey}.${tsName}: ${seedCol.columnType}`
+        `[seed-like-fill] unsupported column type for ${schemaKey}.${tsName}: ${drizzleCol.getSQLType()}`,
       );
     }
-    const gen = seedService.selectVersionOfGenerator(rawGen);
     const pRNGSeed = baseSeed + hashSeed(`${schemaKey}.${tsName}`);
     gen.init({ count, seed: pRNGSeed });
     generators[tsName] = gen;
@@ -184,7 +190,7 @@ export function fillPartialRowsForInsert<T extends PgTable>(
         const g = generators[tsName];
         if (!g) {
           throw new Error(
-            `[seed-like-fill] missing generator for ${schemaKey}.${tsName} (partial row without value)`
+            `[seed-like-fill] missing generator for ${schemaKey}.${tsName} (partial row without value)`,
           );
         }
         row[tsName] = g.generate({ i });

package/src/__tests__/helpers/test-gencow-ctx-rls.ts

@@ -1,12 +1,9 @@
 import { drizzle } from "drizzle-orm/pglite";
 
-import { createRlsDb } from "../../rls-db";
-import type { GencowCtx, UserIdentity } from "../../reactive";
+import { createRlsDb } from "../../rls-db.js";
+import type { GencowCtx, UserIdentity } from "../../reactive.js";
 
-export function makeTestGencowCtxWithRls(
-  db: ReturnType<typeof drizzle>,
-  identity: UserIdentity
-): GencowCtx {
+export function makeTestGencowCtxWithRls(db: ReturnType<typeof drizzle>, identity: UserIdentity): GencowCtx {
   const scoped = createRlsDb(db, { userId: identity.id });
   return {
     db: scoped,
@@ -33,7 +30,7 @@ const FORCE_ROLLBACK = Symbol("force-rollback");
 export async function runWithRollbackTestGencowCtxWithRls<T>(
   db: ReturnType<typeof drizzle>,
   identity: UserIdentity,
-  run: (ctx: GencowCtx) => Promise<T>
+  run: (ctx: GencowCtx) => Promise<T>,
 ): Promise<T> {
   let result!: T;
 

package/src/__tests__/httpaction.test.ts

@@ -7,116 +7,116 @@
  */
 
 import { describe, it, expect, beforeEach } from "bun:test";
-import { httpAction, getRegisteredHttpActions } from "../reactive";
+import { httpAction, getRegisteredHttpActions } from "../reactive.js";
 
 // Clean up httpAction registry between tests
 // Note: httpAction uses globalThis.__gencow_httpActionRegistry (push-only array)
 // We clear it in beforeEach to isolate tests.
 
 describe("httpAction()", () => {
-    const initialLength = getRegisteredHttpActions().length;
+  const initialLength = getRegisteredHttpActions().length;
 
-    it("httpAction 등록 시 레지스트리에 추가된다", () => {
-        const before = getRegisteredHttpActions().length;
+  it("httpAction 등록 시 레지스트리에 추가된다", () => {
+    const before = getRegisteredHttpActions().length;
 
-        httpAction({
-            method: "GET",
-            path: "/test/health",
-            handler: async () => ({ body: { status: "ok" } }),
-        });
-
-        const after = getRegisteredHttpActions().length;
-        expect(after).toBe(before + 1);
-    });
-
-    it("method, path가 정확히 설정된다", () => {
-        httpAction({
-            method: "POST",
-            path: "/webhook/stripe",
-            handler: async () => ({ body: { received: true } }),
-        });
-
-        const actions = getRegisteredHttpActions();
-        const last = actions[actions.length - 1];
-        expect(last.method).toBe("POST");
-        expect(last.path).toBe("/webhook/stripe");
+    httpAction({
+      method: "GET",
+      path: "/test/health",
+      handler: async () => ({ body: { status: "ok" } }),
     });
 
-    it("public 기본값은 false이다", () => {
-        httpAction({
-            method: "GET",
-            path: "/test/private",
-            handler: async () => ({ body: {} }),
-        });
+    const after = getRegisteredHttpActions().length;
+    expect(after).toBe(before + 1);
+  });
 
-        const actions = getRegisteredHttpActions();
-        const last = actions[actions.length - 1];
-        expect(last.isPublic).toBe(false);
+  it("method, path가 정확히 설정된다", () => {
+    httpAction({
+      method: "POST",
+      path: "/webhook/stripe",
+      handler: async () => ({ body: { received: true } }),
     });
 
-    it("public: true 설정 시 isPublic === true", () => {
-        httpAction({
-            method: "GET",
-            path: "/test/public-endpoint",
-            public: true,
-            handler: async () => ({ body: {} }),
-        });
-
-        const actions = getRegisteredHttpActions();
-        const last = actions[actions.length - 1];
-        expect(last.isPublic).toBe(true);
+    const actions = getRegisteredHttpActions();
+    const last = actions[actions.length - 1];
+    expect(last.method).toBe("POST");
+    expect(last.path).toBe("/webhook/stripe");
+  });
+
+  it("public 기본값은 false이다", () => {
+    httpAction({
+      method: "GET",
+      path: "/test/private",
+      handler: async () => ({ body: {} }),
     });
 
-    it("handler가 HttpActionDef에 포함된다", () => {
-        const handler = async () => ({ body: { ok: true } });
-        httpAction({
-            method: "PUT",
-            path: "/test/with-handler",
-            handler,
-        });
-
-        const actions = getRegisteredHttpActions();
-        const last = actions[actions.length - 1];
-        expect(last.handler).toBe(handler);
+    const actions = getRegisteredHttpActions();
+    const last = actions[actions.length - 1];
+    expect(last.isPublic).toBe(false);
+  });
+
+  it("public: true 설정 시 isPublic === true", () => {
+    httpAction({
+      method: "GET",
+      path: "/test/public-endpoint",
+      public: true,
+      handler: async () => ({ body: {} }),
     });
 
-    it("모든 HTTP 메서드 지원 (GET, POST, PUT, DELETE, PATCH)", () => {
-        const methods = ["GET", "POST", "PUT", "DELETE", "PATCH"] as const;
-        const before = getRegisteredHttpActions().length;
-
-        for (const method of methods) {
-            httpAction({
-                method,
-                path: `/test/method-${method.toLowerCase()}`,
-                handler: async () => ({ body: {} }),
-            });
-        }
-
-        const after = getRegisteredHttpActions().length;
-        expect(after).toBe(before + 5);
-
-        const actions = getRegisteredHttpActions();
-        const registered = actions.slice(-5).map(a => a.method);
-        expect(registered).toEqual(["GET", "POST", "PUT", "DELETE", "PATCH"]);
+    const actions = getRegisteredHttpActions();
+    const last = actions[actions.length - 1];
+    expect(last.isPublic).toBe(true);
+  });
+
+  it("handler가 HttpActionDef에 포함된다", () => {
+    const handler = async () => ({ body: { ok: true } });
+    httpAction({
+      method: "PUT",
+      path: "/test/with-handler",
+      handler,
     });
 
-    it("getRegisteredHttpActions()는 복사본을 반환한다 (원본 보호)", () => {
-        const a = getRegisteredHttpActions();
-        const b = getRegisteredHttpActions();
-        expect(a).not.toBe(b);
-        expect(a).toEqual(b);
+    const actions = getRegisteredHttpActions();
+    const last = actions[actions.length - 1];
+    expect(last.handler).toBe(handler);
+  });
+
+  it("모든 HTTP 메서드 지원 (GET, POST, PUT, DELETE, PATCH)", () => {
+    const methods = ["GET", "POST", "PUT", "DELETE", "PATCH"] as const;
+    const before = getRegisteredHttpActions().length;
+
+    for (const method of methods) {
+      httpAction({
+        method,
+        path: `/test/method-${method.toLowerCase()}`,
+        handler: async () => ({ body: {} }),
+      });
+    }
+
+    const after = getRegisteredHttpActions().length;
+    expect(after).toBe(before + 5);
+
+    const actions = getRegisteredHttpActions();
+    const registered = actions.slice(-5).map((a) => a.method);
+    expect(registered).toEqual(["GET", "POST", "PUT", "DELETE", "PATCH"]);
+  });
+
+  it("getRegisteredHttpActions()는 복사본을 반환한다 (원본 보호)", () => {
+    const a = getRegisteredHttpActions();
+    const b = getRegisteredHttpActions();
+    expect(a).not.toBe(b);
+    expect(a).toEqual(b);
+  });
+
+  it("Hono 경로 패턴 (/api/:id) 지원", () => {
+    httpAction({
+      method: "GET",
+      path: "/api/apps/:id/status",
+      public: true,
+      handler: async () => ({ body: {} }),
     });
 
-    it("Hono 경로 패턴 (/api/:id) 지원", () => {
-        httpAction({
-            method: "GET",
-            path: "/api/apps/:id/status",
-            public: true,
-            handler: async () => ({ body: {} }),
-        });
-
-        const actions = getRegisteredHttpActions();
-        const last = actions[actions.length - 1];
-        expect(last.path).toBe("/api/apps/:id/status");
-    });
+    const actions = getRegisteredHttpActions();
+    const last = actions[actions.length - 1];
+    expect(last.path).toBe("/api/apps/:id/status");
+  });
 });