vibeorm 1.1.10 → 1.2.0

package/README.md

@@ -327,13 +327,18 @@ Config is resolved in this order (last wins):
 
 ### vibeorm.config.ts
 
+The loader expects a **default export**. It will also accept `export const config = { ... }`
+as a fallback for ergonomics, but `export default` is the canonical form.
+
 ```ts
-export const config = {
+import type { VibeOrmConfig } from "vibeorm/config";
+
+export default {
   schema: "./prisma/schema.prisma",
   output: "./generated/vibeorm",
   migrations: "./migrations",
   seed: "./prisma/seed.ts",
-};
+} satisfies VibeOrmConfig;
 ```
 
 ### Typical migration workflow

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vibeorm",
-  "version": "1.1.10",
+  "version": "1.2.0",
   "description": "CLI for VibeORM — generate clients, run migrations, introspect databases",
   "license": "MIT",
   "keywords": [
@@ -20,6 +20,10 @@
     ".": {
       "default": "./src/index.ts",
       "types": "./src/index.ts"
+    },
+    "./config": {
+      "default": "./src/config.ts",
+      "types": "./src/config.ts"
     }
   },
   "files": [
@@ -41,10 +45,10 @@
     "bun": ">=1.1.0"
   },
   "dependencies": {
-    "@vibeorm/parser": "1.1.7",
-    "@vibeorm/generator": "1.1.8",
-    "@vibeorm/migrate": "1.1.8",
-    "@vibeorm/runtime": "1.1.7",
-    "@vibeorm/adapter-bun": "1.1.7"
+    "@vibeorm/parser": "1.2.0",
+    "@vibeorm/generator": "1.2.0",
+    "@vibeorm/migrate": "1.2.0",
+    "@vibeorm/runtime": "1.2.0",
+    "@vibeorm/adapter-bun": "1.2.0"
   }
 }

package/src/commands/db-seed.ts

@@ -1,7 +1,12 @@
 /**
  * vibeorm db seed
  *
- * Run a user-defined seed script.
+ * Run a user-defined seed script. Any arguments passed after the `--`
+ * separator are forwarded verbatim to the seed script (npm/bun convention):
+ *
+ *   bunx vibeorm db seed -- --scenario=medium --seed-count 10
+ *
+ * The seed script can then read these from `process.argv.slice(2)`.
  */
 
 import { existsSync } from "fs";
@@ -10,8 +15,9 @@ import type { VibeOrmConfig } from "../config.ts";
 export async function runDbSeed(params: {
   config: VibeOrmConfig;
   flags: Record<string, string>;
+  passthroughArgs?: string[];
 }): Promise<void> {
-  const { config } = params;
+  const { config, passthroughArgs = [] } = params;
 
   console.log("VibeORM DB Seed");
   console.log("");
@@ -30,9 +36,12 @@ export async function runDbSeed(params: {
   }
 
   console.log(`Running seed: ${seedPath}`);
+  if (passthroughArgs.length > 0) {
+    console.log(`  Forwarding args: ${passthroughArgs.join(" ")}`);
+  }
   console.log("");
 
-  const proc = Bun.spawn(["bun", "run", seedPath], {
+  const proc = Bun.spawn(["bun", "run", seedPath, ...passthroughArgs], {
     stdout: "inherit",
     stderr: "inherit",
   });

package/src/config.ts

@@ -55,20 +55,58 @@ function loadPackageJsonConfig(): Partial<VibeOrmConfig> {
   return {};
 }
 
+const KNOWN_CONFIG_KEYS = new Set<keyof VibeOrmConfig>(["schema", "output", "migrations", "seed"]);
+
 async function loadConfigFile(): Promise<Partial<VibeOrmConfig>> {
   const configPath = resolve(process.cwd(), "vibeorm.config.ts");
   if (!existsSync(configPath)) return {};
 
+  let mod: Record<string, unknown>;
   try {
-    const mod = await import(configPath);
-    const config = mod.default ?? mod;
-    if (config && typeof config === "object") {
-      return config as Partial<VibeOrmConfig>;
-    }
-  } catch {
-    // Ignore import errors
+    mod = await import(configPath);
+  } catch (err) {
+    console.warn(`[vibeorm] Failed to import vibeorm.config.ts: ${err instanceof Error ? err.message : String(err)}`);
+    return {};
   }
-  return {};
+
+  // Accept either `export default { ... }` (recommended) or `export const config = { ... }`.
+  // We prefer `default` for consistency with most TS config conventions.
+  let raw: unknown = mod.default;
+  let source: "default" | "config" | "module" = "default";
+  if (raw === undefined && mod.config !== undefined) {
+    raw = mod.config;
+    source = "config";
+  }
+  if (raw === undefined) {
+    raw = mod;
+    source = "module";
+  }
+
+  if (!raw || typeof raw !== "object") {
+    console.warn(`[vibeorm] vibeorm.config.ts loaded but does not export a config object.`);
+    return {};
+  }
+
+  const cfg = raw as Record<string, unknown>;
+  const hasKnown = Array.from(KNOWN_CONFIG_KEYS).some((k) => cfg[k] !== undefined);
+  if (!hasKnown) {
+    console.warn(
+      `[vibeorm] vibeorm.config.ts loaded but no recognised keys (schema/output/migrations/seed) were found. ` +
+      `Did you mean \`export default { ... }\`? Falling back to defaults.`,
+    );
+    return {};
+  }
+
+  if (source === "module") {
+    // The user almost certainly forgot `export default`; their config is being read off the
+    // module namespace by accident. Surface a hint so they don't lose minutes to silent fallback.
+    console.warn(
+      `[vibeorm] vibeorm.config.ts is missing a default export. ` +
+      `Recommended: \`export default { ... } satisfies VibeOrmConfig\`.`,
+    );
+  }
+
+  return cfg as Partial<VibeOrmConfig>;
 }
 
 export async function resolveConfig(params: { flags?: Record<string, string> }): Promise<VibeOrmConfig> {

package/src/index.ts

@@ -36,7 +36,19 @@ import { runMigrateRollback } from "./commands/migrate-rollback.ts";
 
 // ─── Command Router ───────────────────────────────────────────────
 
-const COMMANDS: Record<string, (params: { config: VibeOrmConfig; flags: Record<string, string> }) => Promise<void>> = {
+/**
+ * Standard handler signature. `passthroughArgs` contains everything after the
+ * first standalone `--` token in the original argv — the canonical
+ * npm/bun/pnpm convention for forwarding flags to a wrapped script. Most
+ * commands ignore it; `db seed` forwards it to the user's seed script.
+ */
+type CommandHandler = (params: {
+  config: VibeOrmConfig;
+  flags: Record<string, string>;
+  passthroughArgs: string[];
+}) => Promise<void>;
+
+const COMMANDS: Record<string, CommandHandler> = {
   "init": runInit,
   "generate": runGenerate,
   "db push": runDbPush,
@@ -80,7 +92,14 @@ function printHelp(): void {
 }
 
 async function main(): Promise<void> {
-  const args = process.argv.slice(2);
+  const rawArgs = process.argv.slice(2);
+
+  // Split at the first standalone `--` token (npm/bun/pnpm convention).
+  // Everything before is for vibeorm; everything after is forwarded to the
+  // wrapped script (currently only consumed by `db seed`).
+  const separatorIdx = rawArgs.indexOf("--");
+  const args = separatorIdx === -1 ? rawArgs : rawArgs.slice(0, separatorIdx);
+  const passthroughArgs = separatorIdx === -1 ? [] : rawArgs.slice(separatorIdx + 1);
 
   if (args.length === 0 || args[0] === "--help" || args[0] === "-h") {
     printHelp();
@@ -109,7 +128,7 @@ async function main(): Promise<void> {
   const config = await resolveConfig({ flags });
 
   const handler = COMMANDS[command]!;
-  await handler({ config, flags });
+  await handler({ config, flags, passthroughArgs });
 }
 
 main().catch((err) => {

package/src/schema-loader.ts

@@ -1,14 +1,45 @@
 /**
  * Schema Loader — supports both single .prisma files and directories
- * containing multiple .prisma files.
+ * containing multiple .prisma files (including nested subdirectories,
+ * matching Prisma 7's multi-file mode).
  *
  * If the path is a file, reads it directly.
- * If the path is a directory, reads all *.prisma files within it
- * (sorted alphabetically) and concatenates them.
+ * If the path is a directory, walks recursively and reads every `.prisma` file
+ * (sorted by relative path so concatenation order is deterministic across OSes).
+ * Dotfile-prefixed files (e.g. `.cache.prisma`) are skipped so generated
+ * artefacts don't accidentally get included.
  */
 
 import { existsSync, readFileSync, readdirSync, statSync } from "fs";
-import { join } from "path";
+import { join, sep } from "path";
+
+function collectPrismaFiles(params: { root: string }): string[] {
+  const { root } = params;
+  // Node 18.17+/Bun supports { recursive: true } — returns string[] of paths
+  // relative to `root`, with platform-native separators.
+  const entries = readdirSync(root, { recursive: true }) as string[];
+
+  const files: string[] = [];
+  for (const entry of entries) {
+    if (!entry.endsWith(".prisma")) continue;
+    // Skip dotfile-prefixed segments at any depth (e.g. `.cache/foo.prisma`,
+    // `models/.tmp.prisma`). This protects against accidentally bundling
+    // editor scratch files or third-party-tool artefacts.
+    const segments = entry.split(sep);
+    if (segments.some((s) => s.startsWith("."))) continue;
+
+    const absolute = join(root, entry);
+    // Skip directories that happen to end in `.prisma` (rare but possible).
+    if (!statSync(absolute).isFile()) continue;
+
+    files.push(entry);
+  }
+
+  // Sort by normalised forward-slash path so output is deterministic regardless
+  // of the platform's readdir ordering or path separator.
+  files.sort((a, b) => a.split(sep).join("/").localeCompare(b.split(sep).join("/")));
+  return files;
+}
 
 export function loadSchemaSource(params: { schemaPath: string }): string {
   const { schemaPath } = params;
@@ -26,22 +57,22 @@ export function loadSchemaSource(params: { schemaPath: string }): string {
   }
 
   if (stat.isDirectory()) {
-    const files = readdirSync(schemaPath)
-      .filter((f: string) => f.endsWith(".prisma"))
-      .sort();
+    const files = collectPrismaFiles({ root: schemaPath });
 
     if (files.length === 0) {
-      console.error(`Error: No .prisma files found in ${schemaPath}`);
+      console.error(`Error: No .prisma files found under ${schemaPath} (searched recursively)`);
       process.exit(1);
     }
 
     const sources: string[] = [];
     for (const file of files) {
       const filePath = join(schemaPath, file);
-      sources.push(`// --- ${file} ---\n` + readFileSync(filePath, "utf-8"));
+      // Use the forward-slash form in the header so diffs are stable across OSes.
+      const displayPath = file.split(sep).join("/");
+      sources.push(`// --- ${displayPath} ---\n` + readFileSync(filePath, "utf-8"));
     }
 
-    console.log(`  Loaded ${files.length} schema files from ${schemaPath}`);
+    console.log(`  Loaded ${files.length} schema file${files.length === 1 ? "" : "s"} from ${schemaPath}`);
     return sources.join("\n\n");
   }