@omnifyjp/ts 7.0.2 → 7.0.3

package/dist/php/faker-mapper.js

@@ -18,8 +18,8 @@ export function toFaker(propName, property, schemas = {}) {
         case 'Int':
         case 'BigInt': return intFaker(snakeName, property);
         case 'TinyInt': return `'${snakeName}' => fake()->numberBetween(0, 127),`;
-        case 'Float':
-        case 'Decimal': return `'${snakeName}' => fake()->randomFloat(2, 1, 10000),`;
+        case 'Float': return `'${snakeName}' => fake()->randomFloat(2, 1, 10000),`;
+        case 'Decimal': return decimalFaker(snakeName, property);
         case 'Boolean': return `'${snakeName}' => fake()->boolean(),`;
         case 'Text': return `'${snakeName}' => fake()->paragraphs(3, true),`;
         case 'MediumText': return `'${snakeName}' => fake()->paragraphs(3, true),`;
@@ -82,43 +82,81 @@ export function associationFaker(propName, property, modelNamespace, currentSche
     return { fake, import: importLine };
 }
 function stringFaker(propName, snakeName, property) {
+    const expr = stringFakerExpr(propName, snakeName, property);
+    const length = property['length'];
+    // Clamp to the column's actual length regardless of which branch above
+    // picked the generator: a wrong/over-eager name heuristic (or a caller
+    // constraining `length` below what the heuristic normally produces) must
+    // stay inside the column instead of overflowing it — an SQL 1406 on
+    // MySQL/MariaDB weeks after the schema shipped (sqlite enforces no such
+    // limit, so this was invisible locally). Applied uniformly to every
+    // generator here rather than cherry-picked per branch (#264).
+    const value = length != null ? `mb_substr(${expr}, 0, ${length})` : expr;
+    return `'${snakeName}' => ${value},`;
+}
+function stringFakerExpr(propName, snakeName, property) {
     const lower = propName.toLowerCase();
+    // Name-heuristic tokens, split on the already-normalized snake_case column
+    // name so a single word boundary decides a match — `shipAddress` must not
+    // trip the bare `ip` check meant for `ipAddress` (#264: more-specific
+    // patterns must win, deterministically, not by accidental substring order).
+    const tokens = snakeName.split('_');
     if (propName === 'slug')
-        return `'${snakeName}' => fake()->unique()->slug(2),`;
+        return `fake()->unique()->slug(2)`;
     if (propName === 'uuid' || propName === 'uid')
-        return `'${snakeName}' => (string) \\Illuminate\\Support\\Str::uuid(),`;
+        return `(string) \\Illuminate\\Support\\Str::uuid()`;
+    if (tokens.includes('ip'))
+        return `fake()->ipv4()`;
     if (lower.includes('email'))
-        return `'${snakeName}' => fake()->unique()->safeEmail(),`;
+        return `fake()->unique()->safeEmail()`;
     if (lower.includes('phone'))
-        return `'${snakeName}' => fake()->phoneNumber(),`;
+        return `fake()->phoneNumber()`;
     if (lower.includes('image') || lower.includes('photo') || lower.includes('avatar'))
-        return `'${snakeName}' => fake()->imageUrl(),`;
+        return `fake()->imageUrl()`;
     if (lower.includes('url') || lower.includes('website'))
-        return `'${snakeName}' => fake()->url(),`;
+        return `fake()->url()`;
     if (lower.includes('path') || lower.includes('file'))
-        return `'${snakeName}' => 'uploads/'.fake()->uuid().'.jpg',`;
+        return `'uploads/'.fake()->uuid().'.jpg'`;
     if (propName === 'name' || propName === 'title')
-        return `'${snakeName}' => fake()->sentence(3),`;
+        return `fake()->sentence(3)`;
     if (lower.includes('name'))
-        return `'${snakeName}' => fake()->name(),`;
+        return `fake()->name()`;
     if (lower.includes('address'))
-        return `'${snakeName}' => fake()->address(),`;
+        return `fake()->address()`;
     if (lower.includes('city'))
-        return `'${snakeName}' => fake()->city(),`;
+        return `fake()->city()`;
     if (lower.includes('country'))
-        return `'${snakeName}' => fake()->country(),`;
+        return `fake()->country()`;
     if (lower.includes('zip') || lower.includes('postal'))
-        return `'${snakeName}' => fake()->postcode(),`;
+        return `fake()->postcode()`;
     if (lower.includes('color'))
-        return `'${snakeName}' => fake()->hexColor(),`;
+        return `fake()->hexColor()`;
     if (lower.includes('token') || lower.includes('secret') || lower.includes('key'))
-        return `'${snakeName}' => \\Illuminate\\Support\\Str::random(32),`;
+        return `\\Illuminate\\Support\\Str::random(32)`;
     if (lower.includes('code'))
-        return `'${snakeName}' => fake()->unique()->regexify('[A-Z0-9]{8}'),`;
+        return `fake()->unique()->regexify('[A-Z0-9]{8}')`;
     const length = property['length'];
     if (length != null && length <= 50)
-        return `'${snakeName}' => fake()->words(3, true),`;
-    return `'${snakeName}' => fake()->sentence(),`;
+        return `fake()->words(3, true)`;
+    return `fake()->sentence()`;
+}
+/** Largest value a `Decimal(precision, scale)` column accepts (all-9s at that precision/scale). */
+function decimalMax(precision, scale) {
+    const digits = '9'.repeat(Math.max(precision, 1));
+    if (scale <= 0)
+        return digits;
+    const intPart = digits.slice(0, digits.length - scale) || '0';
+    const fracPart = digits.slice(digits.length - scale);
+    return `${intPart}.${fracPart}`;
+}
+function decimalFaker(snakeName, property) {
+    // Laravel's default Decimal migration is `decimal(8, 2)` (blueprint.go),
+    // matched here so an unspecified precision/scale keeps generating the same
+    // range as before.
+    const precision = property['precision'] ?? 8;
+    const scale = property['scale'] ?? 2;
+    const max = decimalMax(precision, scale);
+    return `'${snakeName}' => fake()->randomFloat(${scale}, 0, ${max}),`;
 }
 function intFaker(snakeName, property) {
     const isUnique = property['unique'] ?? false;

package/dist/php/orphan-cleanup.js

@@ -19,7 +19,8 @@
  * warning is printed so the user can decide whether to clean up by hand.
  */
 import { existsSync, readFileSync, readdirSync, statSync, unlinkSync } from 'node:fs';
-import { join, resolve, basename } from 'node:path';
+import { join, relative, resolve, basename } from 'node:path';
+import { resolveModularBaseNamespace } from './types.js';
 /** Matches the header emitted by `generateEditableService` in service-generator.ts */
 export const OMNIFY_EDITABLE_SERVICE_MARKER = 'SAFE TO EDIT - This file is never overwritten by Omnify.';
 const EXTENDS_SERVICE_BASE_RE = /extends\s+[\w\\]+ServiceBase\b/;
@@ -60,34 +61,83 @@ function collectModularLayerDirs(configDir, config, category) {
     for (const entry of readdirSync(modulesAbs)) {
         const layerDir = join(modulesAbs, entry, category);
         if (existsSync(layerDir) && statSync(layerDir).isDirectory()) {
-            dirs.push(layerDir);
+            dirs.push({
+                dir: layerDir,
+                namespace: resolveModularBaseNamespace(config, entry, category, ''),
+            });
         }
     }
     return dirs;
 }
+/**
+ * FQCN a base file claims from its LOCATION: the layer root's namespace,
+ * one segment per group subdirectory, then the class name from the file
+ * name (`Base/Crm/FooRequestBase.php` under `App\...\Base` →
+ * `App\...\Base\Crm\FooRequestBase`). Derived relative to the layer
+ * root, never from the bare basename — a grouped file's group segment
+ * is part of its identity, and it is also what hand-written `use`
+ * imports name (#263).
+ */
+function fqcnFromLayerRelativePath(rootNamespace, relPath) {
+    const segments = relPath.split(/[\\/]/).filter((s) => s.length > 0);
+    const fileName = segments.pop();
+    if (!fileName)
+        return rootNamespace;
+    return [rootNamespace, ...segments, fileName.replace(/\.php$/i, '')]
+        .filter((s) => s.length > 0)
+        .join('\\');
+}
+/**
+ * Recursively visit every file under `root`. Directories are entered
+ * but never removed — the surrounding cleanup (pruneOrphanServiceFiles,
+ * walkPhpFiles) deletes files only and leaves emptied folders behind,
+ * and this prune matches that behaviour.
+ */
+function walkLayerFiles(root, visit) {
+    if (!existsSync(root))
+        return;
+    let entries;
+    try {
+        entries = readdirSync(root);
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        const full = join(root, entry);
+        let info;
+        try {
+            info = statSync(full);
+        }
+        catch {
+            continue;
+        }
+        if (info.isDirectory()) {
+            walkLayerFiles(full, visit);
+        }
+        else {
+            visit(full);
+        }
+    }
+}
 function pruneDisabledLayerBasesInRoots(spec, roots, expectedAbs, referenced) {
     let pruned = 0;
     let kept = 0;
+    // Grouped schemas nest their bases one directory per group
+    // (`app/Omnify/Requests/OmnifyBase/Crm/FooRequestBase.php`), so the
+    // walk must recurse — a one-level `readdirSync` leaves every grouped
+    // stale base on disk (#263).
     for (const root of roots) {
-        if (!existsSync(root))
-            continue;
-        for (const entry of readdirSync(root)) {
-            if (!spec.matchesBaseFile(entry))
-                continue;
-            const fullPath = join(root, entry);
+        walkLayerFiles(root.dir, (fullPath) => {
+            const name = basename(fullPath);
+            if (!spec.matchesBaseFile(name))
+                return;
             if (expectedAbs.has(fullPath))
-                continue;
-            let content = '';
-            try {
-                content = readFileSync(fullPath, 'utf-8');
-            }
-            catch {
-                continue;
-            }
-            const fqcn = declaredClassName(content);
-            if (fqcn && referenced.has(fqcn)) {
+                return;
+            const fqcn = fqcnFromLayerRelativePath(root.namespace, relative(root.dir, fullPath));
+            if (referenced.has(fqcn)) {
                 kept += 1;
-                continue;
+                return;
             }
             try {
                 unlinkSync(fullPath);
@@ -96,7 +146,7 @@ function pruneDisabledLayerBasesInRoots(spec, roots, expectedAbs, referenced) {
             catch {
                 // skip uncleanable files
             }
-        }
+        });
     }
     return { pruned, kept };
 }
@@ -115,7 +165,7 @@ export function pruneDisabledScaffoldLayerBases(configDir, config, generated, re
             continue;
         const roots = [
             ...collectModularLayerDirs(configDir, config, spec.modularCategory),
-            resolve(configDir, spec.legacyBasePath),
+            { dir: resolve(configDir, spec.legacyBasePath), namespace: spec.layerConfig.baseNamespace },
         ];
         const { pruned, kept } = pruneDisabledLayerBasesInRoots(spec, roots, expectedAbs, referenced);
         if (pruned > 0 || kept > 0) {

package/dist/php/request-generator.js

@@ -3,7 +3,32 @@
  */
 import { toPascalCase, toSnakeCase, toCamelCase, toFkColumnName } from './naming-helper.js';
 import { toStoreRules, toUpdateRules, formatRules, resolveFkRuleType } from './type-mapper.js';
-import { baseFile, userFile, resolveModularBasePath, resolveModularBaseNamespace, resolveBaseClass, resolveEditableClass, nestByGroup, nestEditableByGroup } from './types.js';
+import { baseFile, userFile, resolveModularBasePath, resolveModularBaseNamespace, resolveBaseClass, resolveEditableClass, nestByGroup, nestEditableByGroup, resolveGlobalEnumNamespace } from './types.js';
+import { enumClassName } from './enum-generator.js';
+/**
+ * Format rules for an EnumRef property, replacing the generic `'string'` rule
+ * `toStoreRules`/`toUpdateRules` emit for EnumRef with `Rule::enum(<Class>::class)`
+ * — bare `'string'` lets any value through validation while the model cast
+ * and migration column both enforce the enum's set (#265). Duplicates just
+ * enough of `formatRules`' string/rule_unique_ignore branches, since the
+ * `Rule::enum(...)` case can't be added to type-mapper.ts's `Rule` union from
+ * here without editing a file this job does not own.
+ */
+function formatEnumRefRules(rules, enumFqcn) {
+    const parts = [];
+    for (const rule of rules) {
+        if (rule === 'string') {
+            parts.push(`Rule::enum(${enumFqcn}::class)`);
+        }
+        else if (typeof rule === 'string') {
+            parts.push(`'${rule}'`);
+        }
+        else if (Array.isArray(rule) && rule[0] === 'rule_unique_ignore') {
+            parts.push(`Rule::unique('${rule[1]}')->ignore($this->route('${rule[2]}'))`);
+        }
+    }
+    return `[${parts.join(', ')}]`;
+}
 /** Generate Store/Update request classes for all project-owned visible object schemas. */
 export function generateRequests(reader, config) {
     if (!config.requests.enabled)
@@ -142,7 +167,21 @@ function generateBaseRequest(name, schema, reader, config, action) {
         const rules = isUpdate
             ? toUpdateRules(prop, tableName, modelRouteParam)
             : toStoreRules(prop, tableName);
-        rulesLines.push(`            '${snakeName}' => ${formatRules(rules)},`);
+        // EnumRef: validate against the enum's actual value set via Rule::enum()
+        // instead of the bare 'string' toStoreRules/toUpdateRules emit for it —
+        // otherwise an out-of-set string passes validation, hits the DB, and only
+        // explodes later when the model cast reads it back (#265). Use the exact
+        // FQCN the model cast/doc-block already use (model-generator.ts's
+        // buildCasts), so validation and the cast never disagree. Falls back to
+        // the plain rules when the referenced enum schema doesn't exist, matching
+        // toStoreRules' own fallback for that case.
+        const enumName = type === 'EnumRef' ? prop['enum'] : undefined;
+        const enumSchema = typeof enumName === 'string' ? reader.getSchema(enumName) : undefined;
+        const globalEnumNs = type === 'EnumRef' ? resolveGlobalEnumNamespace(config, config.models.namespace) : '';
+        const formattedRules = typeof enumName === 'string' && enumSchema?.kind === 'enum' && globalEnumNs
+            ? formatEnumRefRules(rules, `\\${globalEnumNs}\\${enumClassName(enumName)}`)
+            : formatRules(rules);
+        rulesLines.push(`            '${snakeName}' => ${formattedRules},`);
         attributeKeys.push(snakeName);
         // Translatable: add locale-nested rules (Astrotomic expects {locale}.{field})
         const isTranslatable = prop['translatable'] ?? false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@omnifyjp/ts",
-  "version": "7.0.2",
+  "version": "7.0.3",
   "description": "TypeScript model type generator from Omnify schemas.json",
   "type": "module",
   "main": "dist/index.js",