@gencow/core 0.1.18 → 0.1.21

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

@@ -0,0 +1,196 @@
+/**
+ * Merge explicit partial insert rows with drizzle-seed-style values for missing columns.
+ * Uses drizzle-seed's `SeedService.selectGeneratorForPostgresColumn` 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 { SeedService } from "drizzle-seed";
+
+type SeedSvc = InstanceType<typeof SeedService>;
+type SeedTable = Parameters<SeedSvc["selectGeneratorForPostgresColumn"]>[0];
+type SeedColumn = Parameters<SeedSvc["selectGeneratorForPostgresColumn"]>[1];
+
+/** Fields drizzle-seed reads from ORM columns (mirrors `getPostgresInfo` in drizzle-seed). */
+type PgColumnSeedExtras = PgColumn & {
+  size?: number;
+  baseColumn?: PgColumn;
+};
+
+function pgColumnForSeed(column: PgColumn): PgColumnSeedExtras {
+  return column as PgColumnSeedExtras;
+}
+
+function hashSeed(str: string): number {
+  let h = 0;
+  for (let i = 0; i < str.length; i++) {
+    h = (Math.imul(31, h) + str.charCodeAt(i)) | 0;
+  }
+  return h >>> 0;
+}
+
+function getTypeParams(sqlType: string): SeedColumn["typeParams"] {
+  const typeParams: Record<string, number> = {};
+  if (sqlType.includes("[")) {
+    const match = sqlType.match(/\[\w*]/g);
+    if (match) {
+      typeParams.dimensions = match.length;
+    }
+  }
+  if (
+    sqlType.startsWith("numeric") ||
+    sqlType.startsWith("decimal") ||
+    sqlType.startsWith("double precision") ||
+    sqlType.startsWith("real")
+  ) {
+    const match = sqlType.match(/\((\d+), *(\d+)\)/);
+    if (match) {
+      typeParams.precision = Number(match[1]);
+      typeParams.scale = Number(match[2]);
+    }
+  } else if (
+    sqlType.startsWith("varchar") ||
+    sqlType.startsWith("bpchar") ||
+    sqlType.startsWith("char") ||
+    sqlType.startsWith("bit") ||
+    sqlType.startsWith("time") ||
+    sqlType.startsWith("timestamp") ||
+    sqlType.startsWith("interval")
+  ) {
+    const match = sqlType.match(/\((\d+)\)/);
+    if (match) {
+      typeParams.length = Number(match[1]);
+    }
+  }
+  return typeParams;
+}
+
+function getAllBaseColumns(baseColumn: PgColumn): NonNullable<SeedColumn["baseColumn"]> {
+  const b = pgColumnForSeed(baseColumn);
+  return {
+    name: baseColumn.name,
+    columnType: baseColumn.getSQLType(),
+    typeParams: getTypeParams(baseColumn.getSQLType()),
+    dataType: baseColumn.dataType,
+    size: b.size,
+    hasDefault: baseColumn.hasDefault,
+    default: baseColumn.default,
+    enumValues: baseColumn.enumValues,
+    isUnique: baseColumn.isUnique,
+    notNull: baseColumn.notNull,
+    primary: baseColumn.primary,
+    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 {
+  const colsMap = getTableColumns(pgTable) as Record<string, PgColumn>;
+  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),
+  };
+  });
+  const primaryKeys = Object.keys(colsMap).filter((k) => colsMap[k]!.primary);
+  return { name: schemaKey, columns, primaryKeys };
+}
+
+/**
+ * For each row, use explicit keys from `partialRows[i]`; for any other column, run the same
+ * generator drizzle-seed would use for that column type (same `generate({ i })` loop as seed).
+ *
+ * `schemaKey` for drizzle-seed defaults to `getTableName(pgTable)` (the SQL table name from
+ * `pgTable("name", …)`). Pass `options.schemaKey` only when you need a different seed namespace.
+ */
+export function fillPartialRowsForInsert<T extends PgTable>(
+  pgTable: T,
+  partialRows: Array<Partial<InferInsertModel<T>>>,
+  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 }
+  > = {};
+
+  for (const tsName of tsNames) {
+    const drizzleCol = colsMap[tsName]!;
+    if (drizzleCol.generatedIdentity?.type === "always") {
+      continue;
+    }
+    const needsGen = partialRows.some((p) => !Object.hasOwn(p, tsName));
+    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) {
+      throw new Error(
+        `[seed-like-fill] unsupported column type for ${schemaKey}.${tsName}: ${seedCol.columnType}`
+      );
+    }
+    const gen = seedService.selectVersionOfGenerator(rawGen);
+    const pRNGSeed = baseSeed + hashSeed(`${schemaKey}.${tsName}`);
+    gen.init({ count, seed: pRNGSeed });
+    generators[tsName] = gen;
+  }
+
+  const out: InferInsertModel<T>[] = [];
+  for (let i = 0; i < count; i++) {
+    const partial = partialRows[i]!;
+    const row: Record<string, unknown> = {};
+    for (const tsName of tsNames) {
+      const drizzleCol = colsMap[tsName]!;
+      if (drizzleCol.generatedIdentity?.type === "always") {
+        continue;
+      }
+      if (Object.hasOwn(partial, tsName)) {
+        row[tsName] = partial[tsName as keyof typeof partial];
+      } else {
+        const g = generators[tsName];
+        if (!g) {
+          throw new Error(
+            `[seed-like-fill] missing generator for ${schemaKey}.${tsName} (partial row without value)`
+          );
+        }
+        row[tsName] = g.generate({ i });
+      }
+    }
+    out.push(row as InferInsertModel<T>);
+  }
+  return out;
+}

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

@@ -0,0 +1,53 @@
+import { drizzle } from "drizzle-orm/pglite";
+
+import { createRlsDb } from "../../rls-db";
+import type { GencowCtx, UserIdentity } from "../../reactive";
+
+export function makeTestGencowCtxWithRls(
+  db: ReturnType<typeof drizzle>,
+  identity: UserIdentity
+): GencowCtx {
+  const scoped = createRlsDb(db, identity.id);
+  return {
+    db: scoped,
+    unsafeDb: db,
+    auth: {
+      getUserIdentity: () => identity,
+      requireAuth: () => identity,
+    },
+    storage: {} as GencowCtx["storage"],
+    scheduler: {} as GencowCtx["scheduler"],
+    realtime: { emit: () => {}, refresh: () => {} },
+    retry: async (fn) => fn(),
+  };
+}
+
+const FORCE_ROLLBACK = Symbol("force-rollback");
+
+/**
+ * Executes a callback inside one outer transaction and always rolls it back.
+ *
+ * This is useful for mutation tests: handlers can run multiple operations and
+ * see intermediate writes, but database state is discarded after the callback.
+ */
+export async function runWithRollbackTestGencowCtxWithRls<T>(
+  db: ReturnType<typeof drizzle>,
+  identity: UserIdentity,
+  run: (ctx: GencowCtx) => Promise<T>
+): Promise<T> {
+  let result!: T;
+
+  try {
+    await (db as any).transaction(async (outerTx: ReturnType<typeof drizzle>) => {
+      const txCtx = makeTestGencowCtxWithRls(outerTx, identity);
+      result = await run(txCtx);
+      throw FORCE_ROLLBACK;
+    });
+  } catch (error) {
+    if (error !== FORCE_ROLLBACK) {
+      throw error;
+    }
+  }
+
+  return result;
+}