@omnifyjp/omnify 6.2.0 → 6.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@omnifyjp/omnify",
-  "version": "6.2.0",
+  "version": "6.3.1",
   "description": "Schema-driven code generation for Laravel, TypeScript, and SQL",
   "license": "MIT",
   "repository": {
@@ -36,10 +36,10 @@
     "zod": "^3.24.0"
   },
   "optionalDependencies": {
-    "@omnifyjp/omnify-darwin-arm64": "6.2.0",
-    "@omnifyjp/omnify-darwin-x64": "6.2.0",
-    "@omnifyjp/omnify-linux-x64": "6.2.0",
-    "@omnifyjp/omnify-linux-arm64": "6.2.0",
-    "@omnifyjp/omnify-win32-x64": "6.2.0"
+    "@omnifyjp/omnify-darwin-arm64": "6.3.1",
+    "@omnifyjp/omnify-darwin-x64": "6.3.1",
+    "@omnifyjp/omnify-linux-x64": "6.3.1",
+    "@omnifyjp/omnify-linux-arm64": "6.3.1",
+    "@omnifyjp/omnify-win32-x64": "6.3.1"
   }
 }

package/ts-dist/cli.js

@@ -29,6 +29,7 @@ import { Command } from 'commander';
 import { parse as parseYaml } from 'yaml';
 import { generateTypeScript } from './generator.js';
 import { generatePhp, derivePhpConfig } from './php/index.js';
+import { stripPhpComments } from './php/types.js';
 import { pruneOrphanServiceFilesIfEnabled } from './php/orphan-cleanup.js';
 import { findSiblingWithSameBasename, findAppRootAncestor } from './php/sibling-skip.js';
 import { runPintFormat } from './php/pint-format.js';
@@ -100,6 +101,11 @@ function resolveFromConfig(configPath) {
         route: laravelConfig?.route,
         config: laravelConfig?.config,
         nestedset: laravelConfig?.nestedset,
+        modules: laravelConfig?.modules,
+        shared: laravelConfig?.shared,
+        enums: laravelConfig?.enums,
+        traits: laravelConfig?.traits,
+        openapi: laravelConfig?.openapi,
     } : undefined;
     return {
         inputSpec,
@@ -226,6 +232,7 @@ program
         let phpOverwritten = 0;
         let phpSkipped = 0;
         let phpSkippedSibling = 0;
+        let phpShadowed = 0;
         const skippedSiblingExamples = [];
         const writtenPaths = [];
         for (const file of phpFiles) {
@@ -233,11 +240,24 @@ program
             mkdirSync(dirname(filePath), { recursive: true });
             if (!file.overwrite && existsSync(filePath)) {
                 phpSkipped++;
+                const existing = file.expects || (file.conflicts && file.conflicts.length > 0)
+                    ? readFileSync(filePath, 'utf-8')
+                    : '';
                 // The file predates something the template now needs. Say so once,
                 // naming the file and the line, rather than rewriting user code.
-                if (file.expects && !readFileSync(filePath, 'utf-8').includes(file.expects.needle)) {
+                if (file.expects && !existing.includes(file.expects.needle)) {
                     console.warn(`[omnify-ts] ${relative(configDir, filePath)}: ${file.expects.hint}`);
                 }
+                // The mirror: the file contains an edit that silently disables what
+                // the base generates. #171 — a redeclared $fillable shadows the
+                // parent's, so every property added afterwards is stripped on mass
+                // assignment with no error anywhere.
+                for (const conflict of file.conflicts ?? []) {
+                    if (new RegExp(conflict.pattern).test(stripPhpComments(existing))) {
+                        phpShadowed++;
+                        console.warn(`[omnify-ts] ${relative(configDir, filePath)}: ${conflict.hint}`);
+                    }
+                }
                 continue;
             }
             // Issue #98 v5.8.18 / #99 v5.8.19: skip user-editable stub
@@ -285,6 +305,10 @@ program
             console.log(`  ${phpCreated} files created (user-editable)`);
         if (phpSkipped > 0)
             console.log(`  ${phpSkipped} files skipped (already exist)`);
+        if (phpShadowed > 0) {
+            console.warn(`  ${phpShadowed} editable file(s) shadow a generated property — ` +
+                `schema changes will NOT reach them until that is fixed (see warnings above).`);
+        }
         if (phpSkippedSibling > 0) {
             console.log(`  ${phpSkippedSibling} user-editable stub(s) skipped (project sibling with same name found in subfolder)`);
             for (const ex of skippedSiblingExamples) {

package/ts-dist/php/audit-observer-generator.js

@@ -72,9 +72,7 @@ class WriteAuditLog implements ShouldQueue
      *                                         ip_address, user_agent, tags,
      *                                         created_at).
      */
-    public function __construct(public array $payload)
-    {
-    }
+    public function __construct(public array $payload) {}
 
     /**
      * Default retry behaviour: try 3 times with 5-second backoff between
@@ -197,7 +195,7 @@ class Audit extends Model
      */
     public function prunable(): Builder
     {
-        $retention = (string) config('omnify.audit.logRetention', ${JSON.stringify(retention)});
+        $retention = (string) config('omnify.audit.logRetention', '${retention.replace(/\\/g, '\\\\').replace(/'/g, "\\'")}');
         if ($retention === '') {
             return static::query()->whereRaw('1 = 0');
         }

package/ts-dist/php/audit-trait-generator.js

@@ -156,6 +156,7 @@ trait HasOmnifyAuditLog
      * restores the previous state, even on exception.
      *
      * @template T
+     *
      * @param  callable(): T  $callback
      * @return T
      */

package/ts-dist/php/enum-generator.js

@@ -59,7 +59,7 @@ ${labelsConst}
     public function label(?string $locale = null): string
     {
         $locale = $locale ?? app()->getLocale();
-        $labels = static::LABELS[$this->value] ?? [];
+        $labels = self::LABELS[$this->value] ?? [];
 
         return $labels[$locale]
             ?? $labels[config('app.fallback_locale', 'en')]

package/ts-dist/php/file-model-generator.js

@@ -138,9 +138,9 @@ use ${traitsNamespace}\\HasLocalizedDisplayName;${sharedModelsNamespace !== base
  */
 class FileBaseModel extends BaseModel
 {
+    use HasLocalizedDisplayName;
     use HasUuids;
     use SoftDeletes;
-    use HasLocalizedDisplayName;
 
     /**
      * The table associated with the model.

package/ts-dist/php/file-trait-generator.js

@@ -55,11 +55,13 @@ trait HasFiles
     /**
      * Attach files by IDs to a collection, making them permanent.
      *
-     * @param array<string> $fileIds
+     * @param  array<string>  $fileIds
      */
     public function attachFiles(array $fileIds, string $collection = 'default', int $startOrder = 0): void
     {
-        if (empty($fileIds)) return;
+        if (empty($fileIds)) {
+            return;
+        }
 
         File::whereIn('id', $fileIds)->update([
             'fileable_type' => $this->getMorphClass(),
@@ -67,14 +69,14 @@ trait HasFiles
             'collection' => $collection,
             'status' => FileStatusEnum::Permanent,
             'expires_at' => null,
-            'sort_order' => \\Illuminate\\Support\\Facades\\DB::raw('sort_order + ' . $startOrder),
+            'sort_order' => \\Illuminate\\Support\\Facades\\DB::raw('sort_order + '.$startOrder),
         ]);
     }
 
     /**
      * Sync files for a collection (detach old, attach new).
      *
-     * @param array<string> $fileIds
+     * @param  array<string>  $fileIds
      */
     public function syncFiles(array $fileIds, string $collection = 'default'): void
     {

package/ts-dist/php/index.js

@@ -35,6 +35,7 @@ import { generateControllers } from './controller-generator.js';
 import { generateServices } from './service-generator.js';
 import { generateRoutes } from './route-generator.js';
 import { generateEnums } from './enum-generator.js';
+import { normalizeNotOperator, normalizePhpBlankLines, normalizePhpStatements, normalizeTopLevelUses } from './php-style.js';
 import { generateOpenApi } from './openapi-generator.js';
 import { generateArchitectureDoc } from './architecture-doc-generator.js';
 export { derivePhpConfig } from './types.js';
@@ -111,5 +112,10 @@ export function generatePhp(data, overrides) {
     // no behavior change for existing consumers, and the doc updates
     // automatically as schemas / config change so it never drifts.
     files.push(...generateArchitectureDoc(reader, config));
-    return files;
+    // #174: every generated PHP file leaves here in Pint's import shape —
+    // unused imports dropped, the rest ordered. Doing it once, centrally, is why
+    // no template has to remember: the two rules fired on almost every layer.
+    return files.map((file) => file.path.endsWith('.php')
+        ? { ...file, content: normalizePhpBlankLines(normalizePhpStatements(normalizeNotOperator(normalizeTopLevelUses(file.content)))) }
+        : file);
 }

package/ts-dist/php/model-generator.js

@@ -5,7 +5,7 @@ import { toPascalCase, toSnakeCase, toCamelCase, toFkColumnName, pluralize } fro
 import { resolveTimestamps } from './timestamps.js';
 import { toCast, toPhpDocType, isHiddenByDefault } from './type-mapper.js';
 import { buildRelation } from './relation-builder.js';
-import { baseFile, userFile, resolveModularBasePath, resolveModularBaseNamespace, resolveSharedBaseNamespace, resolveGlobalTraitNamespace, resolveGlobalEnumNamespace, resolveBaseClass, resolveEditableClass, nestByGroup, nestEditableByGroup, } from './types.js';
+import { baseFile, userFile, shadowingPropertyConflicts, resolveModularBasePath, resolveModularBaseNamespace, resolveSharedBaseNamespace, resolveGlobalTraitNamespace, resolveGlobalEnumNamespace, resolveBaseClass, resolveEditableClass, nestByGroup, nestEditableByGroup, } from './types.js';
 import { enumClassName } from './enum-generator.js';
 /** Generate base model and user model for all project-owned object schemas,
  *  plus user models for package schemas (extending the package model). */
@@ -474,7 +474,11 @@ ${traits.join('\n')}
     //
 }
 `;
-    return userFile(`${editable.path}/${editable.fileName}`, content);
+    // #171: this subclass is created once and then owned by the project. The
+    // most common edit to it — redeclaring $fillable — silently disables every
+    // property omnify adds to the base afterwards. We cannot prevent the edit,
+    // but we can stop it from being invisible.
+    return userFile(`${editable.path}/${editable.fileName}`, content, undefined, shadowingPropertyConflicts(baseAlias));
 }
 function buildImports(baseNamespace, modelName, hasSoftDelete, isAuthenticatable, hasTranslatable, properties, needsUuidTrait = false, needsUlidTrait = false, hasNestedSet = false, nestedSetNamespace = 'Aimeos\\Nestedset', hasFiles = false, modelNamespace = '', localesNamespace = '', traitsNamespace = '', sharedModelsNamespace = '', config, hasAuditLog = false) {
     const lines = [];
@@ -608,25 +612,26 @@ function buildDocProperties(properties, expandedProperties, propertyOrder, reade
     return lines.length === 0 ? '' : lines.join('\n') + '\n';
 }
 function buildTraits(hasSoftDelete, isAuthenticatable, hasTranslatable, needsUuidTrait = false, needsUlidTrait = false, hasNestedSet = false, hasFiles = false, hasAuditLog = false) {
-    const lines = [];
-    lines.push('    use HasLocalizedDisplayName;');
+    const names = ['HasLocalizedDisplayName'];
     if (hasFiles)
-        lines.push('    use HasFiles;');
+        names.push('HasFiles');
     if (hasAuditLog)
-        lines.push('    use HasOmnifyAuditLog;');
+        names.push('HasOmnifyAuditLog');
     if (needsUuidTrait)
-        lines.push('    use HasUuids;');
+        names.push('HasUuids');
     if (needsUlidTrait)
-        lines.push('    use HasUlids;');
+        names.push('HasUlids');
     if (isAuthenticatable)
-        lines.push('    use Notifiable;');
+        names.push('Notifiable');
     if (hasNestedSet)
-        lines.push('    use NodeTrait;');
+        names.push('NodeTrait');
     if (hasSoftDelete)
-        lines.push('    use SoftDeletes;');
+        names.push('SoftDeletes');
     if (hasTranslatable)
-        lines.push('    use Translatable;');
-    return lines.join('\n') + '\n';
+        names.push('Translatable');
+    // #174: Pint's `ordered_traits` sorts them, so emit them sorted.
+    names.sort((a, b) => (a.toLowerCase() < b.toLowerCase() ? -1 : a.toLowerCase() > b.toLowerCase() ? 1 : 0));
+    return names.map((n) => `    use ${n};`).join('\n') + '\n';
 }
 function buildFillable(properties, expandedProperties, propertyOrder) {
     const fields = [];

package/ts-dist/php/php-style.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Formatting helpers that keep emitted PHP byte-stable under Laravel Pint.
+ *
+ * Issue #174: `omnify generate` wrote PHP that Pint immediately rewrote, so a
+ * version bump with no schema change produced hundreds of modified files that
+ * a formatter pass then reverted. Consumers running Pint paid review noise;
+ * consumers without it kept the churn forever. Codegen a formatter rewrites
+ * can never be verified byte-for-byte, so the generators emit Pint's own shape
+ * instead of relying on the post-generate Pint pass to fix it up.
+ */
+/**
+ * Collects `use` imports for the classes a Resource references, so the emitted
+ * file matches what Laravel Pint's `laravel` preset produces.
+ *
+ * Issue #174: the generator emitted inline `\App\Http\Resources\FooResource`,
+ * which Pint rewrites into an import plus the short name. Every consumer with
+ * Pint therefore saw the whole Resource layer change on `generate` and change
+ * back on `pint` — 315 files of churn per run on the reporting project — and
+ * every consumer WITHOUT Pint kept the churn permanently. Codegen a formatter
+ * immediately rewrites can never be verified byte-for-byte.
+ *
+ * Two cases keep the FQCN, because an import would be wrong rather than noisy:
+ *   - the short name is already taken by a different FQN (a genuine collision);
+ *   - the class lives in this file's own namespace, where PHP resolves the
+ *     short name without an import and Pint adds none.
+ */
+export declare function createClassImporter(currentNamespace: string, reserved?: string[]): {
+    /** Reference `fqn` the way Pint would: short name + import when possible. */
+    ref(fqn: string): string;
+    /** Every FQN to import, minus the reserved ones the template writes itself. */
+    list(): string[];
+};
+export type ClassImporter = ReturnType<typeof createClassImporter>;
+/**
+ * Render a `use` block in Pint's `ordered_imports` order. PHP-CS-Fixer's alpha
+ * algorithm compares with `\` replaced by a space, so a shorter namespace
+ * sorts before a longer one sharing its prefix.
+ */
+export declare function renderUseBlock(fqns: string[]): string;
+/**
+ * Rewrite a file's top-level `use` block the way Pint's `ordered_imports` and
+ * `no_unused_imports` would: drop imports nothing in the file references, then
+ * sort what is left.
+ *
+ * Applied to every generated PHP file rather than to each template, because
+ * every template that grew an import grew the same two violations (#174). Only
+ * `use` at column 0 is touched — a trait `use` inside a class body is indented,
+ * and grouped or function/const imports are left exactly as written.
+ */
+export declare function normalizeTopLevelUses(content: string): string;
+/**
+ * The blank-line half of Pint's `laravel` preset, applied to every generated
+ * PHP file (#174):
+ *
+ *   - `no_extra_blank_lines` — never two blank lines in a row, and none left
+ *     hanging before a closing brace;
+ *   - `class_attributes_separation` — one blank line between a class's trait
+ *     `use` group and the member that follows it.
+ *
+ * Templates composed from optional sections (a `$incrementing` block that is
+ * usually absent, a trait list that is sometimes empty) produce these by
+ * construction, which is why this is central rather than per template.
+ */
+export declare function normalizePhpBlankLines(content: string): string;
+/**
+ * The remaining whole-file rules from Pint's `laravel` preset that templates
+ * kept getting wrong (#174):
+ *
+ *   - `function_declaration` — an arrow function is `fn () =>`, not `fn() =>`;
+ *   - `blank_line_before_statement` — a `return` that follows a statement gets
+ *     a blank line before it.
+ */
+export declare function normalizePhpStatements(content: string): string;
+/**
+ * `not_operator_with_successor_space` — Laravel's preset writes `! $x`, not
+ * `!$x` (#174).
+ *
+ * Done with a scanner rather than a regex because the same character is
+ * ordinary text inside a string literal, and generated services embed SQL and
+ * message strings. Only code outside quotes is touched, and `!=` / `!==` are
+ * comparisons, not negations.
+ */
+export declare function normalizeNotOperator(content: string): string;

package/ts-dist/php/php-style.js

@@ -0,0 +1,251 @@
+/**
+ * Formatting helpers that keep emitted PHP byte-stable under Laravel Pint.
+ *
+ * Issue #174: `omnify generate` wrote PHP that Pint immediately rewrote, so a
+ * version bump with no schema change produced hundreds of modified files that
+ * a formatter pass then reverted. Consumers running Pint paid review noise;
+ * consumers without it kept the churn forever. Codegen a formatter rewrites
+ * can never be verified byte-for-byte, so the generators emit Pint's own shape
+ * instead of relying on the post-generate Pint pass to fix it up.
+ */
+/**
+ * Collects `use` imports for the classes a Resource references, so the emitted
+ * file matches what Laravel Pint's `laravel` preset produces.
+ *
+ * Issue #174: the generator emitted inline `\App\Http\Resources\FooResource`,
+ * which Pint rewrites into an import plus the short name. Every consumer with
+ * Pint therefore saw the whole Resource layer change on `generate` and change
+ * back on `pint` — 315 files of churn per run on the reporting project — and
+ * every consumer WITHOUT Pint kept the churn permanently. Codegen a formatter
+ * immediately rewrites can never be verified byte-for-byte.
+ *
+ * Two cases keep the FQCN, because an import would be wrong rather than noisy:
+ *   - the short name is already taken by a different FQN (a genuine collision);
+ *   - the class lives in this file's own namespace, where PHP resolves the
+ *     short name without an import and Pint adds none.
+ */
+export function createClassImporter(currentNamespace, reserved = []) {
+    // short name → FQN it is bound to. Seeded with the names the template always
+    // imports, so a schema called e.g. `Request` cannot shadow them.
+    const bound = new Map();
+    for (const fqn of reserved) {
+        bound.set(fqn.slice(fqn.lastIndexOf('\\') + 1), fqn);
+    }
+    const imported = new Set();
+    return {
+        /** Reference `fqn` the way Pint would: short name + import when possible. */
+        ref(fqn) {
+            const clean = fqn.replace(/^\\+/, '');
+            const shortName = clean.slice(clean.lastIndexOf('\\') + 1);
+            const ns = clean.slice(0, clean.lastIndexOf('\\'));
+            if (ns === currentNamespace)
+                return shortName;
+            const existing = bound.get(shortName);
+            if (existing && existing !== clean)
+                return `\\${clean}`;
+            if (!existing)
+                bound.set(shortName, clean);
+            imported.add(clean);
+            return shortName;
+        },
+        /** Every FQN to import, minus the reserved ones the template writes itself. */
+        list() {
+            return [...imported];
+        },
+    };
+}
+/**
+ * Render a `use` block in Pint's `ordered_imports` order. PHP-CS-Fixer's alpha
+ * algorithm compares with `\` replaced by a space, so a shorter namespace
+ * sorts before a longer one sharing its prefix.
+ */
+export function renderUseBlock(fqns) {
+    const sortKey = (fqn) => fqn.split(' as ')[0].replace(/\\/g, ' ').toLowerCase();
+    return [...new Set(fqns)]
+        .sort((a, b) => (sortKey(a) < sortKey(b) ? -1 : sortKey(a) > sortKey(b) ? 1 : 0))
+        .map((fqn) => `use ${fqn};`)
+        .join('\n');
+}
+/**
+ * Rewrite a file's top-level `use` block the way Pint's `ordered_imports` and
+ * `no_unused_imports` would: drop imports nothing in the file references, then
+ * sort what is left.
+ *
+ * Applied to every generated PHP file rather than to each template, because
+ * every template that grew an import grew the same two violations (#174). Only
+ * `use` at column 0 is touched — a trait `use` inside a class body is indented,
+ * and grouped or function/const imports are left exactly as written.
+ */
+export function normalizeTopLevelUses(content) {
+    const lines = content.split('\n');
+    const useIdx = [];
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (/^(class|trait|interface|enum|abstract|final|return)\b/.test(line))
+            break;
+        if (/^use\s+[A-Za-z_\\][^;]*;\s*$/.test(line) && !line.includes('{'))
+            useIdx.push(i);
+    }
+    if (useIdx.length === 0)
+        return content;
+    const first = useIdx[0];
+    const last = useIdx[useIdx.length - 1];
+    // Anything other than blank lines between the imports means this is not a
+    // single block (a comment splitting it, say); leave the file alone.
+    for (let i = first; i <= last; i++) {
+        if (!useIdx.includes(i) && lines[i].trim() !== '')
+            return content;
+    }
+    const body = [...lines.slice(0, first), ...lines.slice(last + 1)].join('\n');
+    const kept = useIdx
+        .map((i) => lines[i])
+        .filter((line) => {
+        const m = line.match(/^use\s+(?:function\s+|const\s+)?([^;]+);$/);
+        if (!m)
+            return true;
+        const spec = m[1].trim();
+        const alias = spec.includes(' as ')
+            ? spec.slice(spec.lastIndexOf(' as ') + 4).trim()
+            : spec.slice(spec.lastIndexOf('\\') + 1);
+        // A name used anywhere in the body — code, docblock or attribute — keeps
+        // its import, which is the same call `no_unused_imports` makes.
+        return new RegExp(`(?<![\\w\\\\])${alias}(?![\\w])`).test(body);
+    });
+    const sorted = renderUseBlock(kept.map((line) => line.replace(/^use\s+/, '').replace(/;$/, ''))).split('\n').filter((l) => l !== '');
+    return [...lines.slice(0, first), ...sorted, ...lines.slice(last + 1)].join('\n');
+}
+/**
+ * The blank-line half of Pint's `laravel` preset, applied to every generated
+ * PHP file (#174):
+ *
+ *   - `no_extra_blank_lines` — never two blank lines in a row, and none left
+ *     hanging before a closing brace;
+ *   - `class_attributes_separation` — one blank line between a class's trait
+ *     `use` group and the member that follows it.
+ *
+ * Templates composed from optional sections (a `$incrementing` block that is
+ * usually absent, a trait list that is sometimes empty) produce these by
+ * construction, which is why this is central rather than per template.
+ */
+export function normalizePhpBlankLines(content) {
+    const lines = content.split('\n');
+    const out = [];
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const isBlank = line.trim() === '';
+        if (isBlank) {
+            // Collapse a run of blank lines, and drop it entirely when the next
+            // real line closes a block.
+            if (out.length > 0 && out[out.length - 1].trim() === '')
+                continue;
+            let j = i;
+            while (j < lines.length && lines[j].trim() === '')
+                j++;
+            if (j < lines.length && lines[j].trim().startsWith('}'))
+                continue;
+        }
+        const prev = out[out.length - 1];
+        // A method's closing brace must be separated from the next member.
+        if (prev !== undefined
+            && /^ {4}\}$/.test(prev)
+            && !isBlank
+            && !line.trim().startsWith('}')) {
+            out.push('');
+        }
+        // A class's trait `use` group must be separated from what follows it.
+        const prevUse = out[out.length - 1];
+        if (prevUse !== undefined
+            && /^\s+use\s+[A-Za-z_\\][^;]*;\s*$/.test(prevUse)
+            && !isBlank
+            && !/^\s+use\s+[A-Za-z_\\][^;]*;\s*$/.test(line)
+            && !line.trim().startsWith('}')) {
+            out.push('');
+        }
+        out.push(line);
+    }
+    return out.join('\n');
+}
+/**
+ * The remaining whole-file rules from Pint's `laravel` preset that templates
+ * kept getting wrong (#174):
+ *
+ *   - `function_declaration` — an arrow function is `fn () =>`, not `fn() =>`;
+ *   - `blank_line_before_statement` — a `return` that follows a statement gets
+ *     a blank line before it.
+ */
+export function normalizePhpStatements(content) {
+    const spaced = content.replace(/(?<![\w$>\\])fn\(/g, 'fn (');
+    const lines = spaced.split('\n');
+    const out = [];
+    for (const line of lines) {
+        const prev = out[out.length - 1];
+        if (prev !== undefined
+            && /^\s*return\b/.test(line)
+            && prev.trim() !== ''
+            && !prev.trimEnd().endsWith('{')
+            && !/^\s*(\/\/|\/\*|\*)/.test(prev)) {
+            out.push('');
+        }
+        out.push(line);
+    }
+    return out.join('\n');
+}
+/**
+ * `not_operator_with_successor_space` — Laravel's preset writes `! $x`, not
+ * `!$x` (#174).
+ *
+ * Done with a scanner rather than a regex because the same character is
+ * ordinary text inside a string literal, and generated services embed SQL and
+ * message strings. Only code outside quotes is touched, and `!=` / `!==` are
+ * comparisons, not negations.
+ */
+export function normalizeNotOperator(content) {
+    let out = '';
+    let i = 0;
+    while (i < content.length) {
+        const ch = content[i];
+        const next = content[i + 1];
+        // Comments are prose: an apostrophe in "Laravel's" must not be read as a
+        // string opening, or everything after it goes untouched.
+        if (ch === '/' && next === '/') {
+            const end = content.indexOf('\n', i);
+            const stop = end === -1 ? content.length : end;
+            out += content.slice(i, stop);
+            i = stop;
+            continue;
+        }
+        if (ch === '/' && next === '*') {
+            const end = content.indexOf('*/', i + 2);
+            const stop = end === -1 ? content.length : end + 2;
+            out += content.slice(i, stop);
+            i = stop;
+            continue;
+        }
+        if (ch === "'" || ch === '"') {
+            const quote = ch;
+            let j = i + 1;
+            while (j < content.length) {
+                if (content[j] === '\\') {
+                    j += 2;
+                    continue;
+                }
+                if (content[j] === quote) {
+                    j++;
+                    break;
+                }
+                j++;
+            }
+            out += content.slice(i, j);
+            i = j;
+            continue;
+        }
+        if (ch === '!' && next !== '=' && next !== ' ') {
+            out += '! ';
+            i++;
+            continue;
+        }
+        out += ch;
+        i++;
+    }
+    return out;
+}

package/ts-dist/php/pint-format.js

@@ -65,7 +65,17 @@ export function runPintFormat(writtenPhpPaths) {
     if (writtenPhpPaths.length === 0) {
         return { ran: false, pintPath: null, formattedCount: 0, exitStatus: null };
     }
-    const pintPath = findPintBinary(writtenPhpPaths[0]);
+    // Opt-out (#174). The auto-run hides what the generators actually emit: a
+    // template that Pint rewrites looks fine here and produces churn in every
+    // project where Pint is absent or does not run. `OMNIFY_NO_PINT=1` is how
+    // the repo's own fixture check measures the raw output.
+    if (process.env.OMNIFY_NO_PINT === '1') {
+        return { ran: false, pintPath: null, formattedCount: 0, exitStatus: null };
+    }
+    // Resolution walks up from a written file. Trying only the first one makes
+    // it depend on emission order — a single file outside the Laravel root and
+    // the whole run goes unformatted, silently. Try each until one resolves.
+    const pintPath = writtenPhpPaths.reduce((found, path) => found ?? findPintBinary(path), null);
     if (!pintPath) {
         return { ran: false, pintPath: null, formattedCount: 0, exitStatus: null };
     }

package/ts-dist/php/resource-generator.js

@@ -5,6 +5,7 @@ import { toPascalCase, toSnakeCase, toCamelCase, toFkColumnName } from './naming
 import { resolveTimestamps } from './timestamps.js';
 import { isHiddenByDefault, toResourceExpression } from './type-mapper.js';
 import { baseFile, userFile, resolveModularBasePath, resolveModularBaseNamespace, resolveBaseClass, resolveEditableClass, nestByGroup, nestEditableByGroup } from './types.js';
+import { createClassImporter, renderUseBlock } from './php-style.js';
 /** Generate Resource classes for all project-owned visible object schemas.
  *
  * Issue #101 v5.8.23 emitted ONLY the base — but child resources embed a
@@ -72,6 +73,12 @@ function generateBaseResource(name, schema, reader, config) {
     const hasSoftDelete = options.softDelete ?? false;
     const hasId = options.id ?? true;
     const fields = [];
+    // #174: reference other Resources by short name + `use` import, the way Pint
+    // would rewrite them, so `generate` and the formatter stop disagreeing.
+    const importer = createClassImporter(baseNamespace, [
+        'Illuminate\\Http\\Request',
+        'Illuminate\\Http\\Resources\\Json\\JsonResource',
+    ]);
     if (hasId) {
         fields.push("            'id' => $this->id,");
     }
@@ -84,7 +91,7 @@ function generateBaseResource(name, schema, reader, config) {
         if (isHiddenByDefault(type) || hidden)
             continue;
         if (type === 'Association') {
-            addAssociationFields(propName, prop, fields, resourceNamespace, modelNamespace, reader, config);
+            addAssociationFields(propName, prop, fields, resourceNamespace, modelNamespace, reader, config, importer);
             continue;
         }
         if (expandedProperties[propName]) {
@@ -129,6 +136,11 @@ function generateBaseResource(name, schema, reader, config) {
         fields.push("            'deleted_at' => $this->deleted_at?->toISOString(),");
     }
     const fieldsContent = fields.join('\n');
+    const useBlock = renderUseBlock([
+        'Illuminate\\Http\\Request',
+        'Illuminate\\Http\\Resources\\Json\\JsonResource',
+        ...importer.list(),
+    ]);
     const content = `<?php
 
 namespace ${baseNamespace};
@@ -140,8 +152,7 @@ namespace ${baseNamespace};
  * @generated by omnify
  */
 
-use Illuminate\\Http\\Request;
-use Illuminate\\Http\\Resources\\Json\\JsonResource;
+${useBlock}
 
 class ${modelName}ResourceBase extends JsonResource
 {
@@ -236,7 +247,7 @@ class ${editable.className} extends ${baseAlias}
 `;
     return userFile(`${editable.path}/${editable.fileName}`, content);
 }
-function addAssociationFields(propName, prop, fields, resourceNamespace, modelNamespace, reader, config) {
+function addAssociationFields(propName, prop, fields, resourceNamespace, modelNamespace, reader, config, importer) {
     const relation = prop['relation'] ?? '';
     const target = prop['target'] ?? '';
     const methodName = toCamelCase(propName);
@@ -299,17 +310,17 @@ function addAssociationFields(propName, prop, fields, resourceNamespace, modelNa
         case 'ManyToOne': {
             const snakeName = toFkColumnName(propName);
             fields.push(`            '${snakeName}' => $this->${snakeName},`);
-            fields.push(`            '${methodName}' => $this->whenLoaded('${methodName}', fn() => new \\${targetResNs}\\${targetResource}($this->${methodName})),`);
+            fields.push(`            '${methodName}' => $this->whenLoaded('${methodName}', fn () => new ${importer.ref(`${targetResNs}\\${targetResource}`)}($this->${methodName})),`);
             break;
         }
         case 'OneToMany':
         case 'ManyToMany':
         case 'MorphMany':
-            fields.push(`            '${methodName}' => $this->whenLoaded('${methodName}', fn() => \\${targetResNs}\\${targetResource}::collection($this->${methodName})),`);
+            fields.push(`            '${methodName}' => $this->whenLoaded('${methodName}', fn () => ${importer.ref(`${targetResNs}\\${targetResource}`)}::collection($this->${methodName})),`);
             break;
         case 'OneToOne':
         case 'MorphOne':
-            fields.push(`            '${methodName}' => $this->whenLoaded('${methodName}', fn() => new \\${targetResNs}\\${targetResource}($this->${methodName})),`);
+            fields.push(`            '${methodName}' => $this->whenLoaded('${methodName}', fn () => new ${importer.ref(`${targetResNs}\\${targetResource}`)}($this->${methodName})),`);
             break;
         case 'MorphTo':
             fields.push(`            '${methodName}' => $this->whenLoaded('${methodName}'),`);

package/ts-dist/php/service-generator.js

@@ -1257,14 +1257,14 @@ function buildSortSection(_sortableFields, defaultSort, allowedSortColumns, tx)
             $query
                 ->leftJoin('${trTable} as tr_sort', function ($j) use ($locale) {
                     $j->on('tr_sort.${fk}', '=', '${mainTable}.id')
-                      ->where('tr_sort.locale', $locale);
+                        ->where('tr_sort.locale', $locale);
                 })
                 ->leftJoin('${trTable} as tr_sort_fb', function ($j) use ($fallback) {
                     $j->on('tr_sort_fb.${fk}', '=', '${mainTable}.id')
-                      ->where('tr_sort_fb.locale', $fallback);
+                        ->where('tr_sort_fb.locale', $fallback);
                 })
                 ->select('${mainTable}.*')
-                ->orderByRaw("COALESCE(tr_sort.\`{$column}\`, tr_sort_fb.\`{$column}\`) " . strtoupper($direction));
+                ->orderByRaw("COALESCE(tr_sort.\`{$column}\`, tr_sort_fb.\`{$column}\`) ".strtoupper($direction));
         } else {
             $query->orderBy($column, $direction);
         }`;
@@ -1314,7 +1314,6 @@ function buildFindByIdMethod(modelName, eagerLoad, eagerCount, hasSoftDelete) {
      *
      * @example Fetch an active ${modelName}
      *   $model = $service->findById('01h000000000000000000000000');
-     *
      * @example Resolve a trashed ${modelName} for restore() / forceDelete()
      *   $trashed = $service->findById('01h000000000000000000000000', withTrashed: true);
      *   $service->restore($trashed);
@@ -1713,11 +1712,11 @@ ${lookupExample}
             ])
             ->leftJoin('${trTable} as tr_current', function ($j) use ($locale) {
                 $j->on('tr_current.${fk}', '=', '${mainTable}.id')
-                  ->where('tr_current.locale', $locale);
+                    ->where('tr_current.locale', $locale);
             })
             ->leftJoin('${trTable} as tr_fallback', function ($j) use ($fallback) {
                 $j->on('tr_fallback.${fk}', '=', '${mainTable}.id')
-                  ->where('tr_fallback.locale', $fallback);
+                    ->where('tr_fallback.locale', $fallback);
             })
             ${orderByLine};
 

package/ts-dist/php/trait-generator.js

@@ -26,8 +26,7 @@ trait HasLocalizedDisplayName
     /**
      * Get the localized display name for this model.
      *
-     * @param string|null $locale Locale code (defaults to app locale)
-     * @return string
+     * @param  string|null  $locale  Locale code (defaults to app locale)
      */
     public static function displayName(?string $locale = null): string
     {
@@ -53,9 +52,8 @@ trait HasLocalizedDisplayName
     /**
      * Get the localized display name for a property.
      *
-     * @param string $property Property name
-     * @param string|null $locale Locale code (defaults to app locale)
-     * @return string
+     * @param  string  $property  Property name
+     * @param  string|null  $locale  Locale code (defaults to app locale)
      */
     public static function propertyDisplayName(string $property, ?string $locale = null): string
     {
@@ -71,7 +69,7 @@ trait HasLocalizedDisplayName
     /**
      * Get all localized display names for a property.
      *
-     * @param string $property Property name
+     * @param  string  $property  Property name
      * @return array<string, string>
      */
     public static function allPropertyDisplayNames(string $property): array
@@ -82,7 +80,7 @@ trait HasLocalizedDisplayName
     /**
      * Get all property display names for a given locale.
      *
-     * @param string|null $locale Locale code (defaults to app locale)
+     * @param  string|null  $locale  Locale code (defaults to app locale)
      * @return array<string, string>
      */
     public static function allPropertyDisplayNamesForLocale(?string $locale = null): array

package/ts-dist/php/types.d.ts

@@ -21,6 +21,23 @@ export interface GeneratedFile {
         readonly needle: string;
         readonly hint: string;
     };
+    /**
+     * For a user file only: things the file must NOT contain, and why.
+     *
+     * The mirror of `expects`. Some edits to a user-editable subclass silently
+     * disable what the base class generates — the worst being a redeclared
+     * `protected $fillable`, which in PHP REPLACES the parent's rather than
+     * merging, so every property added to the schema afterwards is stripped by
+     * Eloquent on mass assignment. Nothing throws; `save()` returns true and the
+     * column stays NULL (issue #171).
+     *
+     * Each entry is matched against the content of the file we skipped, and
+     * `hint` is printed when it matches.
+     */
+    readonly conflicts?: readonly {
+        readonly pattern: string;
+        readonly hint: string;
+    }[];
 }
 /** Create a base file (always overwritten). */
 export declare function baseFile(path: string, content: string): GeneratedFile;
@@ -28,7 +45,28 @@ export declare function baseFile(path: string, content: string): GeneratedFile;
 export declare function userFile(path: string, content: string, expects?: {
     needle: string;
     hint: string;
-}): GeneratedFile;
+}, conflicts?: readonly {
+    pattern: string;
+    hint: string;
+}[]): GeneratedFile;
+/**
+ * Eloquent array properties that REPLACE the parent's when redeclared in a
+ * subclass, rather than merging. Redeclaring any of these in a user-editable
+ * model shadows whatever the generated base puts there, and the failure is
+ * completely silent. Issue #171.
+ */
+export declare const SHADOWING_ELOQUENT_PROPERTIES: readonly ["fillable", "guarded", "casts", "hidden", "visible", "appends", "dates", "touches", "with"];
+/**
+ * Build the `conflicts` entries for a generated model's editable subclass.
+ *
+ * `baseClass` is named in the hint because the whole point is that the base is
+ * still correct — the generator did emit the property — and the reader needs to
+ * know which file they are shadowing.
+ */
+export declare function shadowingPropertyConflicts(baseClass: string): {
+    pattern: string;
+    hint: string;
+}[];
 /** Category of base file for modular path resolution. */
 export type BaseCategory = 'Models' | 'Controllers' | 'Requests' | 'Resources' | 'Services' | 'Enums' | 'Traits' | 'Locales' | 'Policies';
 /**
@@ -418,3 +456,15 @@ export declare function nestEditableByGroup(layer: BaseEditableLayer, loc: {
  * All paths and namespaces fall back to sensible defaults.
  */
 export declare function derivePhpConfig(overrides?: LaravelCodegenOverrides): PhpConfig;
+/**
+ * Strip PHP comments so a commented-out declaration does not read as a real
+ * one. Without this, the very common
+ *
+ *     // protected $fillable = ['name'];   // left from a refactor
+ *
+ * would be reported as shadowing the base — and a warning that fires on code
+ * that is not running is worse than no warning, because people learn to ignore
+ * it. Naive on purpose: it can strip a `//` inside a string literal, which only
+ * ever costs us a warning we would otherwise have printed, never a false one.
+ */
+export declare function stripPhpComments(source: string): string;

package/ts-dist/php/types.js

@@ -6,8 +6,53 @@ export function baseFile(path, content) {
     return { path, content, overwrite: true, type: 'base' };
 }
 /** Create a user file (created once, skip if exists). */
-export function userFile(path, content, expects) {
-    return { path, content, overwrite: false, type: 'user', ...(expects ? { expects } : {}) };
+export function userFile(path, content, expects, conflicts) {
+    return {
+        path,
+        content,
+        overwrite: false,
+        type: 'user',
+        ...(expects ? { expects } : {}),
+        ...(conflicts && conflicts.length > 0 ? { conflicts } : {}),
+    };
+}
+/**
+ * Eloquent array properties that REPLACE the parent's when redeclared in a
+ * subclass, rather than merging. Redeclaring any of these in a user-editable
+ * model shadows whatever the generated base puts there, and the failure is
+ * completely silent. Issue #171.
+ */
+export const SHADOWING_ELOQUENT_PROPERTIES = [
+    'fillable',
+    'guarded',
+    'casts',
+    'hidden',
+    'visible',
+    'appends',
+    'dates',
+    'touches',
+    'with',
+];
+/**
+ * Build the `conflicts` entries for a generated model's editable subclass.
+ *
+ * `baseClass` is named in the hint because the whole point is that the base is
+ * still correct — the generator did emit the property — and the reader needs to
+ * know which file they are shadowing.
+ */
+export function shadowingPropertyConflicts(baseClass) {
+    return SHADOWING_ELOQUENT_PROPERTIES.map((prop) => ({
+        // Matches `protected $fillable`, `public array $casts`, `protected static
+        // $with` — any redeclaration, whatever the visibility or type hint.
+        pattern: String.raw `(?:public|protected|private)\s+(?:static\s+)?(?:array\s+)?\$` + prop + String.raw `\s*=`,
+        hint: `redeclares $${prop}, which REPLACES ` +
+            `${baseClass}::$${prop} rather than merging with it (PHP does not merge ` +
+            `redeclared properties). Anything omnify adds to $${prop} from now on is ` +
+            `silently dropped: mass assignment strips it, save() still returns true, ` +
+            `and the column stays NULL. Fix: delete the redeclaration and let the base ` +
+            `provide it, or build it from the parent, e.g. ` +
+            `__construct() { $this->${prop} = array_merge(parent::$${prop} ?? [], [...]); }`,
+    }));
 }
 /**
  * Resolve base file path for a schema based on structure.
@@ -382,3 +427,20 @@ export function derivePhpConfig(overrides) {
         },
     };
 }
+/**
+ * Strip PHP comments so a commented-out declaration does not read as a real
+ * one. Without this, the very common
+ *
+ *     // protected $fillable = ['name'];   // left from a refactor
+ *
+ * would be reported as shadowing the base — and a warning that fires on code
+ * that is not running is worse than no warning, because people learn to ignore
+ * it. Naive on purpose: it can strip a `//` inside a string literal, which only
+ * ever costs us a warning we would otherwise have printed, never a false one.
+ */
+export function stripPhpComments(source) {
+    return source
+        .replace(/\/\*[\s\S]*?\*\//g, '')
+        .replace(/(^|\s)\/\/[^\n]*/g, '$1')
+        .replace(/(^|\s)#[^\n]*/g, '$1');
+}