@omnifyjp/omnify 3.13.0 → 3.13.1

package/package.json

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

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`);
         }