@omnifyjp/omnify 3.13.0 → 3.14.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@omnifyjp/omnify",
-  "version": "3.13.0",
+  "version": "3.14.0",
   "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": "3.13.0",
-    "@omnifyjp/omnify-darwin-x64": "3.13.0",
-    "@omnifyjp/omnify-linux-x64": "3.13.0",
-    "@omnifyjp/omnify-linux-arm64": "3.13.0",
-    "@omnifyjp/omnify-win32-x64": "3.13.0"
+    "@omnifyjp/omnify-darwin-arm64": "3.14.0",
+    "@omnifyjp/omnify-darwin-x64": "3.14.0",
+    "@omnifyjp/omnify-linux-x64": "3.14.0",
+    "@omnifyjp/omnify-linux-arm64": "3.14.0",
+    "@omnifyjp/omnify-win32-x64": "3.14.0"
   }
 }

package/ts-dist/generator.js

@@ -17,6 +17,9 @@ import { generateEnums, generatePluginEnums, formatEnum, formatTypeAlias, extrac
 import { generateZodSchemas, generateDisplayNames, getExcludedFields, formatZodSchemasSection, formatZodModelFile, } from './zod-generator.js';
 import { generateI18nFileContent } from './i18n-generator.js';
 import { buildSchemaMetadata, formatMetadataConst, } from './metadata-generator.js';
+import { generateTsServices } from './ts-service-generator.js';
+import { generateTsQueryKeys } from './ts-query-keys-generator.js';
+import { generateTsHooks } from './ts-hooks-generator.js';
 import { buildFormShape, formatPayloadBuilderSection, } from './payload-builder-generator.js';
 /** Auto-generated file header. */
 function generateBaseHeader() {
@@ -493,6 +496,11 @@ export function generateTypeScript(input) {
     files.push(generatePayloadHelpersFile(options));
     // I18n
     files.push(generateI18nFile(options));
+    // Frontend service layer: BaseService + QueryKeys + Hooks (issue #58)
+    // Only for schemas with options.api or options.service.
+    files.push(...generateTsServices(schemas, options));
+    files.push(...generateTsQueryKeys(schemas));
+    files.push(...generateTsHooks(schemas));
     // Index re-exports
     files.push(generateIndexFile(schemas, schemaEnums, pluginEnums, inlineTypeAliases, hasFiles));
     return files;

package/ts-dist/metadata-generator.d.ts

@@ -44,6 +44,8 @@ export interface MetadataField {
     label: Record<string, string>;
     /** Localized placeholder dictionary (locale → string). Optional. */
     placeholder?: Record<string, string>;
+    /** Localized description dictionary (locale → string). Optional. Issue #59. */
+    description?: Record<string, string>;
 }
 /** Aggregations exported alongside the per-field entries for ergonomics. */
 export interface MetadataAggregations {

package/ts-dist/metadata-generator.js

@@ -191,6 +191,9 @@ export function buildSchemaMetadata(schema, allSchemas, options, displayNames) {
             const placeholder = displayNames.propertyPlaceholders[fieldKey];
             if (placeholder)
                 meta.placeholder = placeholder;
+            const description = displayNames.propertyDescriptions[fieldKey];
+            if (description)
+                meta.description = description;
             if (fieldType === 'enum') {
                 if (typeof prop.enum === 'string') {
                     meta.enum = prop.enum;
@@ -314,6 +317,9 @@ export function formatMetadataConst(meta) {
         if (field.placeholder) {
             parts.push(`      placeholder: ${jsLiteral(field.placeholder, 6)},\n`);
         }
+        if (field.description) {
+            parts.push(`      description: ${jsLiteral(field.description, 6)},\n`);
+        }
         parts.push(`    },\n`);
     }
     parts.push(`  },\n\n`);

package/ts-dist/payload-builder-generator.d.ts

@@ -38,6 +38,15 @@ export interface FormField {
     nullable: boolean;
     /** Default value for `empty<Model>CreateForm()`, as a JS literal string. */
     defaultLiteral: string;
+    /**
+     * When true, the field is intentionally omitted from the
+     * `empty<Model>CreateForm()` factory body. Used for optional enum
+     * reference fields where no sensible default exists — the interface
+     * marks the field `?:` so omitting the key is valid, and this is
+     * safer than emitting `undefined` under `exactOptionalPropertyTypes`.
+     * Issue omnify-jp/omnify-go#56.
+     */
+    omitFromEmpty?: boolean;
 }
 /** Resolved per-schema form metadata. */
 export interface SchemaFormShape {

package/ts-dist/payload-builder-generator.js

@@ -22,6 +22,7 @@
  */
 import { toSnakeCase } from './interface-generator.js';
 import { classifyFieldType } from './metadata-generator.js';
+import { toEnumMemberName } from './enum-generator.js';
 // ---------------------------------------------------------------------------
 // Build the IR
 // ---------------------------------------------------------------------------
@@ -71,26 +72,86 @@ function tsTypeForField(metaType, prop) {
             return 'string';
     }
 }
-function defaultLiteralForField(metaType, prop) {
-    // Honor an explicit YAML default when present.
+/**
+ * Resolve an enum's value list either from a plugin enum bank
+ * (customTypes.enums) or from a schema-defined enum (`kind: enum` schemas).
+ * Returns undefined if the enum reference can't be resolved at codegen time.
+ */
+function resolveEnumValueList(prop, allSchemas, pluginEnums) {
+    if (typeof prop.enum === 'string') {
+        // Plugin enum first (customTypes.enums), then schema enum.
+        const fromPlugin = pluginEnums[prop.enum];
+        if (fromPlugin)
+            return fromPlugin;
+        const schemaEnum = allSchemas[prop.enum];
+        if (schemaEnum?.values && schemaEnum.values.length > 0) {
+            return schemaEnum.values.map((v) => v.value);
+        }
+        return undefined;
+    }
+    if (Array.isArray(prop.enum)) {
+        return prop.enum.map((v) => typeof v === 'string' ? v : v.value);
+    }
+    return undefined;
+}
+function defaultLiteralForField(metaType, prop, required, allSchemas, pluginEnums) {
+    // -----------------------------------------------------------------
+    // Enum fields — reference the enum member, not a string literal.
+    //
+    // `status: 'free'` is not assignable to `TableStatus` under strict
+    // TypeScript because enum types are nominal. We must emit
+    // `TableStatus.Free` instead. For inline enums (array of strings) the
+    // TS type is a literal union, so string literals are fine — that case
+    // falls through to the JSON.stringify path at the bottom.
+    //
+    // Issue omnify-jp/omnify-go#56.
+    // -----------------------------------------------------------------
+    if (metaType === 'enum' && typeof prop.enum === 'string') {
+        const enumName = prop.enum;
+        // Optional / nullable enum refs: omit from the factory body entirely.
+        // The form-state interface already marks the field `?:`, so skipping
+        // the key is a valid object literal under strict TS regardless of
+        // `exactOptionalPropertyTypes`.
+        if (!required) {
+            return { literal: '', omit: true };
+        }
+        // Pick the default value: honor YAML `default` first, else first
+        // declared enum member.
+        let rawValue;
+        if (prop.default !== undefined && prop.default !== null) {
+            rawValue = String(prop.default);
+        }
+        else {
+            const values = resolveEnumValueList(prop, allSchemas, pluginEnums);
+            if (values && values.length > 0) {
+                rawValue = values[0];
+            }
+        }
+        if (rawValue === undefined) {
+            // Can't resolve the enum values at codegen time (unlikely, but
+            // keeps the generator total). Fall back to omitting — the dev
+            // will get a TS error at form init and can fix it manually.
+            return { literal: '', omit: true };
+        }
+        return { literal: `${enumName}.${toEnumMemberName(rawValue)}` };
+    }
+    // Honor an explicit YAML default when present (non-enum path).
     if (prop.default !== undefined && prop.default !== null) {
-        return JSON.stringify(prop.default);
+        return { literal: JSON.stringify(prop.default) };
     }
-    // For enums with no default, prefer the first value so the form has a
-    // valid selection on mount.
+    // Inline enum (array form) — the form-state tsType is a literal union,
+    // so a string literal is directly assignable. Use the first value.
     if (metaType === 'enum') {
         if (Array.isArray(prop.enum) && prop.enum.length > 0) {
             const first = prop.enum[0];
             const val = typeof first === 'string' ? first : first.value;
-            return JSON.stringify(val);
+            return { literal: JSON.stringify(val) };
         }
-        // Enum reference: we don't have the value list here; emit empty
-        // string and let the dev select on first interaction.
-        return "''";
+        return { literal: "''" };
     }
     if (metaType === 'boolean')
-        return 'false';
-    return PRIMITIVE_TS_DEFAULTS[metaType];
+        return { literal: 'false' };
+    return { literal: PRIMITIVE_TS_DEFAULTS[metaType] };
 }
 /** Build the form shape IR from a schema. */
 export function buildFormShape(schema, allSchemas, options) {
@@ -129,6 +190,7 @@ export function buildFormShape(schema, allSchemas, options) {
             : prop.rules?.required === true
                 ? true
                 : !(prop.nullable ?? false);
+        const { literal, omit } = defaultLiteralForField(metaType, prop, required, allSchemas, options.customTypes.enums);
         fields.push({
             fieldName,
             tsType: tsTypeForField(metaType, prop),
@@ -136,7 +198,8 @@ export function buildFormShape(schema, allSchemas, options) {
             translatable: prop.translatable === true,
             required,
             nullable: prop.nullable ?? false,
-            defaultLiteral: defaultLiteralForField(metaType, prop),
+            defaultLiteral: literal,
+            omitFromEmpty: omit,
         });
     }
     return { modelName: schema.name, fields };
@@ -184,6 +247,11 @@ export function formatPayloadBuilderSection(shape, defaultLocale) {
     parts.push(`export function empty${modelName}CreateForm(): ${modelName}CreateFormState {\n`);
     parts.push(`  return {\n`);
     for (const f of fields) {
+        // Skip fields marked for omission (e.g. optional enum references
+        // with no sensible default — the interface marks them `?:`).
+        // Issue omnify-jp/omnify-go#56.
+        if (f.omitFromEmpty)
+            continue;
         if (f.translatable) {
             parts.push(`    ${f.fieldName}: emptyLocaleMap(),\n`);
         }

package/ts-dist/php/index.js

@@ -60,7 +60,6 @@ export function generatePhp(data, overrides) {
     if (reader.hasApiSchemas()) {
         files.push(...generateSchemaConfig(reader, config));
         files.push(...generateControllers(reader, config));
-        files.push(...generateServices(reader, config));
         files.push(...generateRoutes(reader, config));
         // Issue #35: opt-in OpenAPI / Swagger annotation scaffold.
         // Controller-level method attributes are emitted inline by
@@ -68,6 +67,10 @@ export function generatePhp(data, overrides) {
         // we add the standalone Common / Info / Schemas files.
         files.push(...generateOpenApi(reader, config));
     }
+    // Service layer (schemas with options.api OR options.service). Issue #57.
+    if (reader.hasApiSchemas() || reader.hasServiceSchemas()) {
+        files.push(...generateServices(reader, config));
+    }
     // Issue #34: every `kind: enum` schema becomes a global PHP enum class.
     files.push(...generateEnums(reader, config));
     // Per-schema files

package/ts-dist/php/schema-reader.d.ts

@@ -57,6 +57,17 @@ export declare class SchemaReader {
     getFileConfig(): import("../types.js").FileConfigExport | null;
     /** Get all schemas that have File-type properties. */
     getSchemasWithFileProperties(): Record<string, SchemaDefinition>;
+    /** Get global audit config from schemas.json. */
+    getAuditConfig(): {
+        model?: string;
+        createdBy?: boolean;
+        updatedBy?: boolean;
+        deletedBy?: boolean;
+    } | null;
+    /** Get schemas that have service options configured (options.service). */
+    getSchemasWithService(): Record<string, import('../types.js').SchemaDefinition>;
+    /** Check if any schema has service options. */
+    hasServiceSchemas(): boolean;
     /** Get translatable field names (snake_case) for a schema. */
     getTranslatableFields(schemaName: string): string[];
 }

package/ts-dist/php/schema-reader.js

@@ -201,6 +201,24 @@ export class SchemaReader {
         }
         return result;
     }
+    /** Get global audit config from schemas.json. */
+    getAuditConfig() {
+        return this.data.auditConfig ?? null;
+    }
+    /** Get schemas that have service options configured (options.service). */
+    getSchemasWithService() {
+        const result = {};
+        for (const [name, schema] of Object.entries(this.getProjectVisibleObjectSchemas())) {
+            if (schema.options?.service) {
+                result[name] = schema;
+            }
+        }
+        return result;
+    }
+    /** Check if any schema has service options. */
+    hasServiceSchemas() {
+        return Object.keys(this.getSchemasWithService()).length > 0;
+    }
     /** Get translatable field names (snake_case) for a schema. */
     getTranslatableFields(schemaName) {
         const schema = this.getSchema(schemaName);

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

@@ -1,7 +1,11 @@
 /**
- * Generates base + editable service classes for schemas with `options.api`.
+ * Generates base + editable service classes for schemas with `options.api`
+ * or `options.service`.
+ *
+ * Issue #57: Full BaseService codegen with translatable, softDelete, audit,
+ * DB::transaction, eagerLoad/eagerCount, lookupFields, defaultSort.
  */
 import { SchemaReader } from './schema-reader.js';
 import type { GeneratedFile, PhpConfig } from './types.js';
-/** Generate service classes for all schemas with api config. */
+/** Generate service classes for all schemas with api or service config. */
 export declare function generateServices(reader: SchemaReader, config: PhpConfig): GeneratedFile[];