@cfast/db 0.6.0 → 0.7.0

package/dist/seed.d.ts

@@ -1,6 +1,9 @@
 import { DrizzleTable } from '@cfast/permissions';
 import { a as Db, i as InferRow } from './types-FUFR36h1.js';
 import { Column } from 'drizzle-orm';
+import { SQLiteColumnBuilderBase, SQLiteTableExtraConfigValue } from 'drizzle-orm/sqlite-core';
+import { BuildColumns } from 'drizzle-orm/column-builder';
+import { SQLiteTableWithColumns } from 'drizzle-orm/sqlite-core/table';
 
 /**
  * Schema-driven seed generator for `@cfast/db`.
@@ -52,12 +55,30 @@ type SeedRunOptions = {
     /** If provided, write the equivalent SQL INSERT statements to this path. */
     transcript?: string;
 };
+/**
+ * Stores column-level seed functions keyed by the column builder's `config`
+ * object. Drizzle shares the same `config` reference between the builder
+ * (what the user passes to `sqliteTable(...)`) and the built column (what
+ * `getTableColumns()` returns), so we can look up the seed fn from either
+ * side. This avoids the builder-vs-column identity mismatch.
+ *
+ * Exported so the `.seed()` prototype patches in `seed.ts` can write to
+ * the same registries. Application code should use `.seed()` or
+ * `seedConfig()`/`tableSeed()` rather than accessing these directly.
+ */
+declare const columnSeedMap: WeakMap<object, ColumnSeedFn>;
+declare const tableSeedMap: WeakMap<object, TableSeedConfig>;
 /**
  * Attaches a seed generator function to a Drizzle column.
  *
  * The column object is returned unmodified so this can be used inline in
  * schema definitions without breaking Drizzle types.
  *
+ * @deprecated Use the `.seed()` method on column builders instead:
+ * ```ts
+ * text("title").seed(f => f.lorem.sentence())
+ * ```
+ *
  * @example
  * ```ts
  * const posts = sqliteTable("posts", {
@@ -69,6 +90,12 @@ declare function seedConfig<T>(column: T, fn: ColumnSeedFn): T;
 /**
  * Attaches table-level seed config (count, per) to a Drizzle table.
  *
+ * @deprecated Use `table()` from `@cfast/db/seed` with `.seed()` instead:
+ * ```ts
+ * import { table } from "@cfast/db/seed";
+ * const posts = table("posts", { ... }).seed({ count: 5, per: users });
+ * ```
+ *
  * @example
  * ```ts
  * const posts = tableSeed(
@@ -139,6 +166,49 @@ declare function createSingleTableSeed(schema: Record<string, unknown>, table: D
  */
 declare function isTable(value: unknown): boolean;
 
+declare module "drizzle-orm/sqlite-core" {
+    interface SQLiteColumnBuilder<T, TRuntimeConfig, TTypeConfig, TExtraConfig> {
+        /**
+         * Attaches a seed generator function to this column.
+         *
+         * @example
+         * ```ts
+         * title: text("title").seed(f => f.lorem.sentence()),
+         * ```
+         */
+        seed(fn: ColumnSeedFn): this;
+    }
+}
+
+/**
+ * Type representing a Drizzle table with an added `.seed()` method.
+ * The `.seed()` method returns the same table reference for chaining.
+ */
+type SeedableTable<T> = T & {
+    seed(config: TableSeedConfig): SeedableTable<T>;
+};
+/**
+ * Creates a SQLite table with a `.seed()` method for configuring
+ * seed generation. Drop-in replacement for `sqliteTable()` from
+ * `drizzle-orm/sqlite-core`.
+ *
+ * @example
+ * ```ts
+ * import { table } from "@cfast/db/seed";
+ *
+ * const posts = table("posts", {
+ *   title: text("title").seed(f => f.lorem.sentence()),
+ *   authorId: text("author_id").references(() => users.id),
+ * }).seed({ count: 5, per: users });
+ * ```
+ */
+declare function table<TTableName extends string, TColumnsMap extends Record<string, SQLiteColumnBuilderBase>>(name: TTableName, columns: TColumnsMap, extraConfig?: (self: BuildColumns<TTableName, TColumnsMap, "sqlite">) => SQLiteTableExtraConfigValue[]): SeedableTable<SQLiteTableWithColumns<{
+    name: TTableName;
+    schema: undefined;
+    columns: BuildColumns<TTableName, TColumnsMap, "sqlite">;
+    dialect: "sqlite";
+}>>;
+
 /**
  * One-liner seed: introspects the schema from the `db` instance, generates
  * realistic data via the bundled `@faker-js/faker`, and inserts it.
@@ -154,7 +224,7 @@ declare function isTable(value: unknown): boolean;
  */
 declare function seed(db: Db, options?: SeedRunOptions): Promise<void>;
 /**
- * A single seed entry — every row in `rows` is inserted into `table` at seed
+ * A single seed entry -- every row in `rows` is inserted into `table` at seed
  * time. Row shape is inferred from the Drizzle table so typos in column names
  * are caught by `tsc` instead of failing at runtime when `INSERT` rejects
  * the statement.
@@ -171,7 +241,7 @@ type SeedEntry<TTable extends DrizzleTable = DrizzleTable> = {
     table: TTable;
     /**
      * Rows to insert. The row shape is inferred from the table's
-     * `$inferSelect` — making a typo in a column name is a compile-time error.
+     * `$inferSelect` -- making a typo in a column name is a compile-time error.
      *
      * Entries are inserted in the order they appear, which lets you control
      * foreign-key ordering just by ordering your `entries` array
@@ -203,7 +273,7 @@ type Seed = {
     /**
      * Executes every entry against the given {@link Db} in the order they were
      * declared. Uses `db.unsafe()` internally so seed scripts don't need
-     * their own grants plumbing — seeding is a system task by definition.
+     * their own grants plumbing -- seeding is a system task by definition.
      *
      * Entries with an empty `rows` array are skipped so callers can leave
      * placeholder entries in the config without crashing the seed.
@@ -255,4 +325,4 @@ type Seed = {
  */
 declare function defineSeed(config: SeedConfig): Seed;
 
-export { type ColumnSeedFn, type Faker, type Seed, type SeedConfig, type SeedContext, type SeedEntry, type SeedRunOptions, type TableSeedConfig, createSeedEngine, createSingleTableSeed, defineSeed, extractForeignKeys, findPrimaryKeyColumn, isTable, seed, seedConfig, tableSeed, topologicalSort };
+export { type ColumnSeedFn, type Faker, type Seed, type SeedConfig, type SeedContext, type SeedEntry, type SeedRunOptions, type SeedableTable, type TableSeedConfig, columnSeedMap, createSeedEngine, createSingleTableSeed, defineSeed, extractForeignKeys, findPrimaryKeyColumn, isTable, seed, seedConfig, table, tableSeed, tableSeedMap, topologicalSort };

package/dist/seed.js

@@ -22,17 +22,17 @@ function seedConfig(column, fn) {
   columnSeedMap.set(column, fn);
   return column;
 }
-function tableSeed(table, config) {
-  tableSeedMap.set(table, config);
-  return table;
+function tableSeed(table2, config) {
+  tableSeedMap.set(table2, config);
+  return table2;
 }
-function extractForeignKeys(table) {
-  const fkSymbol = Object.getOwnPropertySymbols(table).find(
+function extractForeignKeys(table2) {
+  const fkSymbol = Object.getOwnPropertySymbols(table2).find(
     (s) => s.toString().includes("InlineForeignKeys")
   );
   if (!fkSymbol) return [];
-  const fks = table[fkSymbol];
-  const columns = getTableColumns(asTable(table));
+  const fks = table2[fkSymbol];
+  const columns = getTableColumns(asTable(table2));
   const sqlNameToKey = /* @__PURE__ */ new Map();
   for (const [key, col] of Object.entries(columns)) {
     sqlNameToKey.set(col.name, key);
@@ -52,8 +52,8 @@ function extractForeignKeys(table) {
   }
   return result;
 }
-function findPrimaryKeyColumn(table) {
-  const columns = getTableColumns(asTable(table));
+function findPrimaryKeyColumn(table2) {
+  const columns = getTableColumns(asTable(table2));
   for (const [key, col] of Object.entries(columns)) {
     if (col.primary) {
       return { key, column: col };
@@ -86,8 +86,8 @@ function generateDefaultValue(col, isPk, isNullable) {
   return faker.lorem.words(2);
 }
 var AUTH_TABLE_NAME = "users";
-function isAuthUsersTable(table) {
-  return getTableName(asTable(table)) === AUTH_TABLE_NAME;
+function isAuthUsersTable(table2) {
+  return getTableName(asTable(table2)) === AUTH_TABLE_NAME;
 }
 function generateAuthEmail(index) {
   const roles = ["admin", "user", "editor", "viewer", "moderator"];
@@ -155,8 +155,8 @@ function createSeedEngine(schema) {
     }
   }
   const fkMap = /* @__PURE__ */ new Map();
-  for (const table of tables) {
-    fkMap.set(table, extractForeignKeys(table));
+  for (const table2 of tables) {
+    fkMap.set(table2, extractForeignKeys(table2));
   }
   const sorted = topologicalSort(tables, fkMap);
   return {
@@ -168,13 +168,13 @@ function createSeedEngine(schema) {
      */
     generate(tableOverrides) {
       const generated = /* @__PURE__ */ new Map();
-      for (const table of sorted) {
-        const config = tableOverrides?.get(table) ?? tableSeedMap.get(table);
-        const fks = fkMap.get(table) ?? [];
-        const columns = getTableColumns(asTable(table));
-        const pk = findPrimaryKeyColumn(table);
-        const isAuth = isAuthUsersTable(table);
-        const dedupKeys = getDeduplicationKeys(table, fks);
+      for (const table2 of sorted) {
+        const config = tableOverrides?.get(table2) ?? tableSeedMap.get(table2);
+        const fks = fkMap.get(table2) ?? [];
+        const columns = getTableColumns(asTable(table2));
+        const pk = findPrimaryKeyColumn(table2);
+        const isAuth = isAuthUsersTable(table2);
+        const dedupKeys = getDeduplicationKeys(table2, fks);
         const count = config?.count ?? 10;
         const perTable = config?.per;
         const parentRows = perTable ? generated.get(perTable) ?? [] : [void 0];
@@ -258,7 +258,7 @@ function createSeedEngine(schema) {
             globalIndex++;
           }
         }
-        generated.set(table, allRows);
+        generated.set(table2, allRows);
       }
       return generated;
     },
@@ -269,10 +269,10 @@ function createSeedEngine(schema) {
       const generated = this.generate(options?.tableOverrides);
       const unsafeDb = db.unsafe();
       const transcriptLines = [];
-      for (const table of sorted) {
-        const rows = generated.get(table);
+      for (const table2 of sorted) {
+        const rows = generated.get(table2);
         if (!rows || rows.length === 0) continue;
-        const tableName = getTableName(asTable(table));
+        const tableName = getTableName(asTable(table2));
         if (options?.transcript) {
           for (const row of rows) {
             const colNames = Object.keys(row);
@@ -289,7 +289,7 @@ function createSeedEngine(schema) {
           }
         }
         const ops = rows.map(
-          (row) => unsafeDb.insert(table).values(row)
+          (row) => unsafeDb.insert(table2).values(row)
         );
         if (ops.length === 1) {
           await ops[0].run({});
@@ -314,12 +314,12 @@ function createSeedEngine(schema) {
     }
   };
 }
-function createSingleTableSeed(schema, table, count) {
+function createSingleTableSeed(schema, table2, count) {
   const engine = createSeedEngine(schema);
   const overrides = /* @__PURE__ */ new Map();
-  overrides.set(table, { count });
+  overrides.set(table2, { count });
   for (const t of engine.tables) {
-    if (t !== table && !overrides.has(t)) {
+    if (t !== table2 && !overrides.has(t)) {
       overrides.set(t, { count: 0 });
     }
   }
@@ -335,6 +335,24 @@ function isTable(value) {
 }
 
 // src/seed.ts
+import { SQLiteColumnBuilder } from "drizzle-orm/sqlite-core/columns/common";
+import { sqliteTable } from "drizzle-orm/sqlite-core";
+SQLiteColumnBuilder.prototype.seed = function(fn) {
+  const config = this.config;
+  if (config && typeof config === "object") {
+    columnSeedMap.set(config, fn);
+  }
+  columnSeedMap.set(this, fn);
+  return this;
+};
+function table(name, columns, extraConfig) {
+  const t = sqliteTable(name, columns, extraConfig);
+  t.seed = (config) => {
+    tableSeedMap.set(t, config);
+    return t;
+  };
+  return t;
+}
 async function seed(db, options) {
   const engine = createSeedEngine(db._schema);
   await engine.run(db, options);
@@ -365,6 +383,7 @@ function defineSeed(config) {
   };
 }
 export {
+  columnSeedMap,
   createSeedEngine,
   createSingleTableSeed,
   defineSeed,
@@ -373,6 +392,8 @@ export {
   isTable,
   seed,
   seedConfig,
+  table,
   tableSeed,
+  tableSeedMap,
   topologicalSort
 };

package/llms.txt

@@ -478,22 +478,23 @@ auto-generate realistic test data using the bundled faker. Handles FK
 resolution, topological ordering, `per` relational generation,
 many-to-many deduplication, and auth table detection.
 
-#### Column-level seed overrides
+#### Column-level `.seed()` method
 
-`seedConfig(column, fn)` attaches a custom generator to a column:
+Chain `.seed(fn)` on any column builder to attach a custom generator:
 
 ```typescript
-import { seedConfig, tableSeed } from "@cfast/db/seed";
+import { table } from "@cfast/db/seed";
+import { text, integer, real } from "drizzle-orm/sqlite-core";
 
-const posts = sqliteTable("posts", {
+const posts = table("posts", {
   id: text("id").primaryKey(),
-  title: seedConfig(text("title").notNull(), f => f.lorem.sentence()),
-  content: seedConfig(text("content"), f => f.lorem.paragraphs(3)),
+  title: text("title").notNull().seed(f => f.lorem.sentence()),
+  content: text("content").seed(f => f.lorem.paragraphs(3)),
   authorId: text("author_id").references(() => users.id),
-});
+}).seed({ count: 10 });
 ```
 
-Fields without `seedConfig()` are auto-inferred from column type:
+Fields without `.seed()` are auto-inferred from column type:
 - `text` -> `faker.lorem.words()`
 - `integer`/`real` -> `faker.number.int()`/`faker.number.float()`
 - `timestamp` -> `faker.date.recent()`
@@ -503,17 +504,37 @@ Fields without `seedConfig()` are auto-inferred from column type:
 - Nullable -> occasionally `null` (~10%)
 - Columns with `$defaultFn` or static defaults are skipped
 
-#### Table-level seed config
+#### Table-level `.seed()` method
 
-`tableSeed(table, { count, per })` sets the row count and optional
-per-parent relationship:
+Chain `.seed({ count, per })` on a table created with `table()` to set
+the row count and optional per-parent relationship:
 
 ```typescript
-const users = tableSeed(sqliteTable("users", { ... }), { count: 10 });
-const posts = tableSeed(sqliteTable("posts", { ... }), { count: 5, per: users });
+import { table } from "@cfast/db/seed";
+
+const users = table("users", { ... }).seed({ count: 10 });
+const posts = table("posts", { ... }).seed({ count: 5, per: users });
 // -> 5 per user = 50 total. authorId auto-filled with parent user's id.
 ```
 
+`table()` is a drop-in replacement for `sqliteTable()` from
+`drizzle-orm/sqlite-core` that adds the `.seed()` method. The returned
+table is a standard Drizzle table in every way.
+
+#### Deprecated wrapper functions
+
+The older `seedConfig()` and `tableSeed()` wrapper functions still work
+and write to the same internal registries. They are interchangeable with
+the `.seed()` methods but considered deprecated:
+
+```typescript
+// Deprecated -- prefer .seed() method API above
+import { seedConfig, tableSeed } from "@cfast/db/seed";
+const posts = tableSeed(sqliteTable("posts", {
+  title: seedConfig(text("title"), f => f.lorem.sentence()),
+}), { count: 5 });
+```
+
 #### Seed context (ctx)
 
 Column-level seed functions receive `(faker, ctx)` where `ctx` provides:
@@ -524,10 +545,10 @@ Column-level seed functions receive `(faker, ctx)` where `ctx` provides:
 - `ctx.all(table)` -- all generated rows for a table
 
 ```typescript
-authorId: seedConfig(text("author_id").references(() => users.id),
-  (faker, ctx) => ctx.parent?.id), // inherit from parent
-role: seedConfig(text("role"),
-  (f, ctx) => ctx.index === 0 ? "admin" : f.helpers.arrayElement(["member", "viewer"])),
+authorId: text("author_id").references(() => users.id)
+  .seed((faker, ctx) => ctx.parent?.id), // inherit from parent
+role: text("role")
+  .seed((f, ctx) => ctx.index === 0 ? "admin" : f.helpers.arrayElement(["member", "viewer"])),
 ```
 
 #### Runtime API

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cfast/db",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "Permission-aware Drizzle queries for Cloudflare D1",
   "keywords": [
     "cfast",
@@ -33,7 +33,10 @@
     "dist",
     "llms.txt"
   ],
-  "sideEffects": false,
+  "sideEffects": [
+    "./dist/seed.js",
+    "./src/seed.ts"
+  ],
   "publishConfig": {
     "access": "public"
   },