@stacksjs/database 0.70.163 → 0.70.164

package/README.md

@@ -50,7 +50,7 @@ For help, discussion about best practices, or any other conversation that would
 
 For casual chit-chat with others using this package:
 
-[Join the Stacks Discord Server](https://discord.gg/stacksjs)
+[Join the Stacks Discord Server](https://stacksjs.com/discord)
 
 ## 📄 License
 

package/dist/index.d.ts

@@ -10,8 +10,6 @@ export type {
   PostgresConfig,
   SqliteConfig,
 } from './driver-config';
-export type { GenerateOptions } from './factory';
-export type { ScaffoldOptions, ScaffoldResult } from './seed-scaffold';
 export type { DeclaredFK, FkAuditResult, FkOrphan, FkOrphanReport, LiveFK } from './fk-audit';
 export type { DeclaredUnique, LiveUniqueIndex, UniqueAuditResult } from './unique-audit';
 export type {
@@ -83,22 +81,10 @@ export * from './types';
 export * from './migrations';
 // Query logger DI hook (router calls setQueryTracker on init)
 export { setQueryTracker, logQuery } from './query-logger';
-// Class-based seeders (supplements the model-attribute auto-seeder)
-export { Seeder, runClassSeeders } from './class-seeder';
 // Zero-downtime migration helpers
 export { addColumnSafely, backfillInBatches, renameColumnSafely } from './safe-migrations';
 // Seeding
 export * from './seeder';
-// stacksjs/stacks#1919 — public factory API. The canonical replacement
-// for the legacy `useSeeder` trait + auto-walker. Class seeders call
-// `factory.generate(Model, opts)` explicitly so there's one
-// orchestration layer per table, no double-fire on tables that have
-// both a `useSeeder` trait and a class seeder file.
-export { factory, generate as factoryGenerate } from './factory';
-// `buddy seed:scaffold` codemod — generates class-seeder files for
-// every model with a `useSeeder` trait, easing the migration off the
-// auto-walker.
-export { scaffoldClassSeedersFromModels, renderSeederFile } from './seed-scaffold';
 // Driver utilities
 export * from './drivers/index';
 // Custom migrations (jobs, errors, etc.)

package/dist/index.js

@@ -17,11 +17,8 @@ export * from "./utils";
 export * from "./types";
 export * from "./migrations";
 export { setQueryTracker, logQuery } from "./query-logger";
-export { Seeder, runClassSeeders } from "./class-seeder";
 export { addColumnSafely, backfillInBatches, renameColumnSafely } from "./safe-migrations";
 export * from "./seeder";
-export { factory, generate as factoryGenerate } from "./factory";
-export { scaffoldClassSeedersFromModels, renderSeederFile } from "./seed-scaffold";
 export * from "./drivers";
 export * from "./custom";
 export * from "./auth-tables";

package/dist/migrations.js

@@ -297,7 +297,7 @@ async function countAppliedMigrations() {
 }
 async function writeMigrateMarker(appliedCount) {
   try {
-    const fs = await import("node:fs/promises"), dir = path.projectPath(".stacks");
+    const fs = await import("node:fs/promises"), dir = path.frameworkRuntimePath();
     await fs.mkdir(dir, { recursive: !0 });
     const file = `${dir}/last-migrate-result.json`, body = JSON.stringify({
       appliedCount,

package/dist/seeder.d.ts

@@ -6,24 +6,14 @@ import type { Attribute, Model } from '@stacksjs/types';
  */
 export declare function isProtectedModel(name: string): boolean;
 /**
- * Direct entry point for `factory.generate(Model, opts)` — exported
- * under a distinct name so the new public API in `factory.ts` can call
- * into the same insert path the legacy walker uses without leaking the
- * `SeederModel` type. See stacksjs/stacks#1919.
- */
-export declare function seedModelDirect(model: SeederModel, options: SeederConfig): Promise<SeedResult>;
-/**
- * Main seeding function
- * Seeds the database using model factory functions
- * Loads models from both framework defaults and user-defined models,
- * with user models taking precedence.
+ * Seeds the database from your models.
+ *
+ * Walks every model that declares a `useSeeder` trait and fills its table
+ * using the per-attribute `factory: faker => …` declarations. Models are
+ * loaded from `app/Models/` and, with `includeDefaults`, the framework's
+ * built-in models too - user models win on a name collision.
  *
- * @deprecated stacksjs/stacks#1919 — the model auto-walker is no
- * longer invoked by `./buddy seed`. Migrate each `useSeeder` trait to
- * a class seeder via `./buddy seed:scaffold`, then call
- * `factory.generate(Model, opts)` from inside each seeder. This
- * function remains exported for programmatic back-compat but is
- * scheduled for removal.
+ * This is what `./buddy seed` runs.
  */
 export declare function seed(config?: SeederConfig): Promise<SeedSummary>;
 /**

package/dist/seeder.js

@@ -148,9 +148,6 @@ async function generateRecords(model, verbose = !1) {
   }
   return records;
 }
-export function seedModelDirect(model, options) {
-  return seedModel(model, options);
-}
 async function seedModel(model, options) {
   const startTime = Date.now();
   try {
@@ -259,7 +256,6 @@ export async function seed(config = {}) {
       duration: Date.now() - startTime
     };
   }
-  log.warn(`[seed] The \`useSeeder\` trait + auto-walker is deprecated (stacksjs/stacks#1919, #1929). Run \`./buddy seed:scaffold\` to generate a class seeder per \`useSeeder\` model AND strip the trait from the model in one pass. The walker + trait are scheduled for removal in the next major. Affected: ${models.map((m) => m.name).join(", ")}`);
   if (config.only && config.only.length > 0)
     models = models.filter((m) => config.only.includes(m.name));
   if (config.except && config.except.length > 0)

package/dist/types.js

@@ -54,7 +54,7 @@ const SAFE_FILTER_OPERATORS = new Set([
   "is",
   "is not"
 ]);
-function inlineSqlLiteral(_value) {
+function inlineSqlLiteral(value) {
   if (value === null || value === void 0)
     return "NULL";
   if (typeof value === "number") {

package/package.json

@@ -2,7 +2,7 @@
   "name": "@stacksjs/database",
   "type": "module",
   "sideEffects": false,
-  "version": "0.70.163",
+  "version": "0.70.164",
   "description": "The Stacks database integration.",
   "author": "Chris Breuer",
   "contributors": [
@@ -60,15 +60,15 @@
     "dynamodb-tooling": "^0.3.2"
   },
   "devDependencies": {
-    "@stacksjs/cli": "0.70.163",
-    "@stacksjs/config": "0.70.163",
-    "@stacksjs/logging": "0.70.163",
-    "@stacksjs/router": "0.70.163",
+    "@stacksjs/cli": "0.70.164",
+    "@stacksjs/config": "0.70.164",
+    "@stacksjs/logging": "0.70.164",
+    "@stacksjs/router": "0.70.164",
     "better-dx": "^0.2.17",
-    "@stacksjs/path": "0.70.163",
-    "@stacksjs/query-builder": "0.70.163",
-    "@stacksjs/storage": "0.70.163",
-    "@stacksjs/strings": "0.70.163",
-    "@stacksjs/utils": "0.70.163"
+    "@stacksjs/path": "0.70.164",
+    "@stacksjs/query-builder": "0.70.164",
+    "@stacksjs/storage": "0.70.164",
+    "@stacksjs/strings": "0.70.164",
+    "@stacksjs/utils": "0.70.164"
   }
 }

package/dist/class-seeder.d.ts

@@ -1,65 +0,0 @@
-/**
- * Topologically sort seeders by their declared `dependencies`. Ties
- * (and dependency-free seeders) come out in alphabetical order so the
- * result is deterministic across filesystems and runs.
- *
- * Unknown dependency names are dropped from the graph with a warning —
- * they may refer to model-factory seeders that ran earlier in the
- * `buddy seed` pipeline, or be stale references from a rename. The run
- * doesn't fail because of them.
- *
- * Cycles throw with the offending class names in the error message.
- *
- * Exported for testing.
- */
-export declare function topoSortSeeders(seeders: Array<{ name: string, dependencies?: string[] }>): string[];
-/*.ts`; an explicit `--class` filters to one.
- *
- * Ordering:
- *   1. Files matching `*.ts` (excluding `_*.ts`) are imported.
- *   2. If any seeder declares `dependencies`, the runnable set is
- *      topologically sorted (alphabetical tie-break).
- *   3. Otherwise, the alphabetical order from `Array.sort()` wins —
- *      cheaper than the topo path and predictable across filesystems.
- *
- * Class-name filtering via `options.class` short-circuits both paths
- * and runs only that one seeder. Cross-seeder dependencies are NOT
- * resolved transitively in that mode — the caller takes responsibility
- * for whatever prereqs are needed.
- *
- * See stacksjs/stacks#1855 for the original report of unsorted FS
- * iteration producing zero-row seed runs.
- */
-export declare function runClassSeeders(options?: RunOptions): Promise<{ ran: string[], skipped: string[] }>;
-declare interface RunOptions {
-  class?: string
-  dir?: string
-}
-/**
- * Base class for class-based seeders. Subclass this and implement
- * `async run()`. Seeders may call `this.call()` to invoke other
- * seeders, mirroring Laravel's nested-seeder pattern.
- *
- * Cross-seeder ordering can be declared explicitly via `dependencies`:
- *
- *   ```ts
- *   export default class JudgeSeeder extends Seeder {
- *     dependencies = ['CourtHouseSeeder']
- *     async run() { ... }
- *   }
- *   ```
- *
- * The class name of each dependency is matched against the class names
- * `runClassSeeders` discovered in the seeders directory. Unknown
- * dependency names are warned about but don't fail the run (they may
- * refer to a model-factory seeder run earlier in `buddy seed`).
- *
- * When no `dependencies` are declared, seeders run in alphabetical
- * order — predictable across filesystems and good enough for projects
- * that name seeders by data flow (CourtHouse → Judge → Review).
- */
-export declare abstract class Seeder {
-  dependencies?: string[];
-  abstract run(): Promise<void> | void;
-  protected call(other: new () => Seeder): Promise<void>;
-}

package/dist/class-seeder.js

@@ -1,116 +0,0 @@
-import { log } from "@stacksjs/logging";
-import { path } from "@stacksjs/path";
-import { fs } from "@stacksjs/storage";
-
-export class Seeder {
-  dependencies;
-  async call(other) {
-    await new other().run();
-  }
-}
-export function topoSortSeeders(seeders) {
-  const known = new Set(seeders.map((s) => s.name)), effectiveDeps = new Map;
-  for (const s of seeders) {
-    const deps = new Set;
-    for (const dep of s.dependencies ?? []) {
-      if (dep === s.name)
-        continue;
-      if (!known.has(dep)) {
-        log.warn(`[seeder] ${s.name} depends on '${dep}' but no seeder by that name was discovered \u2014 ignoring`);
-        continue;
-      }
-      deps.add(dep);
-    }
-    effectiveDeps.set(s.name, deps);
-  }
-  const indegree = new Map, successors = new Map;
-  for (const s of seeders) {
-    indegree.set(s.name, effectiveDeps.get(s.name).size);
-    successors.set(s.name, new Set);
-  }
-  for (const s of seeders)
-    for (const dep of effectiveDeps.get(s.name))
-      successors.get(dep).add(s.name);
-  const ready = seeders.filter((s) => indegree.get(s.name) === 0).map((s) => s.name).sort(), result = [];
-  while (ready.length > 0) {
-    const next = ready.shift();
-    result.push(next);
-    const newlyReady = [];
-    for (const succ of successors.get(next)) {
-      const left = (indegree.get(succ) ?? 0) - 1;
-      indegree.set(succ, left);
-      if (left === 0)
-        newlyReady.push(succ);
-    }
-    if (newlyReady.length > 0) {
-      ready.push(...newlyReady);
-      ready.sort();
-    }
-  }
-  if (result.length !== seeders.length) {
-    const unresolved = seeders.map((s) => s.name).filter((n) => !result.includes(n));
-    throw Error(`[seeder] Cycle in seeder \`dependencies\` among: ${unresolved.join(", ")}`);
-  }
-  return result;
-}
-export async function runClassSeeders(options = {}) {
-  try {
-    const { injectGlobalAutoImports } = await import("@stacksjs/server");
-    await injectGlobalAutoImports();
-  } catch {}
-  const dir = options.dir ?? path.projectPath("database/seeders"), ran = [], skipped = [];
-  if (!fs.existsSync(dir)) {
-    log.info(`[seeder] No class seeders directory at ${dir}`);
-    return { ran, skipped };
-  }
-  const files = fs.readdirSync(dir).filter((f) => f.endsWith(".ts") && !f.startsWith("_")).sort(), loaded = [];
-  for (const file of files) {
-    const className = file.replace(/\.ts$/, "");
-    try {
-      const mod = await import(`${dir}/${file}`), Klass = mod.default ?? mod[className];
-      if (!Klass) {
-        log.warn(`[seeder] ${file} has no default export`);
-        skipped.push(className);
-        continue;
-      }
-      const inst = new Klass;
-      if (typeof inst.run !== "function") {
-        log.warn(`[seeder] ${className} does not implement run()`);
-        skipped.push(className);
-        continue;
-      }
-      loaded.push({ className, inst });
-    } catch (err) {
-      log.error(`[seeder] ${className} failed to load:`, err);
-      skipped.push(className);
-    }
-  }
-  const declaresDeps = loaded.some((l) => (l.inst.dependencies?.length ?? 0) > 0);
-  let order;
-  if (declaresDeps)
-    try {
-      order = topoSortSeeders(loaded.map((l) => ({ name: l.className, dependencies: l.inst.dependencies })));
-    } catch (err) {
-      log.error(err instanceof Error ? err.message : String(err));
-      return { ran, skipped: [...skipped, ...loaded.map((l) => l.className)] };
-    }
-  else
-    order = loaded.map((l) => l.className);
-  const byName = new Map(loaded.map((l) => [l.className, l.inst]));
-  for (const className of order) {
-    if (options.class && className !== options.class) {
-      skipped.push(className);
-      continue;
-    }
-    const inst = byName.get(className);
-    try {
-      log.info(`[seeder] Running ${className}\u2026`);
-      await inst.run();
-      ran.push(className);
-    } catch (err) {
-      log.error(`[seeder] ${className} failed:`, err);
-      skipped.push(className);
-    }
-  }
-  return { ran, skipped };
-}

package/dist/factory.d.ts

@@ -1,41 +0,0 @@
-import type { Attribute, Model } from '@stacksjs/types';
-import type { SeedResult } from './seeder';
-/**
- * Build the internal `SeederModel`-shaped payload that `seedModelDirect`
- * expects from a public-API call. Pure function — exported separately
- * so tests can assert the override-precedence rules without touching
- * the database.
- *
- * Precedence (lowest → highest): per-attribute `factory` output →
- * global `options.with` → per-row `options.rows[i]`. All keys are
- * snake-cased before insert so callers can use the model's camelCase
- * attribute names without thinking about column naming.
- */
-export declare function buildSeederPayload(modelInput: unknown, options?: GenerateOptions): {
-  name: string
-  table: string
-  count: number
-  fixtures: Array<Record<string, unknown>>
-  attributes: Record<string, Attribute>
-  model: Model
-};
-/**
- * Generate factory rows for a model and insert them. Designed to be
- * called from a class seeder.
- *
- * Honours the model's per-attribute `factory: faker => …` declarations
- * — exactly the same code path as the legacy auto-walker — but without
- * the implicit "every model with `useSeeder` fires on every run"
- * coupling. See stacksjs/stacks#1919 for the rationale.
- */
-export declare function generate(modelInput: unknown, options?: GenerateOptions): Promise<SeedResult>;
-export declare const factory: {
-  generate: typeof generate
-};
-export declare interface GenerateOptions {
-  count?: number
-  fresh?: boolean
-  verbose?: boolean
-  with?: Record<string, unknown>
-  rows?: Array<Record<string, unknown>>
-}

package/dist/factory.js

@@ -1,51 +0,0 @@
-import { log } from "@stacksjs/logging";
-import { seedModelDirect } from "./seeder";
-function resolveDefinition(input) {
-  if (input && typeof input === "object") {
-    const obj = input;
-    if (obj._definition && typeof obj._definition === "object" && "name" in obj._definition)
-      return obj._definition;
-    if ("name" in obj && (("attributes" in obj) || ("table" in obj) || ("traits" in obj)))
-      return obj;
-  }
-  throw Error("factory.generate: expected a Stacks model (the default export of app/Models/*.ts, or a defineModel() return value). Got something without a `.name` field.");
-}
-function snakeCase(str) {
-  return str.replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2").replace(/([a-z\d])([A-Z])/g, "$1_$2").replace(/(\d)([A-Za-z])/g, "$1_$2").toLowerCase();
-}
-function snakeCaseKeys(input) {
-  const out = {};
-  for (const [key, value] of Object.entries(input))
-    out[snakeCase(key)] = value;
-  return out;
-}
-export function buildSeederPayload(modelInput, options = {}) {
-  const def = resolveDefinition(modelInput), name = def.name, attributes = def.attributes ?? {}, useSeederConfig = def.traits?.useSeeder, seederDefault = useSeederConfig && typeof useSeederConfig === "object" ? useSeederConfig : void 0, count = options.count ?? seederDefault?.count ?? 10, globalOverrides = options.with ? snakeCaseKeys(options.with) : void 0, perRow = options.rows ?? seederDefault?.fixtures ?? [], fixtureCount = Math.max(count, perRow.length), fixtures = [];
-  for (let i = 0;i < fixtureCount; i++) {
-    const row = perRow[i];
-    if (!globalOverrides && !row)
-      continue;
-    fixtures[i] = { ...globalOverrides ?? {}, ...row ? snakeCaseKeys(row) : {} };
-  }
-  const table = def.table ?? `${snakeCase(name)}s`;
-  return { name, table, count: fixtureCount, fixtures, attributes, model: def };
-}
-export async function generate(modelInput, options = {}) {
-  const payload = buildSeederPayload(modelInput, options);
-  try {
-    return await seedModelDirect({
-      ...payload,
-      filePath: ""
-    }, {
-      fresh: options.fresh,
-      verbose: options.verbose ?? !1
-    });
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    log.error(`[factory] generate(${payload.name}) failed: ${message}`);
-    throw err;
-  }
-}
-export const factory = {
-  generate
-};

package/dist/seed-scaffold.d.ts

@@ -1,34 +0,0 @@
-/**
- * Remove a single `useSeeder` / `seedable` object-property from model
- * source text (stacksjs/stacks#1929). Brace-aware (balances nested
- * `{}` and skips string literals) and conservative: only strips the
- * documented value shapes (`true`, `false`, or a `{ … }` object). For
- * anything else (an identifier, a function call, a spread) it returns
- * `changed: false` so the caller can flag it for manual cleanup
- * instead of risking a mangled file.
- *
- * Exported for unit tests.
- */
-export declare function stripUseSeederTrait(source: string): { source: string, changed: boolean, skipped: boolean };
-/**
- * Walk the configured models directory, find every model whose
- * `traits.useSeeder` is truthy, and write a class-seeder file for it.
- * Returns a structured report so the CLI command can render a summary
- * without re-parsing log lines.
- */
-export declare function scaffoldClassSeedersFromModels(options?: ScaffoldOptions): Promise<ScaffoldResult>;
-/** Pure renderer — exported for unit tests. */
-export declare function renderSeederFile(modelName: string, modelImportPath: string, count: number): string;
-export declare interface ScaffoldOptions {
-  modelsDir?: string
-  seedersDir?: string
-  force?: boolean
-  dryRun?: boolean
-}
-export declare interface ScaffoldResult {
-  generated: Array<{ model: string, file: string }>
-  skipped: Array<{ model: string, file: string, reason: 'already-exists' | 'no-useseeder' }>
-  errors: Array<{ model: string, error: string }>
-  strippedTrait: Array<{ model: string, file: string }>
-  traitStripSkipped: Array<{ model: string, file: string }>
-}

package/dist/seed-scaffold.js

@@ -1,144 +0,0 @@
-import { log } from "@stacksjs/logging";
-import { path } from "@stacksjs/path";
-import { fs } from "@stacksjs/storage";
-export function stripUseSeederTrait(source) {
-  let out = source, changed = !1, skipped = !1;
-  for (const name of ["useSeeder", "seedable"]) {
-    const m = new RegExp(`\\b${name}\\s*:`).exec(out);
-    if (!m)
-      continue;
-    const keyStart = m.index;
-    let i = keyStart + m[0].length;
-    while (i < out.length && /\s/.test(out[i]))
-      i++;
-    if (out[i] === "{") {
-      let depth = 0, inStr = null;
-      for (;i < out.length; i++) {
-        const ch = out[i];
-        if (inStr) {
-          if (ch === "\\") {
-            i++;
-            continue;
-          }
-          if (ch === inStr)
-            inStr = null;
-          continue;
-        }
-        if (ch === '"' || ch === "'" || ch === "`") {
-          inStr = ch;
-          continue;
-        }
-        if (ch === "{")
-          depth++;
-        else if (ch === "}") {
-          depth--;
-          if (depth === 0) {
-            i++;
-            break;
-          }
-        }
-      }
-    } else if (out.startsWith("true", i) || out.startsWith("false", i))
-      i += out.startsWith("true", i) ? 4 : 5;
-    else {
-      skipped = !0;
-      continue;
-    }
-    let end = i;
-    while (end < out.length && (out[end] === " " || out[end] === "\t"))
-      end++;
-    if (out[end] === ",")
-      end++;
-    while (end < out.length && (out[end] === " " || out[end] === "\t"))
-      end++;
-    if (out[end] === "/" && out[end + 1] === "/")
-      while (end < out.length && out[end] !== `
-`)
-        end++;
-    let start = keyStart;
-    while (start > 0 && (out[start - 1] === " " || out[start - 1] === "\t"))
-      start--;
-    if (start > 0 && out[start - 1] === `
-` && out[end] === `
-`)
-      end++;
-    out = out.slice(0, start) + out.slice(end);
-    changed = !0;
-  }
-  return { source: out, changed, skipped: skipped && !changed };
-}
-const SEEDER_TEMPLATE = (modelName, modelImportPath, count) => `import { factory, Seeder } from '@stacksjs/database'
-import ${modelName} from '${modelImportPath}'
-
-export default class ${modelName}Seeder extends Seeder {
-  async run(): Promise<void> {
-    await factory.generate(${modelName}, { count: ${count} })
-  }
-}
-`;
-function relativeModelImport(seedersDir, modelFilePath) {
-  const noExt = path.relative(seedersDir, modelFilePath).replace(/\\/g, "/").replace(/\.ts$/, "");
-  return noExt.startsWith(".") ? noExt : `./${noExt}`;
-}
-export async function scaffoldClassSeedersFromModels(options = {}) {
-  const modelsDir = options.modelsDir ?? path.userModelsPath(), seedersDir = options.seedersDir ?? path.projectPath("database/seeders"), result = { generated: [], skipped: [], errors: [], strippedTrait: [], traitStripSkipped: [] };
-  if (!fs.existsSync(modelsDir)) {
-    log.warn(`[seed:scaffold] No models directory at ${modelsDir}`);
-    return result;
-  }
-  if (!options.dryRun && !fs.existsSync(seedersDir))
-    fs.mkdirSync(seedersDir, { recursive: !0 });
-  const entries = fs.readdirSync(modelsDir, { withFileTypes: !0 });
-  for (const entry of entries) {
-    if (!entry.isFile() || !entry.name.endsWith(".ts"))
-      continue;
-    if (entry.name.startsWith("_") || entry.name.startsWith("index"))
-      continue;
-    const modelFilePath = path.join(modelsDir, entry.name);
-    let modelDef;
-    try {
-      const module = await import(modelFilePath);
-      modelDef = module.default || module;
-    } catch (err) {
-      result.errors.push({ model: entry.name, error: err.message });
-      continue;
-    }
-    if (!modelDef || !modelDef.name) {
-      result.errors.push({ model: entry.name, error: "missing default export with `name` field" });
-      continue;
-    }
-    const useSeeder = modelDef.traits?.useSeeder ?? modelDef.traits?.seedable;
-    if (!useSeeder) {
-      result.skipped.push({ model: modelDef.name, file: "", reason: "no-useseeder" });
-      continue;
-    }
-    const count = typeof useSeeder === "object" && "count" in useSeeder ? useSeeder.count : 10, seederFileName = `${modelDef.name}Seeder.ts`, seederFilePath = path.join(seedersDir, seederFileName);
-    if (fs.existsSync(seederFilePath) && !options.force)
-      result.skipped.push({ model: modelDef.name, file: seederFilePath, reason: "already-exists" });
-    else {
-      const importPath = relativeModelImport(seedersDir, modelFilePath), content = SEEDER_TEMPLATE(modelDef.name, importPath, count);
-      if (options.dryRun)
-        log.info(`[seed:scaffold] would write ${seederFilePath}`);
-      else
-        fs.writeFileSync(seederFilePath, content, "utf-8");
-      result.generated.push({ model: modelDef.name, file: seederFilePath });
-    }
-    try {
-      const modelSource = fs.readFileSync(modelFilePath, "utf-8"), { source: stripped, changed, skipped } = stripUseSeederTrait(modelSource);
-      if (changed) {
-        if (options.dryRun)
-          log.info(`[seed:scaffold] would strip useSeeder trait from ${modelFilePath}`);
-        else
-          fs.writeFileSync(modelFilePath, stripped, "utf-8");
-        result.strippedTrait.push({ model: modelDef.name, file: modelFilePath });
-      } else if (skipped)
-        result.traitStripSkipped.push({ model: modelDef.name, file: modelFilePath });
-    } catch (err) {
-      result.errors.push({ model: modelDef.name, error: `trait strip failed: ${err.message}` });
-    }
-  }
-  return result;
-}
-export function renderSeederFile(modelName, modelImportPath, count) {
-  return SEEDER_TEMPLATE(modelName, modelImportPath, count);
-}