@omnifyjp/ts 6.7.4 → 6.7.6

package/dist/cli.js

@@ -33,6 +33,7 @@ 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';
+import { runPrettierFormat } from './prettier-format.js';
 import { resolveInput, sniffInputKind } from './input-resolver.js';
 function resolveFromConfig(configPath) {
     const raw = readFileSync(configPath, 'utf-8');
@@ -194,6 +195,7 @@ program
         let tsCreated = 0;
         let tsOverwritten = 0;
         let tsSkipped = 0;
+        const tsWrittenPaths = [];
         for (const file of files) {
             let filePath;
             if (file.category === 'enum' || file.category === 'plugin-enum') {
@@ -208,6 +210,7 @@ program
                 continue;
             }
             writeFileSync(filePath, file.content, 'utf-8');
+            tsWrittenPaths.push(filePath);
             if (file.overwrite || !existsSync(filePath)) {
                 tsOverwritten++;
             }
@@ -220,6 +223,22 @@ program
             console.log(`  ${tsCreated} files created (user-editable)`);
         if (tsSkipped > 0)
             console.log(`  ${tsSkipped} files skipped (already exist)`);
+        // Issue #211: format via the consumer project's Prettier (same idea as Pint for PHP).
+        if (tsWrittenPaths.length > 0) {
+            const prettierResult = runPrettierFormat(tsWrittenPaths);
+            if (prettierResult.ran) {
+                if (prettierResult.exitStatus === 0) {
+                    console.log(`  Formatted ${prettierResult.formattedCount} TS file(s) via Prettier`);
+                }
+                else {
+                    console.warn(`  [omnify] Prettier exited with status ${prettierResult.exitStatus}; generated files may not match project formatting preset.`);
+                    if (prettierResult.errorMessage) {
+                        const trimmed = prettierResult.errorMessage.trim().split('\n').slice(0, 5).join('\n');
+                        console.warn(`  ${trimmed}`);
+                    }
+                }
+            }
+        }
     }
     else {
         console.log(`\n[TypeScript] Skipped (disabled)`);
@@ -366,11 +385,14 @@ program
                 console.log(`    pruned: ${p}`);
             }
         }
-        for (const p of cleanup.warnedEditables) {
-            console.warn(`[omnify-ts] orphan editable service ${p} — backing schema is no ` +
+        if (cleanup.warnedEditables.length > 0) {
+            console.warn(`[omnify-ts] ${cleanup.warnedEditables.length} orphan editable service(s) — backing schema is no ` +
                 `longer eligible for service codegen (removed / renamed / opted out / ` +
                 `flipped to non-object kind). Safe to delete by hand if it has no ` +
                 `custom code inside; preserved for now to protect any hand-edits.`);
+            for (const p of cleanup.warnedEditables) {
+                console.warn(`  orphan editable service: ${p}`);
+            }
         }
     }
     console.log(`\nGeneration complete.`);

package/dist/enum-generator.js

@@ -4,6 +4,7 @@
  * Generates TypeScript enums with helper methods from schema enum definitions,
  * plugin enums (customTypes.enums), and inline property enums.
  */
+import { formatTsObjectKey, tsObjectLiteral } from './ts-literal.js';
 /** Convert a string to PascalCase. */
 export function toPascalCase(value) {
     const normalized = value.replace(/([a-z])([A-Z])/g, '$1_$2');
@@ -154,7 +155,7 @@ export function formatEnum(enumDef, style = 'enum') {
                 .map(v => {
                 if (isMultiLocaleLabel(v.label)) {
                     const locales = Object.entries(v.label)
-                        .map(([locale, text]) => `'${locale}': '${escapeString(text)}'`)
+                        .map(([locale, text]) => `${formatTsObjectKey(locale)}: '${escapeString(text)}'`)
                         .join(', ');
                     return `  [${name}.${v.name}]: { ${locales} },`;
                 }
@@ -193,7 +194,7 @@ export function formatEnum(enumDef, style = 'enum') {
     if (hasExtra) {
         const extraEntries = values
             .filter(v => v.extra !== undefined)
-            .map(v => `  [${name}.${v.name}]: ${JSON.stringify(v.extra)},`)
+            .map(v => `  [${name}.${v.name}]: ${tsObjectLiteral(v.extra, 2)},`)
             .join('\n');
         parts.push(`const ${lowerFirst(name)}Extra: Partial<Record<${name}, Record<string, unknown>>> = {\n${extraEntries}\n};\n\n`);
         parts.push(`/** Get extra metadata for ${name} value */\n`);

package/dist/metadata-generator.js

@@ -14,6 +14,7 @@
  * interface, zod schemas, and i18n object — none of those are modified.
  */
 import { toSnakeCase, toFkColumnName } from './interface-generator.js';
+import { formatTsObjectKey, tsObjectLiteral } from './ts-literal.js';
 // ---------------------------------------------------------------------------
 // Type classification — single source of truth so #55 (payload builder)
 // can reuse the same field-type decisions.
@@ -240,41 +241,6 @@ export function buildSchemaMetadata(schema, allSchemas, options, displayNames) {
 // ---------------------------------------------------------------------------
 // Formatter — turns the IR into a TypeScript const literal.
 // ---------------------------------------------------------------------------
-function jsLiteral(value, indent = 0) {
-    if (value === null)
-        return 'null';
-    if (value === undefined)
-        return 'undefined';
-    if (typeof value === 'string')
-        return JSON.stringify(value);
-    if (typeof value === 'number' || typeof value === 'boolean')
-        return String(value);
-    if (Array.isArray(value)) {
-        if (value.length === 0)
-            return '[]';
-        const inner = value.map((v) => jsLiteral(v, indent + 2)).join(', ');
-        return `[${inner}]`;
-    }
-    if (typeof value === 'object') {
-        const entries = Object.entries(value);
-        if (entries.length === 0)
-            return '{}';
-        const pad = ' '.repeat(indent + 2);
-        const closingPad = ' '.repeat(indent);
-        const inner = entries
-            .map(([k, v]) => `${pad}${formatKey(k)}: ${jsLiteral(v, indent + 2)}`)
-            .join(',\n');
-        return `{\n${inner},\n${closingPad}}`;
-    }
-    return JSON.stringify(value);
-}
-function formatKey(key) {
-    // Use bare identifier when possible (preserves nice JS look); fall back
-    // to quoted string for keys with hyphens, dots, or starting with a digit.
-    if (/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key))
-        return key;
-    return JSON.stringify(key);
-}
 /** Render the SchemaMetadata IR to a TypeScript const literal block. */
 export function formatMetadataConst(meta) {
     const lowerName = meta.modelName.charAt(0).toLowerCase() + meta.modelName.slice(1);
@@ -299,39 +265,39 @@ export function formatMetadataConst(meta) {
     parts.push(`\n`);
     parts.push(`  fields: {\n`);
     for (const [fieldName, field] of Object.entries(meta.fields)) {
-        parts.push(`    ${formatKey(fieldName)}: {\n`);
+        parts.push(`    ${formatTsObjectKey(fieldName)}: {\n`);
         parts.push(`      type: ${JSON.stringify(field.type)},\n`);
         parts.push(`      required: ${field.required},\n`);
         parts.push(`      nullable: ${field.nullable},\n`);
         parts.push(`      translatable: ${field.translatable},\n`);
-        parts.push(`      validation: ${jsLiteral(field.validation, 6)},\n`);
+        parts.push(`      validation: ${tsObjectLiteral(field.validation, 6)},\n`);
         if (field.enum) {
             parts.push(`      enum: ${JSON.stringify(field.enum)},\n`);
         }
         if (field.enumValues) {
-            parts.push(`      enumValues: ${jsLiteral([...field.enumValues], 6)} as const,\n`);
+            parts.push(`      enumValues: ${tsObjectLiteral([...field.enumValues], 6)} as const,\n`);
         }
         if (field.relation) {
-            parts.push(`      relation: ${jsLiteral(field.relation, 6)},\n`);
+            parts.push(`      relation: ${tsObjectLiteral(field.relation, 6)},\n`);
         }
         if (field.compoundType) {
             parts.push(`      compoundType: ${JSON.stringify(field.compoundType)},\n`);
         }
-        parts.push(`      label: ${jsLiteral(field.label, 6)},\n`);
+        parts.push(`      label: ${tsObjectLiteral(field.label, 6)},\n`);
         if (field.placeholder) {
-            parts.push(`      placeholder: ${jsLiteral(field.placeholder, 6)},\n`);
+            parts.push(`      placeholder: ${tsObjectLiteral(field.placeholder, 6)},\n`);
         }
         if (field.description) {
-            parts.push(`      description: ${jsLiteral(field.description, 6)},\n`);
+            parts.push(`      description: ${tsObjectLiteral(field.description, 6)},\n`);
         }
         parts.push(`    },\n`);
     }
     parts.push(`  },\n\n`);
     // Aggregations — emit as `as const` arrays so the literal types narrow.
-    parts.push(`  translatableFields: ${jsLiteral(meta.aggregations.translatableFields, 2)} as const,\n`);
-    parts.push(`  requiredFields: ${jsLiteral(meta.aggregations.requiredFields, 2)} as const,\n`);
-    parts.push(`  enumFields: ${jsLiteral(meta.aggregations.enumFields, 2)} as const,\n`);
-    parts.push(`  relationFields: ${jsLiteral(meta.aggregations.relationFields, 2)} as const,\n`);
+    parts.push(`  translatableFields: ${tsObjectLiteral(meta.aggregations.translatableFields, 2)} as const,\n`);
+    parts.push(`  requiredFields: ${tsObjectLiteral(meta.aggregations.requiredFields, 2)} as const,\n`);
+    parts.push(`  enumFields: ${tsObjectLiteral(meta.aggregations.enumFields, 2)} as const,\n`);
+    parts.push(`  relationFields: ${tsObjectLiteral(meta.aggregations.relationFields, 2)} as const,\n`);
     parts.push(`} as const;\n\n`);
     // Field-name type alias for ergonomic keying in downstream consumers.
     parts.push(`export type ${meta.modelName}FieldName = keyof typeof ${constName}.fields;\n\n`);

package/dist/php/orphan-cleanup.d.ts

@@ -19,6 +19,13 @@
  * warning is printed so the user can decide whether to clean up by hand.
  */
 import type { GeneratedFile, PhpConfig } from './types.js';
+/** Matches the header emitted by `generateEditableService` in service-generator.ts */
+export declare const OMNIFY_EDITABLE_SERVICE_MARKER = "SAFE TO EDIT - This file is never overwritten by Omnify.";
+/**
+ * True when the file looks like an Omnify sinh-1-lần editable stub (not a
+ * hand-written app service that merely ends in `Service.php`).
+ */
+export declare function looksLikeOmnifyEditableService(fileContent: string): boolean;
 export interface ServiceCleanupResult {
     /** Absolute paths to `*ServiceBase.php` files that were deleted. */
     prunedBases: string[];

package/dist/php/orphan-cleanup.js

@@ -18,8 +18,31 @@
  * deleted — they may contain hand-written user code — instead a console
  * warning is printed so the user can decide whether to clean up by hand.
  */
-import { existsSync, readdirSync, statSync, unlinkSync } from 'node:fs';
+import { existsSync, readFileSync, readdirSync, statSync, unlinkSync } from 'node:fs';
 import { join, resolve, basename } from 'node:path';
+/** 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/;
+/**
+ * True when the file looks like an Omnify sinh-1-lần editable stub (not a
+ * hand-written app service that merely ends in `Service.php`).
+ */
+export function looksLikeOmnifyEditableService(fileContent) {
+    if (fileContent.includes(OMNIFY_EDITABLE_SERVICE_MARKER)) {
+        return true;
+    }
+    return EXTENDS_SERVICE_BASE_RE.test(fileContent);
+}
+function readEditableServiceHead(filePath) {
+    try {
+        const buf = readFileSync(filePath);
+        const max = Math.min(buf.length, 8192);
+        return buf.toString('utf8', 0, max);
+    }
+    catch {
+        return null;
+    }
+}
 /**
  * Apply service cleanup only while this target is managed by Omnify.
  * A globally disabled service layer is a migration boundary: existing bases
@@ -96,6 +119,25 @@ export function pruneOrphanServiceFiles(configDir, config, generated) {
     // The recursive walk skips the `OmnifyBase` subfolder (already covered
     // by the base cleanup above) so we don't double-process or warn on
     // base files masquerading as editable.
+    // Membership in `expectedAbs` is the WRONG test for an editable service, and
+    // was the whole defect: an editable service is sinh-1-lần, so once it exists
+    // this pass deliberately skips it and it is never in the generated set. Every
+    // editable service that had ever been created therefore reported itself
+    // orphan on every run — 28 of them here, each with a live `kind: object`
+    // schema that omnify was regenerating a base for in the very same pass, and
+    // each advertised as "safe to delete by hand" while holding the app's
+    // business logic.
+    //
+    // What actually marks a schema ineligible is the absence of its BASE: bases
+    // are regenerated wholesale every pass, so `<Name>ServiceBase.php` is in the
+    // generated set exactly while the schema still opts into service codegen.
+    const expectedBaseNames = new Set();
+    for (const abs of expectedAbs) {
+        const name = basename(abs);
+        if (name.endsWith('ServiceBase.php')) {
+            expectedBaseNames.add(name);
+        }
+    }
     const editableRoot = resolve(configDir, config.services.path);
     walkServiceFiles(editableRoot, (path) => {
         const name = basename(path);
@@ -105,6 +147,13 @@ export function pruneOrphanServiceFiles(configDir, config, generated) {
             return;
         if (expectedAbs.has(path))
             return;
+        // `AbsenceService.php` → `AbsenceServiceBase.php`
+        const baseName = `${name.slice(0, -'Service.php'.length)}ServiceBase.php`;
+        if (expectedBaseNames.has(baseName))
+            return;
+        const head = readEditableServiceHead(path);
+        if (head === null || !looksLikeOmnifyEditableService(head))
+            return;
         result.warnedEditables.push(path);
     });
     return result;

package/dist/prettier-format.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Auto-format generated TypeScript files via the consuming project's Prettier.
+ * Issue omnify-jp/omnify-go#211 (mirrors php/pint-format.ts).
+ */
+/**
+ * Resolve `node_modules/.bin/prettier` by walking up from a written `.ts` file.
+ */
+export declare function findPrettierBinary(anyWrittenTsPath: string): string | null;
+/** Directory containing the `node_modules` that owns this Prettier binary. */
+export declare function prettierProjectRoot(prettierPath: string): string;
+export interface PrettierFormatResult {
+    ran: boolean;
+    prettierPath: string | null;
+    formattedCount: number;
+    exitStatus: number | null;
+    errorMessage?: string;
+    skipped?: 'no-ts-files' | 'opted-out' | 'prettier-not-found';
+}
+/**
+ * Run the project's Prettier on the given TypeScript files (absolute paths).
+ * Silent no-op when Prettier is not installed; never throws.
+ */
+export declare function runPrettierFormat(writtenTsPaths: string[]): PrettierFormatResult;

package/dist/prettier-format.js

@@ -0,0 +1,102 @@
+/**
+ * Auto-format generated TypeScript files via the consuming project's Prettier.
+ * Issue omnify-jp/omnify-go#211 (mirrors php/pint-format.ts).
+ */
+import { existsSync, statSync } from 'node:fs';
+import { spawnSync } from 'node:child_process';
+import { dirname, join } from 'node:path';
+/** Max file paths per Prettier invocation (stay under typical ARG_MAX). */
+const PRETTIER_BATCH_SIZE = 100;
+/**
+ * Resolve `node_modules/.bin/prettier` by walking up from a written `.ts` file.
+ */
+export function findPrettierBinary(anyWrittenTsPath) {
+    let cur = dirname(anyWrittenTsPath);
+    for (let i = 0; i < 12; i++) {
+        const candidate = join(cur, 'node_modules', '.bin', 'prettier');
+        if (existsSync(candidate)) {
+            try {
+                const st = statSync(candidate);
+                if (st.isFile())
+                    return candidate;
+            }
+            catch {
+                // ignore stat errors and keep climbing
+            }
+        }
+        const parent = dirname(cur);
+        if (parent === cur)
+            break;
+        cur = parent;
+    }
+    return null;
+}
+/** Directory containing the `node_modules` that owns this Prettier binary. */
+export function prettierProjectRoot(prettierPath) {
+    return dirname(dirname(dirname(prettierPath)));
+}
+function runPrettierBatch(prettierPath, projectRoot, files) {
+    const result = spawnSync(prettierPath, ['--write', ...files], {
+        cwd: projectRoot,
+        stdio: ['ignore', 'pipe', 'pipe'],
+        encoding: 'utf-8',
+    });
+    const exitStatus = result.status ?? null;
+    return {
+        exitStatus,
+        errorMessage: exitStatus !== 0 ? (result.stderr || result.stdout || undefined) : undefined,
+    };
+}
+/**
+ * Run the project's Prettier on the given TypeScript files (absolute paths).
+ * Silent no-op when Prettier is not installed; never throws.
+ */
+export function runPrettierFormat(writtenTsPaths) {
+    if (writtenTsPaths.length === 0) {
+        return {
+            ran: false,
+            prettierPath: null,
+            formattedCount: 0,
+            exitStatus: null,
+            skipped: 'no-ts-files',
+        };
+    }
+    if (process.env.OMNIFY_NO_PRETTIER === '1') {
+        return {
+            ran: false,
+            prettierPath: null,
+            formattedCount: 0,
+            exitStatus: null,
+            skipped: 'opted-out',
+        };
+    }
+    const prettierPath = writtenTsPaths.reduce((found, path) => found ?? findPrettierBinary(path), null);
+    if (!prettierPath) {
+        return {
+            ran: false,
+            prettierPath: null,
+            formattedCount: 0,
+            exitStatus: null,
+            skipped: 'prettier-not-found',
+        };
+    }
+    const projectRoot = prettierProjectRoot(prettierPath);
+    let exitStatus = 0;
+    let errorMessage;
+    for (let i = 0; i < writtenTsPaths.length; i += PRETTIER_BATCH_SIZE) {
+        const batch = writtenTsPaths.slice(i, i + PRETTIER_BATCH_SIZE);
+        const batchResult = runPrettierBatch(prettierPath, projectRoot, batch);
+        if (batchResult.exitStatus !== 0) {
+            exitStatus = batchResult.exitStatus;
+            errorMessage = batchResult.errorMessage;
+            break;
+        }
+    }
+    return {
+        ran: true,
+        prettierPath,
+        formattedCount: writtenTsPaths.length,
+        exitStatus,
+        errorMessage,
+    };
+}

package/dist/ts-literal.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Emit TypeScript object/array literals (not JSON.stringify blobs).
+ * Issue omnify-jp/omnify-go#211 — Prettier-stable i18n label shapes.
+ */
+/** Object key as a bare identifier when valid, else a quoted string. */
+export declare function formatTsObjectKey(key: string): string;
+/** Render a value as a TypeScript literal expression. */
+export declare function tsObjectLiteral(value: unknown, indent?: number): string;

package/dist/ts-literal.js

@@ -0,0 +1,39 @@
+/**
+ * Emit TypeScript object/array literals (not JSON.stringify blobs).
+ * Issue omnify-jp/omnify-go#211 — Prettier-stable i18n label shapes.
+ */
+/** Object key as a bare identifier when valid, else a quoted string. */
+export function formatTsObjectKey(key) {
+    if (/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key))
+        return key;
+    return JSON.stringify(key);
+}
+/** Render a value as a TypeScript literal expression. */
+export function tsObjectLiteral(value, indent = 0) {
+    if (value === null)
+        return 'null';
+    if (value === undefined)
+        return 'undefined';
+    if (typeof value === 'string')
+        return JSON.stringify(value);
+    if (typeof value === 'number' || typeof value === 'boolean')
+        return String(value);
+    if (Array.isArray(value)) {
+        if (value.length === 0)
+            return '[]';
+        const inner = value.map((v) => tsObjectLiteral(v, indent + 2)).join(', ');
+        return `[${inner}]`;
+    }
+    if (typeof value === 'object') {
+        const entries = Object.entries(value);
+        if (entries.length === 0)
+            return '{}';
+        const pad = ' '.repeat(indent + 2);
+        const closingPad = ' '.repeat(indent);
+        const inner = entries
+            .map(([k, v]) => `${pad}${formatTsObjectKey(k)}: ${tsObjectLiteral(v, indent + 2)}`)
+            .join(',\n');
+        return `{\n${inner},\n${closingPad}}`;
+    }
+    return JSON.stringify(value);
+}

package/dist/zod-generator.js

@@ -4,6 +4,7 @@
  * Generates Zod schemas alongside TypeScript interfaces for form validation.
  */
 import { toSnakeCase } from './interface-generator.js';
+import { tsObjectLiteral } from './ts-literal.js';
 /**
  * Get localized display name as multi-locale object.
  */
@@ -517,14 +518,14 @@ export function formatZodSchemasSection(schemaName, zodSchemas, displayNames, ex
     parts.push(`// ============================================================================\n\n`);
     parts.push(`/**\n * Unified i18n object for ${schemaName}\n */\n`);
     parts.push(`export const ${lowerName}I18n = {\n`);
-    parts.push(`  label: ${JSON.stringify(displayNames.displayName)},\n`);
+    parts.push(`  label: ${tsObjectLiteral(displayNames.displayName, 2)},\n`);
     parts.push(`  fields: {\n`);
     for (const [propName, labelMap] of Object.entries(displayNames.propertyDisplayNames)) {
         const placeholderMap = displayNames.propertyPlaceholders[propName];
         parts.push(`    ${propName}: {\n`);
-        parts.push(`      label: ${JSON.stringify(labelMap)},\n`);
+        parts.push(`      label: ${tsObjectLiteral(labelMap, 6)},\n`);
         if (placeholderMap) {
-            parts.push(`      placeholder: ${JSON.stringify(placeholderMap)},\n`);
+            parts.push(`      placeholder: ${tsObjectLiteral(placeholderMap, 6)},\n`);
         }
         parts.push(`    },\n`);
     }

package/package.json

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