prisma-laravel-migrate 3.1.2 → 3.1.4

package/dist/cli/cli.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { Command } from 'commander';
-import fs8, { readFile } from 'fs/promises';
+import fs7, { readFile } from 'fs/promises';
 import path13, { resolve, extname, dirname } from 'path';
 import { fileURLToPath, pathToFileURL } from 'url';
 import fs, { existsSync, readdirSync, mkdirSync, readFileSync, writeFileSync, unlinkSync } from 'fs';
@@ -9,8 +9,8 @@ import { Minimatch } from 'minimatch';
 import * as diff3 from 'node-diff3';
 import * as prettier from 'prettier';
 import * as prettierPhp from '@prettier/plugin-php';
-import * as dmf2 from '@prisma/internals';
 import { spawn } from 'child_process';
+import * as dmf from '@prisma/internals';
 
 function nearestPkgType(fromPath) {
   try {
@@ -378,16 +378,18 @@ var listFrom = (doc, tag) => {
   return cleaned;
 };
 var FOLDER = "prisma-laravel-migrate";
-function getStubPath(pathString) {
+function getStubPath(pathString, folder) {
   const __filename = fileURLToPath(import.meta.url);
   const __dirname = path13.dirname(__filename);
+  const __file = folder ?? FOLDER;
   const normalised = pathString.replace(/\\/g, "/");
   const dir = __dirname.replace(/\\/g, "/");
-  const idx = dir.lastIndexOf(FOLDER);
+  const idx = dir.lastIndexOf(__file);
   if (idx === -1) {
+    if (!folder) return getStubPath(pathString, "prisma-to-laravel-migration");
     return path13.resolve(process.cwd(), normalised);
   }
-  const baseDir = dir.slice(0, idx + FOLDER.length);
+  const baseDir = dir.slice(0, idx + __file.length);
   return path13.join(baseDir, "stubs", normalised);
 }
 
@@ -2634,6 +2636,22 @@ var TsPrinter = class {
   // ---------------------------------------------------------------------------
   // IMPORTS
   // ---------------------------------------------------------------------------
+  normalizeTsImports(imports) {
+    const grouped = /* @__PURE__ */ new Map();
+    for (const imp of imports) {
+      if (!imp.from) continue;
+      const set = grouped.get(imp.from) ?? /* @__PURE__ */ new Set();
+      for (const t of imp.types ?? []) {
+        if (!t) continue;
+        set.add(t);
+      }
+      grouped.set(imp.from, set);
+    }
+    return Array.from(grouped.entries()).map(([from, set]) => ({
+      from,
+      types: Array.from(set).sort()
+    })).sort((a, b) => a.from.localeCompare(b.from));
+  }
   /**
    * Render import statements for a node that has an `imports` property:
    *   node.imports?: { from: string; types: string[] }[];
@@ -2643,26 +2661,55 @@ var TsPrinter = class {
   renderImports(node) {
     const imports = node.imports ?? [];
     if (!imports.length) return "";
-    return imports.map((i) => {
+    return this.normalizeTsImports(imports).map((i) => {
       const names = i.types.join(", ");
       return `import { ${names} } from ${JSON.stringify(i.from)};`;
     }).join("\n");
   }
   /**
-   * Merge & dedupe imports from multiple model contexts.
-   */
+  * Merge & dedupe imports from multiple model contexts.
+  *
+  * We re-parse the per-model import lines into TsImport objects so that
+  * `normalizeTsImports` can group everything by `from` and merge type lists.
+  */
   collectImports(ctxs) {
-    const set = /* @__PURE__ */ new Set();
+    const collected = [];
+    const importRe = /^import\s*\{\s*([^}]+)\}\s*from\s*(['"])([^'"]+)\2;?$/;
     for (const ctx of ctxs) {
       const raw = (ctx.imports || "").replace(/\r\n/g, "\n");
       if (!raw.trim()) continue;
       for (const line of raw.split("\n")) {
         const trimmed = line.trim();
         if (!trimmed) continue;
-        set.add(trimmed);
+        const m = importRe.exec(trimmed);
+        if (!m) {
+          if (trimmed.startsWith("import ")) {
+            collected.push({
+              from: trimmed,
+              // sentinel; will emit as-is below
+              types: []
+              // no types
+            });
+          }
+          continue;
+        }
+        const typeList = m[1].split(",").map((t) => t.trim()).filter(Boolean);
+        const from = m[3];
+        collected.push({ from, types: typeList });
       }
     }
-    return Array.from(set).join("\n");
+    const rawLines = collected.filter((imp) => !imp.types?.length && imp.from.startsWith("import ")).map((imp) => imp.from);
+    const structured = collected.filter(
+      (imp) => imp.types && imp.types.length && !imp.from.startsWith("import ")
+    );
+    const normalized = this.normalizeTsImports(structured);
+    const structuredLines = normalized.map(
+      (i) => `import { ${i.types.join(", ")} } from ${JSON.stringify(i.from)};`
+    );
+    const allLines = Array.from(
+      /* @__PURE__ */ new Set([...rawLines, ...structuredLines])
+    );
+    return allLines.join("\n");
   }
   // ---------------------------------------------------------------------------
   // MODEL RENDERING (DEFAULT)
@@ -2881,22 +2928,6 @@ function indentBlock(text, indent = "  ") {
 function getDefaultTsOutDir(generator) {
   return generator?.output?.value ?? "resources/ts/prisma";
 }
-async function loadMergedDatamodel(schemaPrismaPath) {
-  const schemaDir = path13.dirname(schemaPrismaPath);
-  const entries = readdirSync(schemaDir).filter(
-    (f) => f.endsWith(".prisma")
-  );
-  const order = [
-    // schema.prisma first
-    ...entries.filter((f) => f === "schema.prisma"),
-    // then the rest alphabetically
-    ...entries.filter((f) => f !== "schema.prisma").sort()
-  ];
-  const chunks = await Promise.all(
-    order.map((f) => fs8.readFile(path13.join(schemaDir, f), "utf-8"))
-  );
-  return chunks.join("\n\n");
-}
 function hasModelSpecificTsStub(model, cfg) {
   if (!cfg.stubDir) return false;
   const key = model.tableName && typeof model.tableName === "string" ? model.tableName : model.name;
@@ -2912,17 +2943,13 @@ function hasModelSpecificTsStub(model, cfg) {
   return path13.basename(stubPath) !== "index.stub";
 }
 async function generateTypesFromPrisma(options) {
-  const { generator } = options;
+  const { dmmf, generator } = options;
   const raw = generator.config ?? {};
-  const schemaPrismaPath = options.schemaPath;
-  const schemaDir = path13.dirname(schemaPrismaPath);
+  const schemaDir = path13.dirname(options.schemaPath);
   const shared = await loadSharedConfig(schemaDir);
   let groups = [];
   if (raw["groups"]) {
-    const groupsModulePath = path13.resolve(
-      process.cwd(),
-      raw["groups"]
-    );
+    const groupsModulePath = path13.resolve(process.cwd(), raw["groups"]);
     const importedModule = await import(groupsModulePath);
     const imported = importedModule.default ?? importedModule;
     if (!Array.isArray(imported)) {
@@ -2933,14 +2960,14 @@ async function generateTypesFromPrisma(options) {
     groups = imported;
   }
   const pick = (key, fallback) => (
-    // prisma-laravel.config.ts -> ts: {}
+    // shared.ts section (if present)
     shared.ts?.[key] ?? // shared root (if you keep ts props there)
     shared[key] ?? // generator block config
     raw[key] ?? // explicit fallback
     fallback
   );
   const cfg = {
-    // base Laravel-ish generator knobs
+    // Laravel-ish generator knobs
     overwriteExisting: pick("overwriteExisting", true),
     prettier: pick("prettier", false),
     noEmit: pick("noEmit", false),
@@ -2952,6 +2979,11 @@ async function generateTypesFromPrisma(options) {
     groups,
     // TS-specific
     outputDir: pick("outputDir") ?? getDefaultTsOutDir(generator),
+    /**
+     * declaration now only affects enums:
+     *  - true  → enums.d.ts
+     *  - false → enums.ts
+     */
     declaration: pick("declaration", false),
     shape: pick("shape", "interface"),
     scalarMap: pick("scalarMap"),
@@ -2959,7 +2991,9 @@ async function generateTypesFromPrisma(options) {
     readonlyArrays: pick("readonlyArrays", false),
     namePrefix: pick("namePrefix", ""),
     nameSuffix: pick("nameSuffix", ""),
-    moduleName: pick("moduleName", "database/prisma")
+    moduleName: pick("moduleName", "database/prisma"),
+    modelsFileName: pick("modelsFileName", "index"),
+    enumsFileName: pick("enumsFileName", "enums")
   };
   const tsOutDir = path13.resolve(process.cwd(), cfg.outputDir);
   if (!existsSync(tsOutDir)) {
@@ -2969,9 +3003,6 @@ async function generateTypesFromPrisma(options) {
   global._config.ts = {
     prettier: !!cfg.prettier
   };
-  const datamodel = await loadMergedDatamodel(schemaPrismaPath);
-  const sdk = dmf2.default ?? dmf2;
-  const { dmmf } = await sdk.getDMMF({ datamodel });
   const tsGen = new PrismaToTypesGenerator(dmmf, cfg);
   const {
     models,
@@ -2992,11 +3023,15 @@ async function generateTypesFromPrisma(options) {
     moduleName: cfg.moduleName,
     shape: cfg.shape
   });
-  const ext = cfg.declaration ? ".d.ts" : ".ts";
+  const modelExt = ".d.ts";
+  const enumExt = cfg.declaration ? ".d.ts" : ".ts";
   if (enums.length) {
     const enumsCode = printer.printEnums(enums);
     if (enumsCode.trim()) {
-      const enumsPath = path13.join(tsOutDir, `enums${ext}`);
+      const enumsPath = path13.join(
+        tsOutDir,
+        `${cfg.enumsFileName ?? "enums"}${enumExt}`
+      );
       await writeWithMerge(
         enumsPath,
         enumsCode,
@@ -3016,7 +3051,10 @@ async function generateTypesFromPrisma(options) {
     );
   }
   if (mainFile.trim()) {
-    const mainPath = path13.join(tsOutDir, `index${ext}`);
+    const mainPath = path13.join(
+      tsOutDir,
+      `${cfg.modelsFileName ?? "index"}${modelExt}`
+    );
     await writeWithMerge(
       mainPath,
       mainFile,
@@ -3030,7 +3068,7 @@ async function generateTypesFromPrisma(options) {
     const decoratedName = `${cfg.namePrefix ?? ""}${model.name}${cfg.nameSuffix ?? ""}`;
     const filePath = path13.join(
       tsOutDir,
-      `${decoratedName}${ext}`
+      `${decoratedName}${modelExt}`
     );
     await writeWithMerge(
       filePath,
@@ -3041,18 +3079,18 @@ async function generateTypesFromPrisma(options) {
   });
   return { models, enums, config: cfg };
 }
-async function loadMergedDatamodel2(schemaPrismaPath) {
+async function loadMergedDatamodel(schemaPrismaPath) {
   const schemaDir = path13.dirname(schemaPrismaPath);
   const entries = readdirSync(schemaDir).filter((f) => f.endsWith(".prisma"));
   const order = [
     ...entries.filter((f) => f === "schema.prisma"),
     ...entries.filter((f) => f !== "schema.prisma").sort()
   ];
-  const chunks = await Promise.all(order.map((f) => fs8.readFile(path13.join(schemaDir, f), "utf-8")));
+  const chunks = await Promise.all(order.map((f) => fs7.readFile(path13.join(schemaDir, f), "utf-8")));
   return chunks.join("\n\n");
 }
 async function getLaravelGeneratorConfigs(datamodel) {
-  const sdk = dmf2.default ?? dmf2;
+  const sdk = dmf.default ?? dmf;
   const { generators } = await sdk.getConfig({ datamodel });
   const findCfg = (provider) => (generators ?? []).find((g) => (g.provider?.value ?? "") === provider)?.config ?? {};
   const migCfg = findCfg("prisma-laravel-migrations");
@@ -3073,9 +3111,9 @@ async function runGenerators(configPath, skipPrismaGenerate = false) {
     throw new Error(`Schema not found: ${schemaPrismaPath}`);
   }
   const doRun = async () => {
-    const datamodel = await loadMergedDatamodel2(schemaPrismaPath);
+    const datamodel = await loadMergedDatamodel(schemaPrismaPath);
     const { migCfg, modCfg, tsCfg } = await getLaravelGeneratorConfigs(datamodel);
-    const sdk = dmf2.default ?? dmf2;
+    const sdk = dmf.default ?? dmf;
     const dmmf = await sdk.getDMMF({ datamodel });
     const config = (conf) => {
       return {
@@ -3133,7 +3171,7 @@ cli.command("init").description("Inject generators into schema.prisma and scaffo
   const stubDirRel = "./" + path13.relative(process.cwd(), userStubs).replace(/\\/g, "/");
   const __dirname = path13.dirname(fileURLToPath(import.meta.url));
   const pkgStubs = path13.resolve(__dirname, "../../stubs");
-  let schema = await fs8.readFile(schemaPath, "utf-8");
+  let schema = await fs7.readFile(schemaPath, "utf-8");
   const hasGenBlock = (name) => new RegExp(`generator\\s+${name}\\s*\\{`).test(schema);
   const hasMigrationsGen = hasGenBlock("migrations");
   const hasModelsGen = hasGenBlock("models");
@@ -3159,24 +3197,24 @@ generator types {
 `;
     console.log("\u27A1\uFE0F  Added types generator");
   }
-  await fs8.writeFile(schemaPath, schema, "utf-8");
+  await fs7.writeFile(schemaPath, schema, "utf-8");
   console.log(`\u2705 Updated ${schemaPath}`);
   const stubTypes = ["migration", "model", "enum"];
   for (const type of stubTypes) {
     const targetDir = path13.join(userStubs, type);
-    await fs8.mkdir(targetDir, { recursive: true });
+    await fs7.mkdir(targetDir, { recursive: true });
     const src = path13.join(pkgStubs, `${type}.stub`);
     const dst = path13.join(targetDir, "index.stub");
     try {
-      await fs8.access(dst);
+      await fs7.access(dst);
     } catch {
-      await fs8.copyFile(src, dst);
+      await fs7.copyFile(src, dst);
       console.log(`\u27A1\uFE0F  Copied ${type}.stub \u2192 stubs/${type}/index.stub`);
     }
   }
   const cfgPath = path13.join(schemaDir, "prisma-laravel.config.js");
   try {
-    await fs8.access(cfgPath);
+    await fs7.access(cfgPath);
   } catch {
     const cfgTemplate = `
 // prisma/prisma-laravel.config.js
@@ -3200,7 +3238,7 @@ module.exports = {
 
 };
 `;
-    await fs8.writeFile(cfgPath, cfgTemplate.trimStart(), "utf-8");
+    await fs7.writeFile(cfgPath, cfgTemplate.trimStart(), "utf-8");
     console.log("\u27A1\uFE0F  Created prisma-laravel.config.js");
   }
   console.log("\u{1F389} Initialization complete!");
@@ -3244,14 +3282,14 @@ cli.command("customize").alias("c").description("Scaffold per-table stub files f
     if (t === "enum") {
       const dir = path13.join(stubRoot, "enum");
       const idx = resolveStubIndex("enum");
-      await fs8.mkdir(dir, { recursive: true });
+      await fs7.mkdir(dir, { recursive: true });
       for (const name of bases) {
         const dst = path13.join(dir, `${name}.stub`);
         try {
-          await fs8.access(dst);
+          await fs7.access(dst);
           console.log(`\u{1F7E1} Skip enum/${name}.stub`);
         } catch {
-          await fs8.copyFile(idx, dst);
+          await fs7.copyFile(idx, dst);
           console.log(`\u2705 Created enum/${name}.stub`);
         }
       }
@@ -3260,14 +3298,14 @@ cli.command("customize").alias("c").description("Scaffold per-table stub files f
     if (t === "ts") {
       const dir = path13.join(stubRoot, "ts");
       const idx = resolveStubIndex("ts");
-      await fs8.mkdir(dir, { recursive: true });
+      await fs7.mkdir(dir, { recursive: true });
       for (const base of bases) {
         const dst = path13.join(dir, `${base}.stub`);
         try {
-          await fs8.access(dst);
+          await fs7.access(dst);
           console.log(`\u{1F7E1} Skip ts/${base}.stub`);
         } catch {
-          await fs8.copyFile(idx, dst);
+          await fs7.copyFile(idx, dst);
           console.log(`\u2705 Created ts/${base}.stub`);
         }
       }
@@ -3276,14 +3314,14 @@ cli.command("customize").alias("c").description("Scaffold per-table stub files f
     for (const kind of doBoth ? ["migration", "model"] : [t]) {
       const dir = path13.join(stubRoot, kind);
       const idx = resolveStubIndex(kind);
-      await fs8.mkdir(dir, { recursive: true });
+      await fs7.mkdir(dir, { recursive: true });
       for (const base of bases) {
         const dst = path13.join(dir, `${base}.stub`);
         try {
-          await fs8.access(dst);
+          await fs7.access(dst);
           console.log(`\u{1F7E1} Skip ${kind}/${base}.stub`);
         } catch {
-          await fs8.copyFile(idx, dst);
+          await fs7.copyFile(idx, dst);
           console.log(`\u2705 Created ${kind}/${base}.stub`);
         }
       }
@@ -3456,7 +3494,7 @@ cli.command("clean").description(
     const rmIfExists = async (p) => {
       if (!p || !existsSync(p)) return false;
       try {
-        await fs8.unlink(p);
+        await fs7.unlink(p);
         return true;
       } catch {
         return false;
@@ -3496,7 +3534,7 @@ cli.command("clean").description(
         }
         if (allRemoved) {
           try {
-            await fs8.rmdir(dir);
+            await fs7.rmdir(dir);
             return true;
           } catch {
             return false;

package/dist/cli/migrator.index.js

@@ -289,16 +289,18 @@ var listFrom = (doc, tag) => {
   return cleaned;
 };
 var FOLDER = "prisma-laravel-migrate";
-function getStubPath(pathString) {
+function getStubPath(pathString, folder) {
   const __filename = fileURLToPath(import.meta.url);
   const __dirname = path7.dirname(__filename);
+  const __file = folder ?? FOLDER;
   const normalised = pathString.replace(/\\/g, "/");
   const dir = __dirname.replace(/\\/g, "/");
-  const idx = dir.lastIndexOf(FOLDER);
+  const idx = dir.lastIndexOf(__file);
   if (idx === -1) {
+    if (!folder) return getStubPath(pathString, "prisma-to-laravel-migration");
     return path7.resolve(process.cwd(), normalised);
   }
-  const baseDir = dir.slice(0, idx + FOLDER.length);
+  const baseDir = dir.slice(0, idx + __file.length);
   return path7.join(baseDir, "stubs", normalised);
 }
 
@@ -1270,10 +1272,26 @@ function formatLaravelTimestamp(date, seq, width) {
 var { generatorHandler } = helperPkg;
 generatorHandler({
   onGenerate: generateLaravelSchema,
-  onManifest: () => ({
-    defaultOutput: "./database/migrations",
-    prettyName: "Laravel Schema"
-  })
+  async onManifest(options) {
+    const cfg = options.config ?? {};
+    let migrationsOutput;
+    migrationsOutput = cfg.outputDir;
+    if (!migrationsOutput && options.sourceFilePath) {
+      try {
+        const schemaDir = path7.dirname(options.sourceFilePath);
+        const shared = await loadSharedConfig(schemaDir);
+        migrationsOutput = shared?.migrate?.outputDir ?? shared?.output?.migrations ?? void 0;
+      } catch {
+      }
+    }
+    if (!migrationsOutput) {
+      migrationsOutput = "database/migrations";
+    }
+    return {
+      defaultOutput: migrationsOutput,
+      prettyName: `Laravel Migration Schema (migrations \u2192 ${migrationsOutput})`
+    };
+  }
 });
 //# sourceMappingURL=migrator.index.js.map
 //# sourceMappingURL=migrator.index.js.map

package/dist/cli/models.index.js

@@ -126,16 +126,18 @@ var listFrom = (doc, tag) => {
   return cleaned;
 };
 var FOLDER = "prisma-laravel-migrate";
-function getStubPath(pathString) {
+function getStubPath(pathString, folder) {
   const __filename = fileURLToPath(import.meta.url);
   const __dirname = path7.dirname(__filename);
+  const __file = folder ?? FOLDER;
   const normalised = pathString.replace(/\\/g, "/");
   const dir = __dirname.replace(/\\/g, "/");
-  const idx = dir.lastIndexOf(FOLDER);
+  const idx = dir.lastIndexOf(__file);
   if (idx === -1) {
+    if (!folder) return getStubPath(pathString, "prisma-to-laravel-migration");
     return path7.resolve(process.cwd(), normalised);
   }
-  const baseDir = dir.slice(0, idx + FOLDER.length);
+  const baseDir = dir.slice(0, idx + __file.length);
   return path7.join(baseDir, "stubs", normalised);
 }
 
@@ -1340,10 +1342,34 @@ function getOutDir(generator) {
 var { generatorHandler } = helperPkg;
 generatorHandler({
   onGenerate: generateLaravelModels,
-  onManifest: () => ({
-    defaultOutput: "./database/migrations",
-    prettyName: "Laravel Schema"
-  })
+  async onManifest(options) {
+    const cfg = options.config ?? {};
+    let modelOutput = cfg.outputDir;
+    let enumOutput;
+    if (options.sourceFilePath) {
+      try {
+        const schemaDir = path7.dirname(options.sourceFilePath);
+        const shared = await loadSharedConfig(schemaDir);
+        if (!modelOutput) {
+          modelOutput = shared?.modeler?.outputDir ?? shared?.output?.models ?? void 0;
+        }
+        enumOutput = shared?.modeler?.outputEnumDir ?? shared?.output?.enums ?? void 0;
+      } catch {
+      }
+    }
+    if (!modelOutput) {
+      modelOutput = "app/Models";
+    }
+    if (!enumOutput) {
+      enumOutput = "app/Enums";
+    }
+    return {
+      // Prisma can only use ONE path for the generator's output
+      defaultOutput: modelOutput,
+      // But we can loudly show BOTH model + enum destinations here
+      prettyName: `Laravel Models & Enums (models \u2192 ${modelOutput}, enums \u2192 ${enumOutput})`
+    };
+  }
 });
 //# sourceMappingURL=models.index.js.map
 //# sourceMappingURL=models.index.js.map

package/dist/cli/ts.index.js

@@ -1,8 +1,7 @@
 #!/usr/bin/env node
 import path7, { resolve, extname, dirname } from 'path';
-import fs, { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync, unlinkSync } from 'fs';
-import fs4, { readFile } from 'fs/promises';
-import * as dmf from '@prisma/internals';
+import fs, { existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync } from 'fs';
+import { readFile } from 'fs/promises';
 import { createRequire } from 'module';
 import { pathToFileURL } from 'url';
 import { Minimatch } from 'minimatch';
@@ -481,6 +480,22 @@ var TsPrinter = class {
   // ---------------------------------------------------------------------------
   // IMPORTS
   // ---------------------------------------------------------------------------
+  normalizeTsImports(imports) {
+    const grouped = /* @__PURE__ */ new Map();
+    for (const imp of imports) {
+      if (!imp.from) continue;
+      const set = grouped.get(imp.from) ?? /* @__PURE__ */ new Set();
+      for (const t of imp.types ?? []) {
+        if (!t) continue;
+        set.add(t);
+      }
+      grouped.set(imp.from, set);
+    }
+    return Array.from(grouped.entries()).map(([from, set]) => ({
+      from,
+      types: Array.from(set).sort()
+    })).sort((a, b) => a.from.localeCompare(b.from));
+  }
   /**
    * Render import statements for a node that has an `imports` property:
    *   node.imports?: { from: string; types: string[] }[];
@@ -490,26 +505,55 @@ var TsPrinter = class {
   renderImports(node) {
     const imports = node.imports ?? [];
     if (!imports.length) return "";
-    return imports.map((i) => {
+    return this.normalizeTsImports(imports).map((i) => {
       const names = i.types.join(", ");
       return `import { ${names} } from ${JSON.stringify(i.from)};`;
     }).join("\n");
   }
   /**
-   * Merge & dedupe imports from multiple model contexts.
-   */
+  * Merge & dedupe imports from multiple model contexts.
+  *
+  * We re-parse the per-model import lines into TsImport objects so that
+  * `normalizeTsImports` can group everything by `from` and merge type lists.
+  */
   collectImports(ctxs) {
-    const set = /* @__PURE__ */ new Set();
+    const collected = [];
+    const importRe = /^import\s*\{\s*([^}]+)\}\s*from\s*(['"])([^'"]+)\2;?$/;
     for (const ctx of ctxs) {
       const raw = (ctx.imports || "").replace(/\r\n/g, "\n");
       if (!raw.trim()) continue;
       for (const line of raw.split("\n")) {
         const trimmed = line.trim();
         if (!trimmed) continue;
-        set.add(trimmed);
+        const m = importRe.exec(trimmed);
+        if (!m) {
+          if (trimmed.startsWith("import ")) {
+            collected.push({
+              from: trimmed,
+              // sentinel; will emit as-is below
+              types: []
+              // no types
+            });
+          }
+          continue;
+        }
+        const typeList = m[1].split(",").map((t) => t.trim()).filter(Boolean);
+        const from = m[3];
+        collected.push({ from, types: typeList });
       }
     }
-    return Array.from(set).join("\n");
+    const rawLines = collected.filter((imp) => !imp.types?.length && imp.from.startsWith("import ")).map((imp) => imp.from);
+    const structured = collected.filter(
+      (imp) => imp.types && imp.types.length && !imp.from.startsWith("import ")
+    );
+    const normalized = this.normalizeTsImports(structured);
+    const structuredLines = normalized.map(
+      (i) => `import { ${i.types.join(", ")} } from ${JSON.stringify(i.from)};`
+    );
+    const allLines = Array.from(
+      /* @__PURE__ */ new Set([...rawLines, ...structuredLines])
+    );
+    return allLines.join("\n");
   }
   // ---------------------------------------------------------------------------
   // MODEL RENDERING (DEFAULT)
@@ -841,22 +885,6 @@ function safeUnlink(p) {
 function getDefaultTsOutDir(generator) {
   return generator?.output?.value ?? "resources/ts/prisma";
 }
-async function loadMergedDatamodel(schemaPrismaPath) {
-  const schemaDir = path7.dirname(schemaPrismaPath);
-  const entries = readdirSync(schemaDir).filter(
-    (f) => f.endsWith(".prisma")
-  );
-  const order = [
-    // schema.prisma first
-    ...entries.filter((f) => f === "schema.prisma"),
-    // then the rest alphabetically
-    ...entries.filter((f) => f !== "schema.prisma").sort()
-  ];
-  const chunks = await Promise.all(
-    order.map((f) => fs4.readFile(path7.join(schemaDir, f), "utf-8"))
-  );
-  return chunks.join("\n\n");
-}
 function hasModelSpecificTsStub(model, cfg) {
   if (!cfg.stubDir) return false;
   const key = model.tableName && typeof model.tableName === "string" ? model.tableName : model.name;
@@ -872,17 +900,13 @@ function hasModelSpecificTsStub(model, cfg) {
   return path7.basename(stubPath) !== "index.stub";
 }
 async function generateTypesFromPrisma(options) {
-  const { generator } = options;
+  const { dmmf, generator } = options;
   const raw = generator.config ?? {};
-  const schemaPrismaPath = options.schemaPath;
-  const schemaDir = path7.dirname(schemaPrismaPath);
+  const schemaDir = path7.dirname(options.schemaPath);
   const shared = await loadSharedConfig(schemaDir);
   let groups = [];
   if (raw["groups"]) {
-    const groupsModulePath = path7.resolve(
-      process.cwd(),
-      raw["groups"]
-    );
+    const groupsModulePath = path7.resolve(process.cwd(), raw["groups"]);
     const importedModule = await import(groupsModulePath);
     const imported = importedModule.default ?? importedModule;
     if (!Array.isArray(imported)) {
@@ -893,14 +917,14 @@ async function generateTypesFromPrisma(options) {
     groups = imported;
   }
   const pick = (key, fallback) => (
-    // prisma-laravel.config.ts -> ts: {}
+    // shared.ts section (if present)
     shared.ts?.[key] ?? // shared root (if you keep ts props there)
     shared[key] ?? // generator block config
     raw[key] ?? // explicit fallback
     fallback
   );
   const cfg = {
-    // base Laravel-ish generator knobs
+    // Laravel-ish generator knobs
     overwriteExisting: pick("overwriteExisting", true),
     prettier: pick("prettier", false),
     noEmit: pick("noEmit", false),
@@ -912,6 +936,11 @@ async function generateTypesFromPrisma(options) {
     groups,
     // TS-specific
     outputDir: pick("outputDir") ?? getDefaultTsOutDir(generator),
+    /**
+     * declaration now only affects enums:
+     *  - true  → enums.d.ts
+     *  - false → enums.ts
+     */
     declaration: pick("declaration", false),
     shape: pick("shape", "interface"),
     scalarMap: pick("scalarMap"),
@@ -919,7 +948,9 @@ async function generateTypesFromPrisma(options) {
     readonlyArrays: pick("readonlyArrays", false),
     namePrefix: pick("namePrefix", ""),
     nameSuffix: pick("nameSuffix", ""),
-    moduleName: pick("moduleName", "database/prisma")
+    moduleName: pick("moduleName", "database/prisma"),
+    modelsFileName: pick("modelsFileName", "index"),
+    enumsFileName: pick("enumsFileName", "enums")
   };
   const tsOutDir = path7.resolve(process.cwd(), cfg.outputDir);
   if (!existsSync(tsOutDir)) {
@@ -929,9 +960,6 @@ async function generateTypesFromPrisma(options) {
   global._config.ts = {
     prettier: !!cfg.prettier
   };
-  const datamodel = await loadMergedDatamodel(schemaPrismaPath);
-  const sdk = dmf.default ?? dmf;
-  const { dmmf } = await sdk.getDMMF({ datamodel });
   const tsGen = new PrismaToTypesGenerator(dmmf, cfg);
   const {
     models,
@@ -952,11 +980,15 @@ async function generateTypesFromPrisma(options) {
     moduleName: cfg.moduleName,
     shape: cfg.shape
   });
-  const ext = cfg.declaration ? ".d.ts" : ".ts";
+  const modelExt = ".d.ts";
+  const enumExt = cfg.declaration ? ".d.ts" : ".ts";
   if (enums.length) {
     const enumsCode = printer.printEnums(enums);
     if (enumsCode.trim()) {
-      const enumsPath = path7.join(tsOutDir, `enums${ext}`);
+      const enumsPath = path7.join(
+        tsOutDir,
+        `${cfg.enumsFileName ?? "enums"}${enumExt}`
+      );
       await writeWithMerge(
         enumsPath,
         enumsCode,
@@ -976,7 +1008,10 @@ async function generateTypesFromPrisma(options) {
     );
   }
   if (mainFile.trim()) {
-    const mainPath = path7.join(tsOutDir, `index${ext}`);
+    const mainPath = path7.join(
+      tsOutDir,
+      `${cfg.modelsFileName ?? "index"}${modelExt}`
+    );
     await writeWithMerge(
       mainPath,
       mainFile,
@@ -990,7 +1025,7 @@ async function generateTypesFromPrisma(options) {
     const decoratedName = `${cfg.namePrefix ?? ""}${model.name}${cfg.nameSuffix ?? ""}`;
     const filePath = path7.join(
       tsOutDir,
-      `${decoratedName}${ext}`
+      `${decoratedName}${modelExt}`
     );
     await writeWithMerge(
       filePath,
@@ -1004,10 +1039,27 @@ async function generateTypesFromPrisma(options) {
 var { generatorHandler } = helperPkg;
 generatorHandler({
   onGenerate: generateTypesFromPrisma,
-  onManifest: () => ({
-    defaultOutput: "./resources/js/types",
-    prettyName: "Laravel Schema"
-  })
+  async onManifest(options) {
+    const cfg = options.config ?? {};
+    let defaultOutput = cfg.outputDir;
+    if (!defaultOutput && options.sourceFilePath) {
+      try {
+        const schemaDir = path7.dirname(options.sourceFilePath);
+        const shared = await loadSharedConfig(schemaDir);
+        if (shared && shared.ts) {
+          defaultOutput = shared.ts.outputDir;
+        }
+      } catch {
+      }
+    }
+    if (!defaultOutput) {
+      defaultOutput = "resources/js/types";
+    }
+    return {
+      defaultOutput,
+      prettyName: "Typescript declarations"
+    };
+  }
 });
 //# sourceMappingURL=ts.index.js.map
 //# sourceMappingURL=ts.index.js.map

package/dist/index.js

@@ -5,9 +5,8 @@ import { Minimatch } from 'minimatch';
 import * as diff3 from 'node-diff3';
 import * as prettier from 'prettier';
 import * as prettierPhp from '@prettier/plugin-php';
-import fs6, { readFile } from 'fs/promises';
+import { readFile } from 'fs/promises';
 import { createRequire } from 'module';
-import * as dmf from '@prisma/internals';
 
 // src/generator/modeler/relationship/template-builder.ts
 var asArrayPhp = (xs) => `[${xs.map((x) => `'${x}'`).join(", ")}]`;
@@ -443,16 +442,18 @@ var listFrom = (doc, tag) => {
   return cleaned;
 };
 var FOLDER = "prisma-laravel-migrate";
-function getStubPath(pathString) {
+function getStubPath(pathString, folder) {
   const __filename = fileURLToPath(import.meta.url);
   const __dirname = path9.dirname(__filename);
+  const __file = folder ?? FOLDER;
   const normalised = pathString.replace(/\\/g, "/");
   const dir = __dirname.replace(/\\/g, "/");
-  const idx = dir.lastIndexOf(FOLDER);
+  const idx = dir.lastIndexOf(__file);
   if (idx === -1) {
+    if (!folder) return getStubPath(pathString, "prisma-to-laravel-migration");
     return path9.resolve(process.cwd(), normalised);
   }
-  const baseDir = dir.slice(0, idx + FOLDER.length);
+  const baseDir = dir.slice(0, idx + __file.length);
   return path9.join(baseDir, "stubs", normalised);
 }
 
@@ -2630,6 +2631,22 @@ var TsPrinter = class {
   // ---------------------------------------------------------------------------
   // IMPORTS
   // ---------------------------------------------------------------------------
+  normalizeTsImports(imports) {
+    const grouped = /* @__PURE__ */ new Map();
+    for (const imp of imports) {
+      if (!imp.from) continue;
+      const set = grouped.get(imp.from) ?? /* @__PURE__ */ new Set();
+      for (const t of imp.types ?? []) {
+        if (!t) continue;
+        set.add(t);
+      }
+      grouped.set(imp.from, set);
+    }
+    return Array.from(grouped.entries()).map(([from, set]) => ({
+      from,
+      types: Array.from(set).sort()
+    })).sort((a, b) => a.from.localeCompare(b.from));
+  }
   /**
    * Render import statements for a node that has an `imports` property:
    *   node.imports?: { from: string; types: string[] }[];
@@ -2639,26 +2656,55 @@ var TsPrinter = class {
   renderImports(node) {
     const imports = node.imports ?? [];
     if (!imports.length) return "";
-    return imports.map((i) => {
+    return this.normalizeTsImports(imports).map((i) => {
       const names = i.types.join(", ");
       return `import { ${names} } from ${JSON.stringify(i.from)};`;
     }).join("\n");
   }
   /**
-   * Merge & dedupe imports from multiple model contexts.
-   */
+  * Merge & dedupe imports from multiple model contexts.
+  *
+  * We re-parse the per-model import lines into TsImport objects so that
+  * `normalizeTsImports` can group everything by `from` and merge type lists.
+  */
   collectImports(ctxs) {
-    const set = /* @__PURE__ */ new Set();
+    const collected = [];
+    const importRe = /^import\s*\{\s*([^}]+)\}\s*from\s*(['"])([^'"]+)\2;?$/;
     for (const ctx of ctxs) {
       const raw = (ctx.imports || "").replace(/\r\n/g, "\n");
       if (!raw.trim()) continue;
       for (const line of raw.split("\n")) {
         const trimmed = line.trim();
         if (!trimmed) continue;
-        set.add(trimmed);
+        const m = importRe.exec(trimmed);
+        if (!m) {
+          if (trimmed.startsWith("import ")) {
+            collected.push({
+              from: trimmed,
+              // sentinel; will emit as-is below
+              types: []
+              // no types
+            });
+          }
+          continue;
+        }
+        const typeList = m[1].split(",").map((t) => t.trim()).filter(Boolean);
+        const from = m[3];
+        collected.push({ from, types: typeList });
       }
     }
-    return Array.from(set).join("\n");
+    const rawLines = collected.filter((imp) => !imp.types?.length && imp.from.startsWith("import ")).map((imp) => imp.from);
+    const structured = collected.filter(
+      (imp) => imp.types && imp.types.length && !imp.from.startsWith("import ")
+    );
+    const normalized = this.normalizeTsImports(structured);
+    const structuredLines = normalized.map(
+      (i) => `import { ${i.types.join(", ")} } from ${JSON.stringify(i.from)};`
+    );
+    const allLines = Array.from(
+      /* @__PURE__ */ new Set([...rawLines, ...structuredLines])
+    );
+    return allLines.join("\n");
   }
   // ---------------------------------------------------------------------------
   // MODEL RENDERING (DEFAULT)
@@ -2877,22 +2923,6 @@ function indentBlock(text, indent = "  ") {
 function getDefaultTsOutDir(generator) {
   return generator?.output?.value ?? "resources/ts/prisma";
 }
-async function loadMergedDatamodel(schemaPrismaPath) {
-  const schemaDir = path9.dirname(schemaPrismaPath);
-  const entries = readdirSync(schemaDir).filter(
-    (f) => f.endsWith(".prisma")
-  );
-  const order = [
-    // schema.prisma first
-    ...entries.filter((f) => f === "schema.prisma"),
-    // then the rest alphabetically
-    ...entries.filter((f) => f !== "schema.prisma").sort()
-  ];
-  const chunks = await Promise.all(
-    order.map((f) => fs6.readFile(path9.join(schemaDir, f), "utf-8"))
-  );
-  return chunks.join("\n\n");
-}
 function hasModelSpecificTsStub(model, cfg) {
   if (!cfg.stubDir) return false;
   const key = model.tableName && typeof model.tableName === "string" ? model.tableName : model.name;
@@ -2908,17 +2938,13 @@ function hasModelSpecificTsStub(model, cfg) {
   return path9.basename(stubPath) !== "index.stub";
 }
 async function generateTypesFromPrisma(options) {
-  const { generator } = options;
+  const { dmmf, generator } = options;
   const raw = generator.config ?? {};
-  const schemaPrismaPath = options.schemaPath;
-  const schemaDir = path9.dirname(schemaPrismaPath);
+  const schemaDir = path9.dirname(options.schemaPath);
   const shared = await loadSharedConfig(schemaDir);
   let groups = [];
   if (raw["groups"]) {
-    const groupsModulePath = path9.resolve(
-      process.cwd(),
-      raw["groups"]
-    );
+    const groupsModulePath = path9.resolve(process.cwd(), raw["groups"]);
     const importedModule = await import(groupsModulePath);
     const imported = importedModule.default ?? importedModule;
     if (!Array.isArray(imported)) {
@@ -2929,14 +2955,14 @@ async function generateTypesFromPrisma(options) {
     groups = imported;
   }
   const pick = (key, fallback) => (
-    // prisma-laravel.config.ts -> ts: {}
+    // shared.ts section (if present)
     shared.ts?.[key] ?? // shared root (if you keep ts props there)
     shared[key] ?? // generator block config
     raw[key] ?? // explicit fallback
     fallback
   );
   const cfg = {
-    // base Laravel-ish generator knobs
+    // Laravel-ish generator knobs
     overwriteExisting: pick("overwriteExisting", true),
     prettier: pick("prettier", false),
     noEmit: pick("noEmit", false),
@@ -2948,6 +2974,11 @@ async function generateTypesFromPrisma(options) {
     groups,
     // TS-specific
     outputDir: pick("outputDir") ?? getDefaultTsOutDir(generator),
+    /**
+     * declaration now only affects enums:
+     *  - true  → enums.d.ts
+     *  - false → enums.ts
+     */
     declaration: pick("declaration", false),
     shape: pick("shape", "interface"),
     scalarMap: pick("scalarMap"),
@@ -2955,7 +2986,9 @@ async function generateTypesFromPrisma(options) {
     readonlyArrays: pick("readonlyArrays", false),
     namePrefix: pick("namePrefix", ""),
     nameSuffix: pick("nameSuffix", ""),
-    moduleName: pick("moduleName", "database/prisma")
+    moduleName: pick("moduleName", "database/prisma"),
+    modelsFileName: pick("modelsFileName", "index"),
+    enumsFileName: pick("enumsFileName", "enums")
   };
   const tsOutDir = path9.resolve(process.cwd(), cfg.outputDir);
   if (!existsSync(tsOutDir)) {
@@ -2965,9 +2998,6 @@ async function generateTypesFromPrisma(options) {
   global._config.ts = {
     prettier: !!cfg.prettier
   };
-  const datamodel = await loadMergedDatamodel(schemaPrismaPath);
-  const sdk = dmf.default ?? dmf;
-  const { dmmf } = await sdk.getDMMF({ datamodel });
   const tsGen = new PrismaToTypesGenerator(dmmf, cfg);
   const {
     models,
@@ -2988,11 +3018,15 @@ async function generateTypesFromPrisma(options) {
     moduleName: cfg.moduleName,
     shape: cfg.shape
   });
-  const ext = cfg.declaration ? ".d.ts" : ".ts";
+  const modelExt = ".d.ts";
+  const enumExt = cfg.declaration ? ".d.ts" : ".ts";
   if (enums.length) {
     const enumsCode = printer.printEnums(enums);
     if (enumsCode.trim()) {
-      const enumsPath = path9.join(tsOutDir, `enums${ext}`);
+      const enumsPath = path9.join(
+        tsOutDir,
+        `${cfg.enumsFileName ?? "enums"}${enumExt}`
+      );
       await writeWithMerge(
         enumsPath,
         enumsCode,
@@ -3012,7 +3046,10 @@ async function generateTypesFromPrisma(options) {
     );
   }
   if (mainFile.trim()) {
-    const mainPath = path9.join(tsOutDir, `index${ext}`);
+    const mainPath = path9.join(
+      tsOutDir,
+      `${cfg.modelsFileName ?? "index"}${modelExt}`
+    );
     await writeWithMerge(
       mainPath,
       mainFile,
@@ -3026,7 +3063,7 @@ async function generateTypesFromPrisma(options) {
     const decoratedName = `${cfg.namePrefix ?? ""}${model.name}${cfg.nameSuffix ?? ""}`;
     const filePath = path9.join(
       tsOutDir,
-      `${decoratedName}${ext}`
+      `${decoratedName}${modelExt}`
     );
     await writeWithMerge(
       filePath,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prisma-laravel-migrate",
-  "version": "3.1.2",
+  "version": "3.1.4",
   "description": "Generate laravel migrations and/or models using prisma files",
   "bin": {
     "prisma-laravel-migrations": "./dist/cli/migrator.index.js",