@omnifyjp/ts 5.8.36 → 5.8.39

package/dist/interface-generator.d.ts

@@ -18,7 +18,15 @@ export declare function getPropertyType(property: PropertyDefinition, allSchemas
 export declare function propertyToTSProperties(propertyName: string, property: PropertyDefinition, schema: SchemaDefinition, allSchemas: Record<string, SchemaDefinition>, options: GeneratorOptions): TSProperty[];
 /** Generate a TSInterface from a schema definition. */
 export declare function schemaToInterface(schema: SchemaDefinition, allSchemas: Record<string, SchemaDefinition>, options: GeneratorOptions): TSInterface;
-/** Format a TypeScript property line. */
+/** Format a TypeScript property line.
+ *
+ * Nullable fields (DB column allows NULL) emit `field?: T | null` so
+ * consumers can accept the actual JSON value the backend serializes
+ * (`null`), not just an absent key. Mirrors the Go target's `*T`
+ * pointer convention — `*string` in Go ↔ `string | null` in TS.
+ * Pure-optional fields (e.g. payload DTOs that allow omitting) keep
+ * the `field?: T` shape. Issue #103 Phase 2 TS-Go nullability sync.
+ */
 export declare function formatProperty(property: TSProperty): string;
 /** Format a TypeScript interface. */
 export declare function formatInterface(iface: TSInterface): string;

package/dist/interface-generator.js

@@ -129,6 +129,7 @@ export function propertyToTSProperties(propertyName, property, schema, allSchema
                 name: col.name,
                 type: tsType,
                 optional: col.nullable ?? false,
+                nullable: col.nullable ?? false,
                 readonly: isReadonly,
             });
         }
@@ -142,6 +143,7 @@ export function propertyToTSProperties(propertyName, property, schema, allSchema
                 name: propertyName,
                 type: tsType,
                 optional: isNullable,
+                nullable: isNullable,
                 readonly: isReadonly,
             }];
     }
@@ -185,10 +187,13 @@ export function propertyToTSProperties(propertyName, property, schema, allSchema
                 name: `${propertyName}_id`,
                 type: fkType,
                 optional: isNullable,
+                nullable: isNullable,
                 readonly: isReadonly,
             },
             {
                 name: propertyName,
+                // Type already carries `| null` when nullable — don't double up
+                // by also setting nullable: true on the property.
                 type: isNullable ? `${targetName} | null` : targetName,
                 optional: true,
                 readonly: isReadonly,
@@ -211,6 +216,7 @@ export function propertyToTSProperties(propertyName, property, schema, allSchema
             name: propertyName,
             type,
             optional: isNullable,
+            nullable: isNullable,
             readonly: isReadonly,
         }];
 }
@@ -252,13 +258,17 @@ export function schemaToInterface(schema, allSchemas, options) {
             properties.push(...propertyToTSProperties(propName, property, schema, allSchemas, options));
         }
     }
-    // Timestamps
+    // Timestamps. created_at + updated_at are NOT NULL with DEFAULT
+    // CURRENT_TIMESTAMP — every persisted row has them. Mark optional in
+    // Create-DTO contexts (caller can omit, DB fills) but always present
+    // and never NULL on the read shape, so no `| null`.
     if (schema.options?.timestamps !== false) {
         properties.push({ name: 'created_at', type: 'DateTimeString', optional: true, readonly: false }, { name: 'updated_at', type: 'DateTimeString', optional: true, readonly: false });
     }
-    // Soft delete
+    // Soft delete. deleted_at IS nullable (NULL until soft-deleted) — match
+    // Go's `*time.Time` pointer with TS `?: DateTimeString | null`.
     if (schema.options?.softDelete) {
-        properties.push({ name: 'deleted_at', type: 'DateTimeString', optional: true, readonly: false });
+        properties.push({ name: 'deleted_at', type: 'DateTimeString', optional: true, nullable: true, readonly: false });
     }
     // Collect dependencies
     const dependencySet = new Set();
@@ -304,10 +314,24 @@ export function schemaToInterface(schema, allSchemas, options) {
         enumDependencies: enumDependencySet.size > 0 ? Array.from(enumDependencySet).sort() : undefined,
     };
 }
-/** Format a TypeScript property line. */
+/** Format a TypeScript property line.
+ *
+ * Nullable fields (DB column allows NULL) emit `field?: T | null` so
+ * consumers can accept the actual JSON value the backend serializes
+ * (`null`), not just an absent key. Mirrors the Go target's `*T`
+ * pointer convention — `*string` in Go ↔ `string | null` in TS.
+ * Pure-optional fields (e.g. payload DTOs that allow omitting) keep
+ * the `field?: T` shape. Issue #103 Phase 2 TS-Go nullability sync.
+ */
 export function formatProperty(property) {
     const optional = property.optional ? '?' : '';
-    return `  ${property.name}${optional}: ${property.type};`;
+    // Already-nullable type strings (e.g. someone hand-wrote `T | null`
+    // upstream) are passed through unchanged so we don't end up with
+    // `T | null | null`.
+    const typeStr = property.nullable && !/\| null\b/.test(property.type)
+        ? `${property.type} | null`
+        : property.type;
+    return `  ${property.name}${optional}: ${typeStr};`;
 }
 /** Format a TypeScript interface. */
 export function formatInterface(iface) {

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

@@ -20,9 +20,34 @@ namespace ${ns};
  */
 
 use Illuminate\\Database\\Eloquent\\Model;
+use Illuminate\\Database\\Eloquent\\Relations\\Relation;
 
 class BaseModel extends Model
 {
+    /**
+     * Resolve the polymorphic alias from the morph map, walking up the class
+     * hierarchy so application subclasses of a generated model still resolve.
+     *
+     * Omnify registers the morph map against the generated model classes. A
+     * project that subclasses one and instantiates the subclass would otherwise
+     * throw ClassMorphViolationException under an enforced morph map, because the
+     * subclass itself is absent from the map. Returning the nearest mapped
+     * ancestor's alias keeps stored type values stable across both layers.
+     */
+    public function getMorphClass(): string
+    {
+        $morphMap = Relation::morphMap();
+
+        for ($class = static::class; $class !== false; $class = get_parent_class($class)) {
+            $alias = array_search($class, $morphMap, true);
+
+            if ($alias !== false) {
+                return $alias;
+            }
+        }
+
+        return parent::getMorphClass();
+    }
 }
 `;
     const path = resolveSharedBasePath(config, 'Models', 'BaseModel.php', config.models.basePath);

package/dist/types.d.ts

@@ -392,6 +392,14 @@ export interface TSProperty {
     readonly optional: boolean;
     readonly readonly: boolean;
     readonly comment?: string;
+    /**
+     * The underlying schema column is `nullable: true` (DB allows NULL),
+     * NOT just "optional in some payload shape". When set, formatProperty
+     * emits `field?: T | null` so consumers can accept the actual JSON
+     * value the backend serializes (`null`, not `undefined`). Mirrors the
+     * Go target's `*T` pointer convention. Phase 2 of issue #103.
+     */
+    readonly nullable?: boolean;
 }
 /** TypeScript interface definition. */
 export interface TSInterface {

package/package.json

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