@omnifyjp/omnify 3.7.2 → 3.9.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@omnifyjp/omnify",
-  "version": "3.7.2",
+  "version": "3.9.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.7.2",
-    "@omnifyjp/omnify-darwin-x64": "3.7.2",
-    "@omnifyjp/omnify-linux-x64": "3.7.2",
-    "@omnifyjp/omnify-linux-arm64": "3.7.2",
-    "@omnifyjp/omnify-win32-x64": "3.7.2"
+    "@omnifyjp/omnify-darwin-arm64": "3.9.0",
+    "@omnifyjp/omnify-darwin-x64": "3.9.0",
+    "@omnifyjp/omnify-linux-x64": "3.9.0",
+    "@omnifyjp/omnify-linux-arm64": "3.9.0",
+    "@omnifyjp/omnify-win32-x64": "3.9.0"
   }
 }

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

@@ -1,7 +1,7 @@
 /**
  * Port of ModelGenerator.php — generates Eloquent model base + user classes.
  */
-import { toPascalCase, toSnakeCase, toCamelCase } from './naming-helper.js';
+import { toPascalCase, toSnakeCase, toCamelCase, pluralize } from './naming-helper.js';
 import { toCast, toPhpDocType, isHiddenByDefault } from './type-mapper.js';
 import { buildRelation } from './relation-builder.js';
 import { baseFile, userFile, resolveModularBasePath, resolveModularBaseNamespace, resolveSharedBaseNamespace, resolveGlobalTraitNamespace, resolveGlobalEnumNamespace, } from './types.js';
@@ -490,6 +490,12 @@ function buildCasts(properties, expandedProperties, propertyOrder, reader, confi
 function buildRelations(schemaName, properties, propertyOrder, modelNamespace, reader) {
     const methods = [];
     const sourceTableName = reader.getTableName(schemaName);
+    // Track method names already declared on this model so reverse-relation
+    // inference (#39) can skip any name the user has explicitly defined.
+    const declaredMethods = new Set();
+    // Track explicit OneToMany/HasOne declarations by `<targetSchema>.<mappedBy>`
+    // so the auto-inverse pass can skip child relations the user already covered.
+    const explicitInverses = new Set();
     for (const propName of propertyOrder) {
         const prop = properties[propName];
         if (!prop || prop['type'] !== 'Association')
@@ -501,6 +507,78 @@ function buildRelations(schemaName, properties, propertyOrder, modelNamespace, r
         const result = buildRelation(propName, prop, ns, { sourceTableName, targetTableName });
         if (result) {
             methods.push('\n' + result.method);
+            declaredMethods.add(toCamelCase(propName));
+            const relation = prop['relation'] ?? '';
+            const mappedBy = prop['mappedBy'] ?? '';
+            if ((relation === 'OneToMany' || relation === 'OneToOne') && target && mappedBy) {
+                explicitInverses.add(`${target}.${mappedBy}`);
+            }
+        }
+    }
+    // Auto-generate reverse HasMany/HasOne for any child schema that declares a
+    // ManyToOne/OneToOne pointing at this schema, unless the user has already
+    // declared a relation method with the same name. Issue #39.
+    const inverseRelations = buildInverseRelations(schemaName, modelNamespace, reader, declaredMethods, explicitInverses);
+    if (inverseRelations) {
+        methods.push(inverseRelations);
+    }
+    return methods.join('\n');
+}
+/**
+ * Discover child schemas that point at `parentName` via ManyToOne/OneToOne and
+ * generate the corresponding HasMany/HasOne accessor on the parent. Skips any
+ * inverse relation whose derived method name collides with a user-declared
+ * relation. Issue #39.
+ */
+function buildInverseRelations(parentName, modelNamespace, reader, declaredMethods, explicitInverses) {
+    const methods = [];
+    const allSchemas = reader.getSchemas();
+    // Stable iteration order — sort child names so output is deterministic
+    // regardless of how schemas were loaded into the map.
+    const childNames = Object.keys(allSchemas).sort();
+    for (const childName of childNames) {
+        if (childName === parentName)
+            continue;
+        const childSchema = allSchemas[childName];
+        if (!childSchema)
+            continue;
+        const childProps = (childSchema.properties ?? {});
+        for (const [childPropName, childProp] of Object.entries(childProps)) {
+            if (childProp['type'] !== 'Association')
+                continue;
+            const relation = childProp['relation'] ?? '';
+            if (relation !== 'ManyToOne' && relation !== 'OneToOne')
+                continue;
+            if (childProp['target'] !== parentName)
+                continue;
+            // Skip when an explicit OneToMany/HasOne on the parent already covers
+            // this child relation (matched by `<childSchema>.<childPropName>`).
+            if (explicitInverses.has(`${childName}.${childPropName}`))
+                continue;
+            const isOneToOne = relation === 'OneToOne';
+            const methodName = isOneToOne
+                ? toCamelCase(childName)
+                : toCamelCase(pluralize(childName));
+            if (declaredMethods.has(methodName))
+                continue;
+            declaredMethods.add(methodName);
+            // OneToOne with mappedBy is the reverse side already — skip; it would
+            // generate a child-side accessor, not a parent-side one.
+            // Here we're emitting the *parent* accessor, so the child's ManyToOne
+            // (or owning OneToOne) is what we react to.
+            const fkColumn = `${toSnakeCase(childPropName)}_id`;
+            const childNs = reader.resolveModelNamespace(childName, modelNamespace);
+            const fqcn = `\\${childNs}\\${childName}`;
+            const returnType = isOneToOne ? 'HasOne' : 'HasMany';
+            const eloquentMethod = isOneToOne ? 'hasOne' : 'hasMany';
+            methods.push(`
+    /**
+     * Auto-generated inverse of ${childName}.${childPropName} (${relation}).
+     */
+    public function ${methodName}(): ${returnType}
+    {
+        return $this->${eloquentMethod}(${fqcn}::class, '${fkColumn}');
+    }`);
         }
     }
     return methods.join('\n');
@@ -599,12 +677,12 @@ function buildNestedSetParentIdMethod(parentColumn) {
 function buildAuditSection(options, reader, modelNamespace) {
     const opts = options;
     const audit = opts?.['audit'];
-    if (!audit)
-        return '';
-    const hasCreatedBy = audit['createdBy'] ?? false;
-    const hasUpdatedBy = audit['updatedBy'] ?? false;
-    const hasDeletedBy = audit['deletedBy'] ?? false;
-    if (!hasCreatedBy && !hasUpdatedBy && !hasDeletedBy)
+    const defaultOrder = opts?.['defaultOrder'];
+    const hasCreatedBy = audit?.['createdBy'] ?? false;
+    const hasUpdatedBy = audit?.['updatedBy'] ?? false;
+    const hasDeletedBy = audit?.['deletedBy'] ?? false;
+    const hasDefaultOrder = Array.isArray(defaultOrder) && defaultOrder.length > 0;
+    if (!hasCreatedBy && !hasUpdatedBy && !hasDeletedBy && !hasDefaultOrder)
         return '';
     // Get audit model name from schemas.json auditConfig
     const auditModel = reader.data?.auditConfig?.model ?? 'User';
@@ -612,6 +690,17 @@ function buildAuditSection(options, reader, modelNamespace) {
     const parts = [];
     // Model events (booted)
     const events = [];
+    // defaultOrder global scope (issue #40 phase 2). Bypass with
+    // ->withoutGlobalScope('defaultOrder') in queries that need a different sort.
+    if (hasDefaultOrder) {
+        const chain = defaultOrder
+            .map(o => `                ->orderBy('${o.column}', '${(o.direction ?? 'asc').toLowerCase()}')`)
+            .join('\n');
+        events.push(`        static::addGlobalScope('defaultOrder', function ($query) {
+            $query
+${chain};
+        });`);
+    }
     if (hasCreatedBy) {
         events.push(`        static::creating(function ($model) {
             if (auth()->check() && !$model->created_by_id) {

package/ts-dist/php/relation-builder.d.ts

@@ -15,4 +15,9 @@ export declare function buildRelation(propName: string, property: Record<string,
 export declare function generatePivotTableName(sourceTable: string, targetTable: string): string;
 /** Get the return type hint for a relation. */
 export declare function getReturnType(relation: string): string;
+/**
+ * Build a chained `->orderBy('col', 'dir')` PHP fragment from an OrderByList.
+ * Returns an empty string if no ordering is configured. Issue #40.
+ */
+export declare function formatOrderByChain(orderBy: unknown): string;
 export {};

package/ts-dist/php/relation-builder.js

@@ -95,14 +95,33 @@ function hasMany(propName, property, target, ns) {
     const foreignKey = inverse ? `${toSnakeCase(inverse)}_id` : `${toSnakeCase(propName)}_id`;
     const methodName = toCamelCase(propName);
     const fqcn = `\\${ns}\\${target}`;
+    const orderChain = formatOrderByChain(property['orderBy']);
     return `    /**
      * Get the ${propName} for this model.
      */
     public function ${methodName}(): HasMany
     {
-        return $this->hasMany(${fqcn}::class, '${foreignKey}');
+        return $this->hasMany(${fqcn}::class, '${foreignKey}')${orderChain};
     }`;
 }
+/**
+ * Build a chained `->orderBy('col', 'dir')` PHP fragment from an OrderByList.
+ * Returns an empty string if no ordering is configured. Issue #40.
+ */
+export function formatOrderByChain(orderBy) {
+    if (!Array.isArray(orderBy) || orderBy.length === 0)
+        return '';
+    return orderBy
+        .map(item => {
+        const col = item.column ?? '';
+        if (!col)
+            return '';
+        const dir = (item.direction ?? 'asc').toLowerCase();
+        return `\n            ->orderBy('${col}', '${dir}')`;
+    })
+        .filter(Boolean)
+        .join('');
+}
 function belongsToMany(propName, property, target, ns, context) {
     let joinTable = property['joinTable'] ?? '';
     if (!joinTable && context?.sourceTableName && context?.targetTableName) {
@@ -118,6 +137,7 @@ function belongsToMany(propName, property, target, ns, context) {
         chain += `\n            ->withPivot(${fields})`;
     }
     chain += `\n            ->withTimestamps()`;
+    chain += formatOrderByChain(property['orderBy']);
     return `    /**
      * The ${propName} that belong to this model.
      */
@@ -153,12 +173,13 @@ function morphMany(propName, property, target, ns) {
     const morphName = property['morphName'] ?? toSnakeCase(propName);
     const methodName = toCamelCase(propName);
     const fqcn = `\\${ns}\\${target}`;
+    const orderChain = formatOrderByChain(property['orderBy']);
     return `    /**
      * Get the ${propName} for this model.
      */
     public function ${methodName}(): MorphMany
     {
-        return $this->morphMany(${fqcn}::class, '${morphName}');
+        return $this->morphMany(${fqcn}::class, '${morphName}')${orderChain};
     }`;
 }
 function morphToMany(propName, property, target, ns, context) {

package/ts-dist/types.d.ts

@@ -123,6 +123,8 @@ export interface SchemaOptions {
         readonly updatedBy?: boolean;
         readonly deletedBy?: boolean;
     };
+    /** Schema-level default ordering — generates a global Eloquent scope. Issue #40. */
+    readonly defaultOrder?: readonly OrderByItem[];
 }
 /** Schema definition from schemas.json. */
 export interface SchemaDefinition {
@@ -233,12 +235,18 @@ export interface PropertyDefinition {
     readonly morphName?: string;
     readonly joinTable?: string;
     readonly mappedBy?: string;
+    readonly orderBy?: readonly OrderByItem[];
     readonly useCurrent?: boolean;
     readonly searchable?: boolean;
     readonly filterable?: boolean;
     readonly sortable?: boolean;
     readonly fields?: Record<string, FieldOverride>;
 }
+/** Single column ordering. Direction defaults to 'asc'. Issue #40. */
+export interface OrderByItem {
+    readonly column: string;
+    readonly direction?: string;
+}
 /** Field override for compound type properties. */
 export interface FieldOverride {
     readonly nullable?: boolean;