prisma-laravel-migrate 0.0.4 → 0.0.6

package/README.md

@@ -0,0 +1,329 @@
+# Prisma Laravel Migrate
+
+A generator toolkit that translates your **Prisma schema** into Laravel-compatible  
+**Database Migrations**, **Eloquent Models**, and **Enum classes**.  
+Everything is written in strict TypeScript and fully customizable through stubs, grouping, and marker-based injection.
+
+---
+
+## 📦 Installation
+
+```bash
+npm install prisma-laravel-migrate --save-dev
+
+(Requires prisma in the same project.)
+
+
+---
+
+🛠️ Prisma Generator Setup
+
+Insert two generator blocks in schema.prisma:
+
+generator migrate {
+  provider    = "prisma-laravel-migrate"
+  stubDir     = "./prisma/stubs"
+  output      = "database/migrations"   // fallback
+  outputDir   = "database/migrations"   // takes precedence
+  startMarker = "// <prisma-laravel:start>"
+  endMarker   = "// <prisma-laravel:end>"
+  noEmit      = false                   // set true to skip writing files
+  groups      = "./prisma/group-stubs.js" // optional group mapping
+}
+
+generator modeler {
+  provider      = "prisma-laravel-models"
+  stubDir       = "./prisma/stubs"
+  output        = "app/Models"
+  outputDir     = "app/Models"          // takes precedence
+  outputEnumDir = "app/Enums"           // enums folder (optional)
+  startMarker   = "// <prisma-laravel:start>"
+  endMarker     = "// <prisma-laravel:end>"
+  noEmit        = false
+  groups        = "./prisma/group-stubs.js"
+}
+
+Field Reference
+
+Key	Notes
+
+output / outputDir	Destination folder; outputDir overrides output.
+outputEnumDir	(modeler) folder for PHP enum classes.
+stubDir	Root stubs folder (migration/, model/, enum/).
+startMarker / endMarker	Region markers the generator will update.
+groups	Path to JS module exporting stub-group mappings.
+noEmit	If true, generator parses but writes no files.
+
+
+
+---
+
+📁 Stub Folder Layout
+
+Running
+
+npx prisma-laravel-cli init --schema=prisma/schema.prisma
+
+creates:
+
+prisma/stubs/
+├── migration/index.stub
+├── model/index.stub
+├── model/simple-model.stub
+└── enum/index.stub
+
+Copy log (example):
+
+➡️  Copied migration.stub → stubs/migration/index.stub
+➡️  Copied model.stub     → stubs/model/index.stub
+➡️  Copied enums.stub     → stubs/enum/index.stub
+➡️  Copied simple-model.stub → stubs/model/simple-model.stub
+
+Override a single table / enum by adding
+stubs/<type>/<name>.stub (e.g. stubs/model/users.stub).
+
+
+---
+
+🔧 CLI Commands
+
+Command	Purpose
+
+init	Injects generator blocks & scaffold stub folders.
+customize	Create per-table stub overrides.
+gen	Run prisma generate and then Laravel generators.
+
+
+init
+
+npx prisma-laravel-cli init --schema=prisma/schema.prisma
+
+customize
+
+# create migration+model overrides for users & accounts
+npx prisma-laravel-cli customize -t migration,model -n users,accounts
+
+# create enum overrides
+npx prisma-laravel-cli customize -t enum -n UserStatus,RoleType
+
+migration & model may be combined; enum must be separate.
+
+gen
+
+# run prisma generate then Laravel generation
+npx prisma-laravel-cli gen --config=prisma/laravel.config.js
+
+# skip prisma generate step
+npx prisma-laravel-cli gen --config=prisma/laravel.config.js --skipGenerate
+
+prisma/laravel.config.js example:
+
+module.exports = {
+  migrator: {
+    outputDir: 'database/migrations',
+    stubDir: 'prisma/stubs',
+    groups: './prisma/group-stubs.js',
+  },
+  modeler: {
+    outputDir: 'app/Models',
+    outputEnumDir: 'app/Enums',
+    stubDir: 'prisma/stubs',
+    groups: './prisma/group-stubs.js',
+  },
+};
+
+
+---
+
+🧩 Grouping Stubs
+
+prisma/group-stubs.js
+
+module.exports = [
+  { stubFile: 'auth.stub',    tables: ['users','accounts','password_resets'] },
+  { stubFile: 'billing.stub', tables: ['invoices','transactions'] },
+];
+
+Resolution order
+
+1. stubs/<type>/<table>.stub
+
+
+2. Matching group stub (stubFile)
+
+
+3. stubs/<type>/index.stub
+
+
+
+
+---
+
+✨ Stub Customization Notes
+
+Stubs are JavaScript template literals. Escape \` and \${ } if you need them literally.
+
+Keep the ${content} placeholder inside the marker block if you want the generator to keep injecting its dynamic chunk.
+
+> Full Custom Model Stubs
+If you plan to hand-craft a model stub completely—removing both the ${content} placeholder and the // <prisma-laravel:start> / // <prisma-laravel:end> markers—set
+noEmit = true for the modeler generator (or exclude that table via custom rules).
+Otherwise, the generator has nowhere to inject its code and will skip the file.
+Leaving the markers + ${content} lets you customise everything around the generated region while the tool continues to maintain fillable lists, casts, and relations automatically.
+
+
+
+
+---
+
+📑 Default Stub Templates
+
+Enum
+
+<?php
+
+namespace App\\Enums;
+
+enum ${enumDef.name}: string
+{
+    // <prisma-laravel:start>
+${enumDef.values.map(v => `    case ${v} = '${v}';`).join('\\n')}
+    // <prisma-laravel:end>
+}
+
+Migration
+
+<?php
+
+use Illuminate\\Database\\Migrations\\Migration;
+use Illuminate\\Database\\Schema\\Blueprint;
+use Illuminate\\Support\\Facades\\Schema;
+
+return new class extends Migration
+{
+    public function up(): void
+    {
+        Schema::create('${tableName}', function (Blueprint $table) {
+            // <prisma-laravel:start>
+            ${columns}
+            // <prisma-laravel:end>
+        });
+    }
+
+    public function down(): void
+    {
+        Schema::dropIfExists('${tableName}');
+    }
+};
+
+
+---
+
+🏗️ Complex Model Stub Example
+
+<?php
+
+namespace App\\Models;
+
+${model.imports}
+use Illuminate\\Database\\Eloquent\\Model;
+use Illuminate\\Database\\Eloquent\\Relations\\{ BelongsTo, HasMany, BelongsToMany };
+
+class ${model.className} extends Model
+{
+    protected $table = '${model.tableName}';
+
+    /* ---------- Mass Assignment ---------- */
+    protected $fillable = [
+${model.properties.filter(p => p.fillable).map(p => `        '${p.name}',`).join('\\n')}
+    ];
+    protected $guarded = [
+${(model.guarded ?? []).map(n => `        '${n}',`).join('\\n')}
+    ];
+
+    /* ---------- Hidden / Casts ---------- */
+    protected $hidden = [
+${model.properties.filter(p => p.hidden).map(p => `        '${p.name}',`).join('\\n')}
+    ];
+    protected $casts = [
+${model.properties.filter(p => p.cast).map(p => `        '${p.name}' => '${p.cast}',`).join('\\n')}
+${model.properties.filter(p => p.enumRef).map(p => `        '${p.name}' => ${p.enumRef}::class,`).join('\\n')}
+    ];
+
+    /* ---------- Eager Loading ---------- */
+    protected $with = [
+${(model.with ?? []).map(r => `        '${r}',`).join('\\n')}
+    ];
+
+    /* ---------- Interfaces ---------- */
+    public array $interfaces = [
+${Object.entries(model.interfaces).map(([k,i]) => `        '${k}' => {${i.import ? ` import: '${i.import}',` : ''} type: '${i.type}' },`).join('\\n')}
+    ];
+
+    /* ---------- Relationships ---------- */
+${model.relations.map(r => {
+  const args = [r.modelClass, r.foreignKey ? `'${r.foreignKey}'` : '', r.localKey ? `'${r.localKey}'` : ''].filter(Boolean).join(', ');
+  return `    public function ${r.name}(): ${r.type.charAt(0).toUpperCase() + r.type.slice(1)}\\n    {\\n        return $this->${r.type}(${args});\\n    }`;
+}).join('\\n\\n')}
+
+    // <prisma-laravel:start>
+    ${content}
+    // <prisma-laravel:end>
+}
+
+
+---
+
+📚 Interfaces Metadata Example
+
+Useful for fumeapp/modeltyper integration:
+
+public array $interfaces = [
+    'props' => [
+        'import' => \"@typings/service-forms\",
+        'type'   => 'ServiceProps',
+    ],
+    'services' => [
+        'type' => 'Array<SMMService>',
+    ],
+];
+
+Type definition:
+Record<string, { import?: string; type: string }>.
+
+
+---
+
+🚀 Enum Casting
+
+The generator automatically casts Prisma enums:
+
+protected $casts = [
+    'status' => StatusEnum::class,
+];
+
+Enums are saved to outputEnumDir if configured.
+
+
+---
+
+💡 Tips
+
+Combine migration & model in the same customize command when table names align.
+
+Escape template characters in stub files.
+
+Use noEmit: true for dry-runs or CI validation.
+
+
+
+---
+
+📜 License
+
+MIT — Happy scaffolding! 🎉
+
+---
+
+Copy that entire block into **README.md** and you’ll have the corrected, full documentation—including the note about fully custom model stubs.
+

package/dist/cli/index.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
-import { generatorHandler } from "@prisma/generator-helper";
 import { generateLaravelSchema } from "../generator/migrator/index.js";
+import helperPkg from '@prisma/generator-helper';
+const { generatorHandler } = helperPkg;
 generatorHandler({
     onGenerate: generateLaravelSchema,
     onManifest: () => ({

package/dist/cli/models.index.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
-import { generatorHandler } from "@prisma/generator-helper";
 import { generateLaravelModels } from "../generator/modeler/index.js";
+import helperPkg from '@prisma/generator-helper';
+const { generatorHandler } = helperPkg;
 generatorHandler({
     onGenerate: generateLaravelModels,
     onManifest: () => ({

package/dist/generator/migrator/index.js

@@ -2,13 +2,25 @@ import { existsSync, mkdirSync, readdirSync } from "fs";
 import path from "path";
 import { PrismaToLaravelMigrationGenerator } from "./PrismaToLaravelMigrationGenerator.js";
 import { StubMigrationPrinter } from "../../printer/migrations.js";
-import { sortMigrations, writeWithMarkers } from "../../generator/utils.js";
+import { writeWithMarkers } from "../../generator/utils.js";
 import { fileURLToPath } from "url";
+import { sortMigrations } from "./sort.js";
 export async function generateLaravelSchema(options) {
     const { dmmf, generator } = options;
     // 0) Pull config values (all come in as strings)
     // Inside generateLaravelSchema()
     const raw = (generator.config ?? {});
+    // 0.a) Load groups from a JS file if provided
+    let groups = [];
+    if (raw["groups"]) {
+        const groupsModulePath = path.resolve(process.cwd(), raw["groups"]);
+        const imported = await import(groupsModulePath);
+        const exported = imported.default ?? imported;
+        if (!Array.isArray(exported)) {
+            throw new Error(`Custom groups module must export an array, but got ${typeof exported}`);
+        }
+        groups = exported;
+    }
     const cfg = {
         stubPath: raw["stubPath"],
         overwriteExisting: raw["overwriteExisting"] === "true",
@@ -16,6 +28,8 @@ export async function generateLaravelSchema(options) {
         outputDir: raw["outputDir"],
         startMarker: raw["startMarker"] ?? "// <prisma-laravel:start>",
         endMarker: raw["endMarker"] ?? "// <prisma-laravel:end>",
+        stubDir: raw["stubDir"],
+        groups,
     };
     // 1) Determine and ensure output directory exists
     const baseOut = cfg.outputDir
@@ -46,10 +60,10 @@ export async function generateLaravelSchema(options) {
     const __filename = fileURLToPath(import.meta.url);
     const __dirname = path.dirname(__filename);
     // 4) Prepare the stub printer
-    const stubFile = cfg.stubPath
+    const fallbackStubFile = cfg.stubPath
         ? path.resolve(process.cwd(), cfg.stubPath)
         : path.resolve(__dirname, "../../../stubs/migration.stub");
-    const printer = new StubMigrationPrinter(stubFile);
+    let printer = new StubMigrationPrinter(cfg, fallbackStubFile);
     // 5) Write each migration file
     migrations.forEach((mig, idx) => {
         const timestamp = formatLaravelTimestamp(new Date(), idx + 1);

package/dist/generator/migrator/sort.js

@@ -0,0 +1,75 @@
+/**
+ * Reorders migrations so that any table with foreign‐key dependencies
+ * is always migrated *after* the tables it references.
+ *
+ * @param migrations  Array of Migration objects (with tableName & definitions[])
+ * @returns           New array sorted in dependency order
+ * @throws            If there’s a cycle in the relationships
+ */
+export function sortMigrations(migrations) {
+    // 1) Build a map: tableName → Migration
+    const migMap = new Map(migrations.map(m => [m.tableName, m]));
+    // 2) Collect “true” FKs only (skip back‐relation object fields)
+    const rawDeps = new Map();
+    for (const { tableName } of migrations) {
+        rawDeps.set(tableName, new Set());
+    }
+    for (const m of migrations) {
+        for (const def of m.definitions) {
+            // only consider a relationship if:
+            //  - it exists (def.relationship)
+            //  - this field is a scalar FK column (def.kind === 'scalar')
+            //  - it's the owning side (relationFromFields non-empty)
+            if (!def.relationship ||
+                !def.relationFromFields ||
+                def.relationFromFields.length === 0) {
+                continue;
+            }
+            const parent = def.relationship.on;
+            if (!migMap.has(parent) || m.tableName == parent)
+                continue; // skip external tables
+            rawDeps.get(m.tableName).add(parent);
+        }
+    }
+    // 3) Build adjacency (parent → dependents) and in-degree (table → count)
+    const adj = new Map();
+    const inDegree = new Map();
+    for (const tbl of migMap.keys()) {
+        adj.set(tbl, []);
+        inDegree.set(tbl, 0);
+    }
+    for (const [child, parents] of rawDeps) {
+        for (const parent of parents) {
+            if (parent !== child)
+                adj.get(parent).push(child);
+            inDegree.set(child, inDegree.get(child) + 1);
+        }
+    }
+    // 4) Kahn’s algorithm: enqueue all zero in-degree tables
+    const queue = [];
+    for (const [tbl, deg] of inDegree) {
+        if (deg === 0)
+            queue.push(tbl);
+    }
+    const sorted = [];
+    while (queue.length) {
+        const tbl = queue.shift();
+        sorted.push(migMap.get(tbl));
+        for (const child of adj.get(tbl)) {
+            const nd = inDegree.get(child) - 1;
+            inDegree.set(child, nd);
+            if (nd === 0)
+                queue.push(child);
+        }
+    }
+    // 5) If not all processed, there is a genuine cycle
+    if (sorted.length !== migrations.length) {
+        const cycle = migrations
+            .map(m => m.tableName)
+            .filter(t => !sorted.some(s => s.tableName === t));
+        throw new Error(`Cycle detected in migration dependencies: ${cycle.join(' → ')}`);
+    }
+    console.log('\n📦 Sorted Migration Tables:\n' + sorted.map((item, i) => ` ${i + 1}. ${item.tableName}`).join('\n') + '\n');
+    return sorted;
+}
+//# sourceMappingURL=sort.js.map

package/dist/generator/modeler/index.js

@@ -9,13 +9,26 @@ export async function generateLaravelModels(options) {
     // 0) Pull config values
     // Inside generateLaravelModels()
     const raw = (generator.config ?? {});
+    let groups = [];
+    if (raw["groups"]) {
+        const groupsModulePath = path.resolve(process.cwd(), raw["groups"]);
+        const imported = await import(groupsModulePath);
+        const exported = imported.default ?? imported;
+        if (!Array.isArray(exported)) {
+            throw new Error(`Custom groups module must export an array, but got ${typeof exported}`);
+        }
+        groups = exported;
+    }
     const cfg = {
         modelStubPath: raw["modelStubPath"],
         enumStubPath: raw["enumStubPath"],
         overwriteExisting: raw["overwriteExisting"] === "true",
         outputDir: raw["outputDir"],
+        outputEnumDir: raw["outputEnumDir"],
         startMarker: raw["startMarker"] ?? "// <prisma-laravel:start>",
         endMarker: raw["endMarker"] ?? "// <prisma-laravel:end>",
+        stubDir: raw["stubDir"],
+        groups,
     };
     // 1) Determine and ensure output directories
     const modelsDir = cfg.outputDir
@@ -24,7 +37,10 @@ export async function generateLaravelModels(options) {
     if (!existsSync(modelsDir)) {
         mkdirSync(modelsDir, { recursive: true });
     }
-    const enumsDir = path.resolve(process.cwd(), "app/Enums");
+    const enumsDir = cfg.outputEnumDir
+        ? path.resolve(process.cwd(), cfg.outputEnumDir)
+        : path.resolve(process.cwd(), 'app/Enums');
+    console.log(enumsDir, cfg, process.cwd());
     if (!existsSync(enumsDir)) {
         mkdirSync(enumsDir, { recursive: true });
     }
@@ -39,7 +55,7 @@ export async function generateLaravelModels(options) {
     const enumStub = cfg.enumStubPath
         ? path.resolve(process.cwd(), cfg.enumStubPath)
         : path.resolve(__dirname, "../../../stubs/enums.stub");
-    const printer = new StubModelPrinter(modelStub, enumStub);
+    const printer = new StubModelPrinter(cfg, modelStub, enumStub);
     // 3) Generate definitions
     const schemaGen = new PrismaToLaravelModelGenerator(dmmf);
     const { models, enums } = schemaGen.generateAll();

package/dist/generator/utils.js

@@ -1,6 +1,7 @@
 import { NativeToMigrationTypeMap } from "./migrator/column-maps.js";
 import { MigrationTypes } from "./migrator/migrationTypes.js";
 import { existsSync, readFileSync, writeFileSync } from 'fs';
+import path from "path";
 /**
  * Given a Prisma field default, return the PHP code fragment
  * to append to your migration column definition.
@@ -77,79 +78,6 @@ export function getType(field) {
     // @ts-ignore
     return NativeToMigrationTypeMap[key] ?? MigrationTypes.string;
 }
-/**
- * Reorders migrations so that any table with foreign‐key dependencies
- * is always migrated *after* the tables it references.
- *
- * @param migrations  Array of Migration objects (with tableName & definitions[])
- * @returns           New array sorted in dependency order
- * @throws            If there’s a cycle in the relationships
- */
-export function sortMigrations(migrations) {
-    // 1) Build a map: tableName → Migration
-    const migMap = new Map(migrations.map(m => [m.tableName, m]));
-    // 2) Collect “true” FKs only (skip back‐relation object fields)
-    const rawDeps = new Map();
-    for (const { tableName } of migrations) {
-        rawDeps.set(tableName, new Set());
-    }
-    for (const m of migrations) {
-        for (const def of m.definitions) {
-            // only consider a relationship if:
-            //  - it exists (def.relationship)
-            //  - this field is a scalar FK column (def.kind === 'scalar')
-            //  - it's the owning side (relationFromFields non-empty)
-            if (!def.relationship ||
-                !def.relationFromFields ||
-                def.relationFromFields.length === 0) {
-                continue;
-            }
-            const parent = def.relationship.on;
-            if (!migMap.has(parent))
-                continue; // skip external tables
-            rawDeps.get(m.tableName).add(parent);
-        }
-    }
-    // 3) Build adjacency (parent → dependents) and in-degree (table → count)
-    const adj = new Map();
-    const inDegree = new Map();
-    for (const tbl of migMap.keys()) {
-        adj.set(tbl, []);
-        inDegree.set(tbl, 0);
-    }
-    for (const [child, parents] of rawDeps) {
-        for (const parent of parents) {
-            adj.get(parent).push(child);
-            inDegree.set(child, inDegree.get(child) + 1);
-        }
-    }
-    // 4) Kahn’s algorithm: enqueue all zero in-degree tables
-    const queue = [];
-    for (const [tbl, deg] of inDegree) {
-        if (deg === 0)
-            queue.push(tbl);
-    }
-    const sorted = [];
-    while (queue.length) {
-        const tbl = queue.shift();
-        sorted.push(migMap.get(tbl));
-        for (const child of adj.get(tbl)) {
-            const nd = inDegree.get(child) - 1;
-            inDegree.set(child, nd);
-            if (nd === 0)
-                queue.push(child);
-        }
-    }
-    // 5) If not all processed, there is a genuine cycle
-    if (sorted.length !== migrations.length) {
-        const cycle = migrations
-            .map(m => m.tableName)
-            .filter(t => !sorted.some(s => s.tableName === t));
-        throw new Error(`Cycle detected in migration dependencies: ${cycle.join(' → ')}`);
-    }
-    console.log(sorted.map(item => item.tableName));
-    return sorted;
-}
 export function buildModelContent(model) {
     const lines = [];
     // 1) If @guarded is used, emit $guarded instead of $fillable
@@ -236,4 +164,31 @@ export function writeWithMarkers(filePath, fullContent, generated, startMarker,
     // Otherwise write the full content (which itself can include the markers)
     writeFileSync(filePath, fullContent, 'utf-8');
 }
+export function resolveStub(cfg, type, tableName) {
+    if (!cfg.stubDir)
+        return;
+    //---
+    const dir = path.resolve(process.cwd(), cfg.stubDir, type);
+    // A) 1st: file‐based override: <tableName>.stub
+    const fileOverride = path.join(dir, `${tableName}.stub`);
+    if (existsSync(fileOverride)) {
+        return fileOverride;
+    }
+    // B) 2nd: group‐based override
+    if (cfg.groups) {
+        for (const { stubFile, tables } of cfg.groups) {
+            if (tables.includes(tableName)) {
+                const groupPath = path.join(dir, stubFile);
+                if (existsSync(groupPath)) {
+                    return groupPath;
+                }
+            }
+        }
+    }
+    // C) Fallback to index.stub
+    const defaultPath = path.join(dir, "index.stub");
+    if (!existsSync(defaultPath))
+        return;
+    return defaultPath;
+}
 //# sourceMappingURL=utils.js.map