prisma-laravel-migrate 0.0.3 → 0.0.5

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";
+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

package/dist/index.js

@@ -0,0 +1,220 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import fs from 'fs/promises';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import * as dmf from '@prisma/sdk';
+import { generateLaravelSchema } from './generator/migrator/index.js';
+import { generateLaravelModels } from './generator/modeler/index.js';
+import { existsSync, readFileSync } from 'fs';
+import { spawn } from 'child_process';
+const cli = new Command();
+cli
+    .name('prisma-laravel-cli')
+    .description('Initialize and customize Prisma→Laravel generators & stubs')
+    .version('0.1.0');
+//
+// init
+//
+cli
+    .command('init')
+    .description('Inject generators into schema.prisma and scaffold stubs/')
+    .option('-s, --schema <path>', 'Prisma schema file', 'prisma/schema.prisma')
+    .action(async (opts) => {
+    const schemaPath = path.resolve(process.cwd(), opts.schema);
+    let schema = await fs.readFile(schemaPath, 'utf-8');
+    // ① inject migrations generator
+    if (!/generator\s+migrations\s*\{/.test(schema)) {
+        schema += `
+generator migrations {
+  provider = "prisma-laravel-migrations"
+  output   = "database/migrations"
+  stubDir  = "./stubs"
+}
+`;
+        console.log('➡️  Added migrations generator');
+    }
+    // ② inject models generator
+    if (!/generator\s+models\s*\{/.test(schema)) {
+        schema += `
+generator models {
+  provider = "prisma-laravel-models"
+  output   = "app/Models"
+  outputEnumDir   = "app/Enums"
+  stubDir  = "./stubs"
+}
+`;
+        console.log('➡️  Added models generator');
+    }
+    await fs.writeFile(schemaPath, schema, 'utf-8');
+    console.log(`✅ Updated ${schemaPath}`);
+    // ③ copy your package’s built-in stubs into prisma/stubs/
+    const schemaDir = path.dirname(schemaPath);
+    const userStubs = path.join(schemaDir, 'stubs');
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = path.dirname(__filename);
+    const pkgStubs = path.resolve(__dirname, '../stubs');
+    for (const type of ['migration', 'model', 'enums']) {
+        const target = path.join(userStubs, type);
+        await fs.mkdir(target, { recursive: true });
+        // copy <type>.stub → <type>/index.stub
+        const src = path.join(pkgStubs, `${type}.stub`);
+        const dst = path.join(target, 'index.stub');
+        try {
+            await fs.access(dst);
+        }
+        catch {
+            await fs.copyFile(src, dst);
+            console.log(`➡️  Copied ${type}.stub → stubs/${type}/index.stub`);
+        }
+        // copy simple-model.stub too
+        if (type === 'model') {
+            const src2 = path.join(pkgStubs, 'simple-model.stub');
+            const dst2 = path.join(target, 'simple-model.stub');
+            try {
+                await fs.access(dst2);
+            }
+            catch {
+                await fs.copyFile(src2, dst2);
+                console.log(`➡️  Copied simple-model.stub → stubs/model/simple-model.stub`);
+            }
+        }
+    }
+    console.log('🎉 Initialization complete!');
+});
+//
+// customize
+//
+cli
+    .command('customize')
+    .alias('c')
+    .description('Scaffold per-table stub files from index.stub')
+    .option('-s, --schema <path>', 'Prisma schema file', 'prisma/schema.prisma')
+    .option('-t, --types <list>', 'Comma-separated: migration,model,enum', (val) => val.split(',').map(s => s.trim().toLowerCase()), [])
+    .option('-n, --names <list>', 'Comma-separated base names', (val) => val.split(',').map(s => s.trim()), [])
+    .action(async (opts) => {
+    const want = opts.types;
+    const bases = opts.names;
+    if (!want.length)
+        throw new Error('Specify at least one type with -t');
+    if (!bases.length)
+        throw new Error('Specify at least one name with -n');
+    // enums stand alone
+    if (want.includes('enum') && want.length > 1) {
+        throw new Error('`enum` cannot be combined with other types');
+    }
+    const schemaDir = path.dirname(path.resolve(process.cwd(), opts.schema));
+    const stubRoot = path.join(schemaDir, 'stubs');
+    const doBoth = want.includes('migration') && want.includes('model');
+    for (const t of want) {
+        if (t === 'enum') {
+            const dir = path.join(stubRoot, 'enum');
+            const idx = path.join(dir, 'index.stub');
+            await fs.mkdir(dir, { recursive: true });
+            for (const name of bases) {
+                const dst = path.join(dir, `${name}.stub`);
+                try {
+                    await fs.access(dst);
+                    console.log(`🟡 Skip enum/${name}.stub`);
+                }
+                catch {
+                    await fs.copyFile(idx, dst);
+                    console.log(`✅ Created enum/${name}.stub`);
+                }
+            }
+            continue;
+        }
+        for (const kind of doBoth ? ['migration', 'model'] : [t]) {
+            const dir = path.join(stubRoot, kind);
+            const idx = path.join(dir, 'index.stub');
+            await fs.mkdir(dir, { recursive: true });
+            for (const base of bases) {
+                const dst = path.join(dir, `${base}.stub`);
+                try {
+                    await fs.access(dst);
+                    console.log(`🟡 Skip ${kind}/${base}.stub`);
+                }
+                catch {
+                    await fs.copyFile(idx, dst);
+                    console.log(`✅ Created ${kind}/${base}.stub`);
+                }
+            }
+        }
+    }
+    console.log('🎉 Customize complete!');
+});
+//
+// proxy to Prisma generate
+//
+cli
+    .command('gen')
+    .description('Run Prisma generate, or skip it (--skipGenerate), then run Laravel generators')
+    .option('--config <path>', 'Path to prisma-laravel config file')
+    .option('--skipGenerate', 'Only run the Laravel generators (no Prisma generate)')
+    .action(async (opts) => {
+    const configPath = opts.config
+        ? path.resolve(process.cwd(), opts.config)
+        : path.resolve(process.cwd(), 'prisma-laravel.config.js');
+    if (!existsSync(configPath)) {
+        console.error(`❌ Config file not found: ${configPath}`);
+        process.exit(1);
+    }
+    const cfgMod = await import(configPath);
+    const cfg = cfgMod.default ?? cfgMod;
+    if (!cfg.generator?.config) {
+        console.error('❌ `generator.config` is required in your config.');
+        process.exit(1);
+    }
+    const schemaPrismaPath = cfg.schemaPath
+        ? path.resolve(process.cwd(), cfg.schemaPath)
+        : path.resolve(process.cwd(), 'prisma/schema.prisma');
+    if (!existsSync(schemaPrismaPath)) {
+        console.error(`❌ Schema not found: ${schemaPrismaPath}`);
+        process.exit(1);
+    }
+    const run = async () => {
+        const datamodel = readFileSync(schemaPrismaPath, 'utf-8');
+        const sdk = dmf.default ?? dmf;
+        const { dmmf } = await sdk.getDMMF({ datamodel });
+        await generateLaravelSchema({
+            dmmf,
+            //@ts-ignore
+            generator: { config: cfg.generator.config },
+            otherGenerators: [],
+            schemaPath: schemaPrismaPath,
+            datasources: [],
+            datamodel,
+            version: '',
+        });
+        await generateLaravelModels({
+            dmmf,
+            //@ts-ignore
+            generator: { config: cfg.generator.config },
+            otherGenerators: [],
+            schemaPath: schemaPrismaPath,
+            datasources: [],
+            datamodel,
+            version: '',
+        });
+    };
+    if (opts.skipGenerate) {
+        await run();
+    }
+    else {
+        const prisma = spawn('npx', ['prisma', 'generate'], {
+            stdio: 'inherit',
+            shell: true,
+        });
+        prisma.on('exit', (code) => {
+            if (code !== 0)
+                process.exit(code);
+            run().catch(e => {
+                console.error('❌ Gen failed:', e.message ?? e);
+                process.exit(1);
+            });
+        });
+    }
+});
+cli.parse(process.argv);
+cli.parse(process.argv);
+//# sourceMappingURL=index.js.map

package/dist/printer/migrations.js

@@ -1,32 +1,60 @@
 import fs from 'fs';
 import path from 'path';
-import { formatStub, sortMigrations } from '../generator/utils.js';
+import { formatStub, resolveStub } from '../generator/utils.js';
+import { sortMigrations } from '../generator/migrator/sort.js';
 export class StubMigrationPrinter {
+    cfg;
+    globalStubPath;
+    #currentStubPath = '';
     tmplFn;
-    constructor(stubFilePath) {
-        // Load the stub exactly as you wrote it, with no backticks
-        const stub = fs.readFileSync(path.resolve(stubFilePath), 'utf-8');
-        // Build a function that, given tableName and columns, returns
-        // the evaluated template literal of your stub.
-        // We inject the stub inside backticks here—your file stays untouched.
-        this.tmplFn = new Function('tableName', 'columns', 'definitions', 
-        // Wrap stub in backticks so that `${…}` inside it is evaluated now
-        `return \`${formatStub(stub)}\`;`);
+    constructor(
+    /** base config for per‐table stub resolution */
+    cfg, 
+    /** optional global override: if set, always use this stub */
+    globalStubPath) {
+        this.cfg = cfg;
+        this.globalStubPath = globalStubPath;
     }
+    /** Switch to the correct stub for this table (or reuse the last one) */
+    ensureStub(tableName) {
+        // 1) pick the stub path: global override wins, otherwise per‐table/group/index
+        // Prioritize per‐table/group/index stubs; only fall back to global override if none found
+        const resolved = resolveStub(this.cfg, 'migration', tableName);
+        const stubPath = resolved
+            ? resolved
+            : this.globalStubPath
+                ? path.resolve(process.cwd(), this.globalStubPath)
+                : (() => { throw new Error(`No stub found for migration '${tableName}'`); })();
+        if (stubPath === this.#currentStubPath) {
+            return;
+        }
+        // 2) load and compile
+        const raw = fs.readFileSync(path.resolve(stubPath), 'utf-8');
+        const escaped = formatStub(raw);
+        this.tmplFn = new Function('tableName', 'columns', 'definitions', `return \`${escaped}\`;`);
+        this.#currentStubPath = stubPath;
+    }
+    /**
+     * Render a single migration.
+     * Returns both the full file and the raw column block.
+     */
     printMigration(mig) {
-        // Prepare `columns` as a single string, indenting as you like
+        // ensure we have the right stub loaded
+        this.ensureStub(mig.tableName);
+        // prepare the indented columns block
         const columns = mig.statements
-            .map(line => '            ' + line) // match your stub’s indentation
+            .map(line => '            ' + line)
             .join('\n');
-        // Call the compiled template function
-        return {
-            fullContent: this.tmplFn(mig.tableName, columns, mig.definitions),
-            columns
-        };
+        // call the compiled template function
+        const fullContent = this.tmplFn(mig.tableName, columns, mig.definitions);
+        return { fullContent, columns };
     }
+    /** Helper to render all, sorted and joined with separators */
     printAll(migs) {
-        migs = sortMigrations(migs);
-        return migs.map(m => this.printMigration(m)).join('\n\n');
+        const sorted = sortMigrations(migs);
+        return sorted
+            .map(m => this.printMigration(m).fullContent)
+            .join('\n\n');
     }
 }
 //# sourceMappingURL=migrations.js.map