prisma-laravel-migrate 0.0.7 → 0.0.9

package/README.md

@@ -1,299 +1,482 @@
-# Prisma Laravel Migrate
-
-A generator plugin that translates your **Prisma schema** into Laravel‑ready  
-**Database Migrations**, **Eloquent Models**, and **Enum classes**.  
-Built in strict TypeScript with fully‑customisable stubs, grouping, and marker‑based updates.
-
----
-
-## 📦 Installation
-
-```bash
-npm install prisma-laravel-migrate --save-dev
-# requires the Prisma CLI in your project
-```
-
----
-
-## 🛠️ Prisma Generator Setup
-
-Add both generator blocks to **`schema.prisma`**:
-
-```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
-  groups      = "./prisma/group-stubs.js"
-}
-
-generator modeler {
-  provider      = "prisma-laravel-models"
-  stubDir       = "./prisma/stubs"
-  output        = "app/Models"
-  outputDir     = "app/Models"            // overrides output
-  outputEnumDir = "app/Enums"
-  startMarker   = "// <prisma-laravel:start>"
-  endMarker     = "// <prisma-laravel:end>"
-  noEmit        = false
-  groups        = "./prisma/group-stubs.js"
-}
-```
-
-### Field Reference
-
-| Key | Notes |
-| --- | --- |
-| `outputDir / output` | Destination folder (`outputDir` takes precedence). |
-| `outputEnumDir` | (modeler) directory for PHP enum classes. |
-| `stubDir` | Root stubs folder (`migration/`, `model/`, `enum/`). |
-| `startMarker/endMarker` | Region markers the generator will update. |
-| `groups` | JS module exporting stub‑group mappings. |
-| `noEmit` | If `true`, generator parses but **writes no** files. |
-
----
-
-## 📁 Stub Folder Layout
-
-```
-prisma/stubs/
-├── migration/index.stub
-├── model/index.stub
-├── model/simple-model.stub
-└── enum/index.stub
-```
-
-Create a table‑specific override with  
-`stubs/<type>/<table>.stub` (e.g. `stubs/model/users.stub`).
-
----
-
-## 🔧 CLI Commands
-
-| Command | What it does |
-| --- | --- |
-| `init` | Inject generator blocks & scaffold stub folders |
-| `customize` | Create per‑table stub overrides |
-| `gen` | Run `prisma generate` then Laravel generators |
-
-### init
-
-```bash
-npx prisma-laravel-cli init --schema=prisma/schema.prisma
-```
-
-### customize
-
-Generate override stubs.
-
-```bash
-npx prisma-laravel-cli customize \
-  -t <types> \
-  -n <names> \
-  [--force] \
-  [--config <path>]
-```
-
-| Flag | Description |
-| --- | --- |
-| `-t, --type` | **Required.** Comma‑separated list of stub types.<br>Valid values: `migration`, `model`, `enum`. You may combine `migration,model`; `enum` must be used alone. |
-| `-n, --names` | **Required.** Comma‑separated table or enum names (e.g. `users,accounts`). |
-| `--force` | Overwrite existing stub files. |
-| `--config` | Path to an alternate CLI config file (custom stubDir/groups). |
-
-**Behaviour**
-
-1. Checks `<stubDir>/<type>/<name>.stub`.
-2. If missing, copies from `index.stub` → that path and logs:  
-  `➡️ Created stubs/<type>/<name>.stub from index.stub`
-3. If present and `--force` **not** set:  
-  `⏭️ Skipped existing stubs/<type>/<name>.stub`
-4. With `--force`, overwrites and logs creation.
-
-**Example**
-
-```bash
-# migration + model overrides for two tables
-npx prisma-laravel-cli customize -t migration,model -n users,accounts
-```
-
-### gen
-
-```bash
-# run prisma generate then Laravel generators
-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:
-
-```js
-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",
-  },
-};
-```
-
----
-
-## ✨ Stub Customization Notes
-
-Stubs are **JS template literals**. Escape \\` and \\${ } if you want them literally.
-
-> **Full custom model stubs**  
-> If you plan to hand-craft **all** the internal sections yourself
-> (fillable, hidden, casts, etc.), remove the `${content}` placeholder
-> but **keep** the `// <prisma-laravel:start>` and
-> `// <prisma-laravel:end>` markers so the generator still knows where
-> to inject future updates.  
-> Remove the markers only if you never want the file touched again
-
----
-
-## 📑 Default Stub Templates
-
-<details>
-<summary>Enum <code>index.stub</code></summary>
-
-```php
-<?php
-
-namespace App\\Enums;
-
-enum ${enumDef.name}: string
-{
-    // <prisma-laravel:start>
-${enumDef.values.map(v => `    case ${v} = '${v}';`).join('\\n')}
-    // <prisma-laravel:end>
-}
-```
-
-</details>
-
-<details>
-<summary>Migration <code>index.stub</code></summary>
-
-```php
-<?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}');
-    }
-};
-```
-
-</details>
-
----
-
-## 🏗️ Complex Model Stub Example
-
-<details>
-<summary>Expand stub</summary>
-
-```php
-<?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')}
-    ];
-
-    /* Interfaces metadata */
-    public array $interfaces = [
-${Object.entries(model.interfaces).map(([k,i]) =>
-`        '${k}' => {${i.import ? ` import: '${i.import}',` : ''} type: '${i.type}' },`).join('\\n')}
-    ];
-    // This structure is useful for packages like fumeapp/modeltyper which
-    // read interface metadata to build TypeScript helpers.
-
-    /* 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>
-}
-```
-
-</details>
-
----
-
-## 🚀 Enum Casting
-
-```php
-protected $casts = [
-    'status' => StatusEnum::class,
-];
-```
-
----
-
-## 💡 Tips
-
-- Combine `migration` & `model` in one customize command when table names align.
-- Use `noEmit: true` for dry‑runs or CI validation.
-- Escape template chars in stub files.
-
----
-
-## 📜 License
-
+# Prisma Laravel Migrate
+
+A generator plugin that translates your **Prisma schema** into Laravel‑ready  
+**Database Migrations**, **Eloquent Models**, and **Enum classes**.  
+Built in strict TypeScript with fully‑customisable stubs, grouping, and smart merge updates.
+
+---
+
+## 📦 Installation
+
+```bash
+npm install prisma-laravel-migrate --save-dev
+# requires the Prisma CLI in your project
+```
+
+---
+
+## 🛠️ Prisma Generator Setup
+
+Add both generator blocks to **`schema.prisma`**:
+
+```prisma
+generator migrate {
+  provider  = "prisma-laravel-migrate"
+  stubDir   = "./prisma/stubs"
+
+  output    = "database/migrations"   // fallback
+  outputDir = "database/migrations"   // takes precedence
+
+  noEmit    = false                   // skip writing if true
+  groups    = "./prisma/group-stubs.js"
+}
+
+generator modeler {
+  provider      = "prisma-laravel-models"
+  stubDir       = "./prisma/stubs"
+
+  output        = "app/Models"
+  outputDir     = "app/Models"        // overrides output
+  outputEnumDir = "app/Enums"
+
+  noEmit        = false
+  groups        = "./prisma/group-stubs.js"
+}
+```
+
+### Field Reference
+
+| Key | Notes |
+| --- | --- |
+| `outputDir / output` | Destination folder (`outputDir` overrides `output`). |
+| `outputEnumDir` | (modeler) directory for generated enum classes. |
+| `stubDir` | Root stub folder (`migration/`, `model/`, `enum/`). |
+| `groups` | JS module that maps stub files to table groups. |
+| `noEmit` | If `true`, generator parses but **writes no** files (dry‑run). |
+
+---
+
+## 🔀 `groups` – Stub Grouping
+
+```prisma
+generator migrate {
+  provider = "prisma-laravel-migrate"
+  stubDir  = "./prisma/stubs"
+  groups   = "./prisma/group-stubs.js"
+}
+```
+
+`prisma/group-stubs.js`
+
+```js
+module.exports = [
+  {
+    stubFile: "auth.stub",                // stubs/migration/auth.stub
+    tables:   ["users","accounts","password_resets"]
+  },
+  {
+    stubFile: "billing.stub",             // stubs/migration/billing.stub
+    tables:   ["invoices","transactions"]
+  }
+];
+```
+
+**Resolution order**
+
+1. `stubs/<type>/<table>.stub` (table‑specific)
+2. Matching group stub (`stubFile`)
+3. `stubs/<type>/index.stub` (default)
+
+---
+
+## 📁 Stub Folder Layout
+
+```text
+prisma/stubs/
+├── migration/index.stub
+├── model/index.stub
+├── model/simple-model.stub
+└── enum/index.stub
+```
+
+Add table‑specific overrides at  
+`stubs/<type>/<table>.stub` (e.g. `stubs/model/users.stub`).
+
+---
+
+## 🔧 CLI Commands
+
+| Command | Purpose |
+| --- | --- |
+| `init` | Inject generator blocks & scaffold stub folders |
+| `customize` | Create per-table stub overrides |
+| `gen` | Run `prisma generate` then Laravel generators |
+
+### init
+
+```bash
+npx prisma-laravel-cli init --schema=prisma/schema.prisma
+```
+
+### customize
+
+```bash
+npx prisma-laravel-cli customize   -t migration,model   -n users,accounts   --force
+```
+
+| Flag | Description |
+| --- | --- |
+| `-t, --type` | **Required.** Stub types (`migration`, `model`, `enum`). `enum` may not mix. |
+| `-n, --names` | **Required.** Table or enum names (`users,accounts`). |
+| `--force` | Overwrite existing stub files. |
+| `--config` | Alternate CLI config path. |
+
+### gen
+
+```bash
+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`
+
+```js
+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"
+  }
+};
+```
+
+---
+
+## 🔄 How updates are applied
+
+1. Generator builds a **full new file** from your schema & stubs.
+2. Performs a **git‑style 3‑way merge** (using `node-diff3`):
+  - **base** = last generator output (`.prisma-laravel/backups/...`)
+  - **ours** = file on disk (user edits)
+  - **theirs** = freshly generated file
+3. Non‑conflicting changes merge automatically; conflicts are wrapped with  
+  `<<<<<<<`, `=======`, `>>>>>>>`.
+4. New `use …;` imports are merged, duplicates skipped.
+5. Baseline copy is updated in the backups folder.
+
+Delete the marker block **and** set `noEmit = true` to stop updates for a file.
+
+---
+
+## ✨ Stub Customisation Notes
+
+Stubs are **JavaScript template literals**. Escape \` and \${ } if you want them literally.
+
+> **Fully custom model stubs**  
+> If you remove the `${content}` placeholder **and** the marker block, the
+> generator leaves the file untouched.  
+> Keep the markers if you want automated updates but customised surroundings.
+
+---
+
+## 📑 Default Stub Templates
+
+<details>
+<summary>Enum <code>index.stub</code></summary>
+
+```php
+<?php
+
+namespace App\\Enums;
+
+enum ${enumDef.name}: string
+{
+    // <prisma-laravel:start>
+${enumDef.values.map(v => `    case ${v} = '${v}';`).join('\\n')}
+    // <prisma-laravel:end>
+}
+```
+
+</details>
+
+<details>
+<summary>Migration <code>index.stub</code></summary>
+
+```php
+<?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}');
+    }
+};
+```
+
+</details>
+
+---
+
+## 🏗️ Complex Model Stub Example
+
+<details>
+<summary>Expand stub</summary>
+
+```php
+<?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')}
+    ];
+
+    /* Interfaces metadata */
+    public array $interfaces = [
+${Object.entries(model.interfaces).map(([k,i]) =>
+`        '${k}' => {${i.import ? ` import: '${i.import}',` : ''} type: '${i.type}' },`).join('\\n')}
+    ];
+    // This structure is useful for packages like fumeapp/modeltyper which
+    // read interface metadata to build TypeScript helpers.
+
+    /* 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>
+}
+```
+
+</details>
+
+---
+
+## 🚀 Enum Casting
+
+```php
+protected $casts = [
+    'status' => StatusEnum::class,
+];
+```
+
+---
+
+
+## 🧩 Custom Migration Rules
+
+Point the generator’s `rules` field to a JS file exporting an **array** of
+objects that implement the `Rule` interface:
+
+```prisma
+generator migrate {
+  provider = "prisma-laravel-migration"
+  stubDir  = "./prisma/stubs"
+  rules    = "./prisma/custom-rules.js"
+}
+```
+
+`prisma/custom-rules.js`
+
+```js
+/** @type {import('prisma-laravel-migrate').Rule[]} */
+module.exports = [
+  {
+    // Always add an `archived` boolean column defaulting to false
+    test(def) {
+      return def.name === "archived" && def.migrationType === "boolean";
+    },
+    render() {
+      return {
+        column: "archived",
+        snippet: ["$table->boolean('archived')->default(false);"],
+      };
+    },
+  },
+  // add more Rule objects...
+];
+```
+
+**Rule execution order**
+
+1. Built‑in rules  
+2. Custom rules (executed in array order)
+
+---
+
+### ColumnDefinition quick reference
+
+`ColumnDefinition` extends Prisma’s `DMMF.Field`, so all raw Prisma
+properties remain accessible.
+
+```ts
+import { DMMF } from "@prisma/generator-helper";
+
+export interface ColumnDefinition extends DMMF.Field {
+  migrationType: MigrationType; // e.g. "unsignedBigInteger"
+  args?: string[];
+  nullable?: boolean;
+  unsigned?: boolean;
+
+  hasDefaultValue: boolean;
+  default?: string | number | boolean | null;
+
+  relationship?: {
+    on: string;
+    references?: string;
+    onDelete?: string;
+    onUpdate?: string;
+  };
+
+  ignore?: boolean;
+}
+```
+
+Common checks inside a rule:
+
+```ts
+def.kind          // "scalar" | "enum" | "object"
+def.type          // original Prisma scalar
+def.migrationType // mapped Laravel builder name
+def.isId
+```
+
+📝 **Prisma DMMF docs:**  
+https://github.com/prisma/prisma/blob/main/packages/prisma-schema-wasm/src/__tests__/snapshot/dmmf.md
+
+
+---
+
+### 📝 Comment-Directives in `schema.prisma`
+
+Attach these `@` directives either to a **field** (inline or `///` above) **or**
+to the **model** (curly‑brace syntax) to control what the generator writes into
+your Eloquent model.
+
+| Directive | Where you can put it | Effect in generated PHP |
+| --- | --- | --- |
+| `@fillable` | Field **or** `@fillable{...}` on model | Adds column(s) to `$fillable` |
+| `@hidden` | Field **or** `@hidden{...}` on model | Adds column(s) to `$hidden` |
+| `@guarded` | Field **or** `@guarded{...}` on model | Adds column(s) to `$guarded` |
+| `@cast{...}` | Field only | Adds custom entry to `$casts` |
+| `@type{ import:'…', type:'…' }` | Field only | Adds entry to `$interfaces` metadata |
+| `@ignore` | Relation field | Skips generating the relationship method |
+| `@with` (no args) | Relation field | Adds that single relation to `$with` |
+| `@with(rel1,rel2,…)` | Model only | Adds listed relations to `$with` |
+
+> **Syntax options**  
+> • Inline:  
+>  `balance Decimal /// @fillable @cast{decimal:2}`  
+> • Block above field:  
+>  `/// @hidden`  
+> • Model list:  
+>  `/// @fillable{name,balance}`  
+> • Model eager‑load:  
+>  `/// @with(posts,roles)`
+
+---
+
+#### Example
+
+```prisma
+/// @fillable{name,balance}
+/// @hidden{secretToken}
+model Account {
+  id        Int      @id @default(autoincrement())
+
+  balance   Decimal  @default(0.0) /// @cast{decimal:2}
+
+  nickname  String   /// @fillable @hidden
+
+  profile   Json?    /// @type{ import:'@types/forms', type:'ProfileDTO' }
+
+  company   Company? @relation(fields:[companyId], references:[id]) /// @ignore
+  companyId Int?
+
+  posts     Post[]   /// @with
+}
+
+/// @with(posts,comments)
+model User {
+  id       Int      @id @default(autoincrement())
+  email    String
+  posts    Post[]
+  comments Comment[]
+}
+```
+
+**Generated output**
+
+```php
+protected $fillable = ['name','balance','nickname'];
+protected $hidden   = ['secretToken','nickname'];
+protected $casts    = ['balance' => 'decimal:2'];
+
+public array $interfaces = [
+    'profile' => { import: '@types/forms', type: 'ProfileDTO' },
+];
+
+protected $with = ['posts','comments'];
+```
+
+`@ignore` prevents the `company()` relation method.  
+Combine multiple inline directives; they’re processed left‑to‑right.
+
+---
+
+## 💡 Tips
+
+- Combine `migration` & `model` in one customize command when table names align.
+- Use `noEmit: true` for dry‑runs or CI validation.
+- Escape template chars in stub files.
+
+---
+
+## 📜 License
+
 MIT — Happy scaffolding! 🎉

package/dist/diff-writer/backupPath.js

@@ -0,0 +1,14 @@
+import path from "path";
+import { mkdirSync, existsSync } from "fs";
+/** project-level hidden folder */
+const BACKUP_ROOT = path.resolve(process.cwd(), ".prisma-laravel", "backups");
+/** Returns `<root>/.prisma-laravel/backups/<relative-to-cwd>.bak` */
+export function backupPathFor(targetFile) {
+    const rel = path.relative(process.cwd(), targetFile);
+    const full = path.join(BACKUP_ROOT, rel + ".bak");
+    const dir = path.dirname(full);
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+    return full;
+}
+//# sourceMappingURL=backupPath.js.map

package/dist/diff-writer/writer.js

@@ -0,0 +1,37 @@
+// writeWithMerge.ts
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import * as diff3 from "node-diff3";
+import { backupPathFor } from "./backupPath.js";
+/**
+ * Git-style 3-way merge writer.
+ * @param filePath      Destination file
+ * @param newContent    Freshly generated FULL text
+ * @param overwrite     Skip write if false and file exists
+ */
+export function writeWithMerge(filePath, newContent, overwrite = true) {
+    if (!overwrite && existsSync(filePath))
+        return;
+    const bakPath = backupPathFor(filePath);
+    const base = existsSync(bakPath) ? readFileSync(bakPath, "utf-8") : null;
+    /* initial write */
+    if (!existsSync(filePath)) {
+        writeFileSync(filePath, newContent, "utf-8");
+        writeFileSync(bakPath, newContent, "utf-8");
+        return;
+    }
+    const mine = readFileSync(filePath, "utf-8");
+    if (mine === newContent)
+        return; // already up-to-date
+    /* no baseline yet → save current as baseline, overwrite */
+    if (!base) {
+        writeFileSync(bakPath, mine, "utf-8");
+        writeFileSync(filePath, newContent, "utf-8");
+        return;
+    }
+    /* diff3 merge */
+    const merged = diff3
+        .merge(mine.split(/\r?\n/), base.split(/\r?\n/), newContent.split(/\r?\n/), { stringSeparator: "\n" }).result.join("\n");
+    writeFileSync(filePath, merged, "utf-8");
+    writeFileSync(bakPath, newContent, "utf-8"); // update baseline
+}
+//# sourceMappingURL=writer.js.map

package/dist/generator/migrator/index.js

@@ -2,9 +2,9 @@ import { existsSync, mkdirSync, readdirSync } from "fs";
 import path from "path";
 import { PrismaToLaravelMigrationGenerator } from "./PrismaToLaravelMigrationGenerator.js";
 import { StubMigrationPrinter } from "../../printer/migrations.js";
-import { writeWithMarkers } from "../../generator/utils.js";
 import { fileURLToPath } from "url";
 import { sortMigrations } from "./sort.js";
+import { writeWithMerge } from "diff-writer/writer.js";
 export async function generateLaravelSchema(options) {
     const { dmmf, generator } = options;
     // 0) Pull config values (all come in as strings)
@@ -75,9 +75,9 @@ export async function generateLaravelSchema(options) {
             : `${timestamp}_create_${mig.tableName}_table.php`;
         const filePath = path.join(baseOut, fileName);
         // 3) Extract full & generated parts from your printer
-        const { fullContent: content, columns: generated } = printer.printMigration(mig);
+        const { fullContent: content } = printer.printMigration(mig);
         // 4) Write with markers as before
-        writeWithMarkers(filePath, content, generated, cfg.startMarker, cfg.endMarker, cfg.overwriteExisting ?? false);
+        writeWithMerge(filePath, content, cfg.overwriteExisting ?? false);
     });
     return migrations;
 }

package/dist/generator/modeler/generator.js

@@ -13,58 +13,80 @@ export class PrismaToLaravelModelGenerator {
             values: e.values.map((v) => v.name),
         }));
         // 2) Build each ModelDefinition
-        const models = this.dmmf.datamodel.models.map((model) => {
-            const tableName = model.dbName ?? model.name;
-            const className = model.name;
+        // 2) Build each ModelDefinition
+        const models = this.dmmf.datamodel.models.map(model => {
+            /* ── 2.1  Model-level directives ──────────────────────────────── */
             const modelDoc = model.documentation ?? "";
-            const guardedMatch = modelDoc.match(/@guarded\{([^}]+)\}/);
-            const guarded = guardedMatch
-                ? guardedMatch[1]
-                    .split(",")
-                    .map((s) => s.trim())
-                    .filter(Boolean)
-                : undefined;
-            const withList = [];
-            // 2a) Properties (scalars + enums + @fillable/@hidden/@ignore/@cast/@type)
-            const properties = model.fields.map((field) => {
+            // helper → get list from @tag{a,b,c}
+            const listFrom = (doc, tag) => {
+                const m = doc.match(new RegExp(`@${tag}\\{([^}]+)\\}`));
+                return m ? m[1].split(",").map(s => s.trim()).filter(Boolean) : [];
+            };
+            const modelFillable = listFrom(modelDoc, "fillable");
+            const modelHidden = listFrom(modelDoc, "hidden");
+            const modelGuarded = listFrom(modelDoc, "guarded");
+            // model-level eager-loads  @with(rel1,rel2)
+            const modelWith = (() => {
+                const m = modelDoc.match(/@with([^)]+)/);
+                return m ? m[1].split(",").map(s => s.trim()).filter(Boolean) : [];
+            })();
+            /* ── 2.2  Field processing ────────────────────────────────────── */
+            const withList = [...modelWith]; // eager-load bucket
+            const guardedSet = new Set(modelGuarded);
+            const fillableSet = new Set(modelFillable);
+            const hiddenSet = new Set(modelHidden);
+            const properties = model.fields.map(field => {
                 const doc = field.documentation ?? "";
-                const fillable = /@fillable\b/.test(doc);
-                const hidden = /@hidden\b/.test(doc);
-                const ignore = /@ignore\b/.test(doc);
-                // parse a single @cast{...}
+                // quick helper for boolean flags
+                const flag = (tag) => new RegExp(`@${tag}\\b`).test(doc);
+                const fillable = flag("fillable") || fillableSet.has(field.name);
+                const hidden = flag("hidden") || hiddenSet.has(field.name);
+                const guarded = flag("guarded") || guardedSet.has(field.name);
+                const ignore = flag("ignore");
+                // eager-load relation field
+                if (flag("with") && !withList.includes(field.name)) {
+                    withList.push(field.name);
+                }
+                // custom cast
                 const castMatch = doc.match(/@cast\{([^}]+)\}/);
-                let cast = castMatch ? castMatch[1].trim() : undefined;
-                const typeMatch = doc.match(/@type\s*(?:import\s*=\s*"([^"]+)")?\s*,?\s*type\s*=\s*"([^"]+)"/);
+                const cast = castMatch ? castMatch[1].trim() : undefined;
+                // @type{ import:'x', type:'Y' }
+                const typeMatch = doc.match(/@type\{\s*(?:import\s*:\s*'([^']+)')?\s*,?\s*type\s*:\s*'([^']+)'\s*\}/);
                 const typeAnnotation = typeMatch
                     ? { import: typeMatch[1], type: typeMatch[2] }
                     : undefined;
-                const enumMeta = enums.find((e) => e.name === field.type);
+                const enumMeta = enums.find(e => e.name === field.type);
                 const phpType = enumMeta
-                    ? `${field.type}`
+                    ? enumMeta.name
                     : this.mapPrismaToPhpType(field.type);
-                // with checking
-                if (doc.includes("@with"))
-                    withList.push(field.name);
                 return {
                     name: field.name,
                     phpType,
                     fillable,
                     hidden,
                     ignore,
+                    guarded,
                     cast,
                     enumRef: enumMeta?.name,
                     typeAnnotation,
                 };
             });
-            // 2b) Relations: skip any field marked @ignore
+            /* ── 2.3  Laravel $guarded array (union model + field) ─────────── */
+            const guarded = guardedSet.size || properties.some(p => p.guarded)
+                ? [
+                    ...guardedSet,
+                    ...properties.filter(p => p.guarded).map(p => p.name),
+                ]
+                : undefined;
+            /* ── 2.4  Relations (unchanged except @ignore honoured) ────────── */
             const relations = model.fields
-                .filter((f) => f.kind === "object" &&
+                .filter(f => f.kind === "object" &&
                 f.relationName &&
                 !/@ignore\b/.test(f.documentation ?? ""))
-                .map((f) => {
-                const relatedModel = this.dmmf.datamodel.models.find((m) => m.name === f.type);
+                .map(f => {
+                const relatedModel = this.dmmf.datamodel.models.find(m => m.name === f.type);
                 const relatedTable = relatedModel.dbName ?? f.type;
-                const thisTable = tableName;
+                const thisTable = model.dbName ?? model.name;
                 const isImplicitM2M = f.isList && (f.relationFromFields?.length ?? 0) === 0;
                 const relType = isImplicitM2M
                     ? "belongsToMany"
@@ -74,7 +96,7 @@ export class PrismaToLaravelModelGenerator {
                 let pivotTable;
                 if (relType === "belongsToMany") {
                     pivotTable = [thisTable, relatedTable]
-                        .map((t) => t.toLowerCase())
+                        .map(t => t.toLowerCase())
                         .sort()
                         .join("_");
                 }
@@ -87,22 +109,23 @@ export class PrismaToLaravelModelGenerator {
                     pivotTable,
                 };
             });
-            // 2c) Interfaces from @type annotations
+            /* ── 2.5  Interfaces from @type annotations ────────────────────── */
             const interfaces = {};
             for (const prop of properties) {
                 if (prop.typeAnnotation) {
                     interfaces[prop.name] = { ...prop.typeAnnotation };
                 }
             }
+            /* ── 2.6  Final ModelDefinition ────────────────────────────────── */
             return {
+                className: model.name,
+                tableName: model.dbName ?? model.name,
                 guarded,
-                className,
-                tableName,
                 properties,
                 relations,
                 enums,
                 interfaces,
-                with: withList.length ? withList : undefined
+                with: withList.length ? withList : undefined,
             };
         });
         return { models, enums };

package/dist/generator/modeler/index.js

@@ -1,9 +1,10 @@
 import { existsSync, mkdirSync } from "fs";
 import path from "path";
-import { buildModelContent, writeWithMarkers } from "../utils.js";
+import { buildModelContent } from "../utils.js";
 import { StubModelPrinter } from "../../printer/models.js";
 import { PrismaToLaravelModelGenerator } from "./generator.js";
 import { fileURLToPath } from "url";
+import { writeWithMerge } from "diff-writer/writer.js";
 export async function generateLaravelModels(options) {
     const { dmmf, generator } = options;
     // 0) Pull config values
@@ -51,7 +52,7 @@ export async function generateLaravelModels(options) {
     // 2) Load stubs (allow overrides)
     const modelStub = cfg.modelStubPath
         ? path.resolve(process.cwd(), cfg.modelStubPath)
-        : path.resolve(__dirname, "../../../stubs/simple-model.stub");
+        : path.resolve(__dirname, "../../../stubs/model.stub");
     const enumStub = cfg.enumStubPath
         ? path.resolve(process.cwd(), cfg.enumStubPath)
         : path.resolve(__dirname, "../../../stubs/enums.stub");
@@ -63,14 +64,16 @@ export async function generateLaravelModels(options) {
     for (const enumDef of enums) {
         const enumPhp = printer.printEnum(enumDef);
         const enumFile = path.join(enumsDir, `${enumDef.name}.php`);
-        writeWithMarkers(enumFile, enumPhp, enumDef.values.map(v => `    case ${v} = '${v}';`).join('\n'), cfg.startMarker, cfg.endMarker, cfg.overwriteExisting ?? false);
+        writeWithMerge(enumFile, enumPhp, cfg.overwriteExisting ?? false);
     }
     // 5) Write model files
     for (const model of models) {
+        model.imports = model.properties.filter(item => item.enumRef).map(item => `use App\\Enums\\${item.enumRef};`);
+        //----
         const content = buildModelContent(model);
         const modelPhp = printer.printModel(model, enums, content);
         const modelFile = path.join(modelsDir, `${model.className}.php`);
-        writeWithMarkers(modelFile, modelPhp, content, cfg.startMarker, cfg.endMarker, cfg.overwriteExisting ?? false);
+        writeWithMerge(modelFile, modelPhp, cfg.overwriteExisting ?? false);
     }
     return { models, enums };
 }

package/dist/generator/utils.js

@@ -1,6 +1,6 @@
 import { NativeToMigrationTypeMap } from "./migrator/column-maps.js";
 import { MigrationTypes } from "./migrator/migrationTypes.js";
-import { existsSync, readFileSync, writeFileSync } from 'fs';
+import { existsSync } from 'fs';
 import path from "path";
 /**
  * Given a Prisma field default, return the PHP code fragment
@@ -105,9 +105,21 @@ export function buildModelContent(model) {
     if (model.properties.some(p => p.cast || p.enumRef)) {
         lines.push(`protected $casts = [\n${model.properties
             .filter(p => p.cast || p.enumRef)
-            .map(p => `        '${p.name}' => ${p.enumRef ? `\\App\\Enums\\${p.enumRef}::class` : `'${p.cast}'`}`)
+            .map(p => `        '${p.name}' => ${p.enumRef ? `${p.enumRef}::class` : `'${p.cast}'`}`)
             .join(",\n")}\n    ];`);
     }
+    // — Interfaces metadata slot —
+    if (model.interfaces && Object.keys(model.interfaces).length) {
+        lines.push(`    public array $interfaces = [`);
+        for (const [key, info] of Object.entries(model.interfaces)) {
+            const parts = [];
+            if (info.import)
+                parts.push(`import: '${info.import}'`);
+            parts.push(`type: '${info.type}'`);
+            lines.push(`        '${key}' => { ${parts.join(', ')} },`);
+        }
+        lines.push(`    ];`);
+    }
     // 4) Relations (unchanged)
     for (const rel of model.relations) {
         const args = [
@@ -131,38 +143,6 @@ export function buildModelContent(model) {
  */
 export function formatStub(stub) {
     return stub;
-    // escape backslashes first
-    // .replace(/\\/g, '\\\\')
-    // then escape any backticks
-    // .replace(/`/g, '\\`');
-}
-/**
- * Safely write or update a file by replacing the region between
- * startMarker and endMarker if both exist, otherwise overwrite the whole file.
- *
- * @param filePath      Path to the target file
- * @param fullContent   The full text to write if markers are missing
- * @param generated     The text to inject between the markers
- * @param startMarker   Literal string marking the region start
- * @param endMarker     Literal string marking the region end
- * @param overwrite     If false and file exists, do nothing
- */
-export function writeWithMarkers(filePath, fullContent, generated, startMarker, endMarker, overwrite) {
-    // If the file exists but we're *not* overwriting, skip entirely
-    if (existsSync(filePath) && !overwrite)
-        return;
-    if (existsSync(filePath)) {
-        const existing = readFileSync(filePath, 'utf-8');
-        // If both markers are present, do an in‐place replace
-        if (existing.includes(startMarker) && existing.includes(endMarker)) {
-            const escaped = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-            const re = new RegExp(`${escaped(startMarker)}[\\s\\S]*?${escaped(endMarker)}`, 'm');
-            const updated = existing.replace(re, `${startMarker}\n${generated}\n${endMarker}`);
-            return writeFileSync(filePath, updated, 'utf-8');
-        }
-    }
-    // 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)

package/dist/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["../src/global.ts","../src/index.ts","../src/test.ts","../src/cli/index.ts","../src/cli/models.index.ts","../src/generator/utils.ts","../src/generator/migrator/prismatolaravelmigrationgenerator.ts","../src/generator/migrator/actions-map.ts","../src/generator/migrator/column-definition-types.ts","../src/generator/migrator/column-definition.ts","../src/generator/migrator/column-maps.ts","../src/generator/migrator/index.ts","../src/generator/migrator/migrationtypes.ts","../src/generator/migrator/rule-definition.ts","../src/generator/migrator/rules.ts","../src/generator/migrator/sort.ts","../src/generator/modeler/generator.ts","../src/generator/modeler/index.ts","../src/generator/modeler/types.ts","../src/printer/migrations.ts","../src/printer/models.ts"],"version":"5.7.2"}
+{"root":["../src/global.ts","../src/index.ts","../src/test.ts","../src/cli/index.ts","../src/cli/models.index.ts","../src/diff-writer/backuppath.ts","../src/diff-writer/writer.ts","../src/generator/utils.ts","../src/generator/migrator/prismatolaravelmigrationgenerator.ts","../src/generator/migrator/actions-map.ts","../src/generator/migrator/column-definition-types.ts","../src/generator/migrator/column-definition.ts","../src/generator/migrator/column-maps.ts","../src/generator/migrator/index.ts","../src/generator/migrator/migrationtypes.ts","../src/generator/migrator/rule-definition.ts","../src/generator/migrator/rules.ts","../src/generator/migrator/sort.ts","../src/generator/modeler/generator.ts","../src/generator/modeler/index.ts","../src/generator/modeler/types.ts","../src/printer/migrations.ts","../src/printer/models.ts"],"version":"5.7.2"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prisma-laravel-migrate",
-  "version": "0.0.7",
+  "version": "0.0.9",
   "description": "Generate laravel migrations and/or models using prisma files",
   "bin": {
     "prisma-laravel-migrations": "./dist/cli/index.js",
@@ -43,7 +43,9 @@
     "@types/node": "^24.0.3",
     "change-case": "^5.4.4",
     "dayjs": "^1.11.13",
+    "diff3": "^0.0.4",
     "jest": "^30.0.2",
+    "node-diff3": "^3.1.2",
     "pluralize": "^8.0.0",
     "prettier": "^3.5.3",
     "ts-node": "^10.9.2",