@omnifyjp/ts 1.2.6 → 1.3.1

package/dist/cli.js

@@ -53,6 +53,7 @@ function resolveFromConfig(configPath) {
         factory: laravelConfig?.factory,
         provider: laravelConfig?.provider,
         policy: laravelConfig?.policy,
+        nestedset: laravelConfig?.nestedset,
     } : undefined;
     return {
         input: resolve(configDir, schemasPath),

package/dist/php/model-generator.js

@@ -23,9 +23,12 @@ export function generateModels(reader, config) {
     return files;
 }
 function generateForSchema(name, schema, reader, config) {
+    const properties = (schema.properties ?? {});
+    const options = schema.options ?? {};
+    const hasNestedSet = detectNestedSet(options, properties);
     return [
         generateBaseModel(name, schema, reader, config),
-        generateUserModel(name, config),
+        generateUserModel(name, config, hasNestedSet),
     ];
 }
 function generateBaseModel(name, schema, reader, config) {
@@ -40,6 +43,9 @@ function generateBaseModel(name, schema, reader, config) {
     const isAuthenticatable = options['authenticatable'] ?? false;
     const hasSoftDelete = options.softDelete ?? false;
     const hasTimestamps = options.timestamps ?? false;
+    // NodeTrait is added to the user-editable Model, not BaseModel
+    const hasNestedSet = false;
+    const nestedSetParentColumn = null;
     const translatableFields = reader.getTranslatableFields(name);
     const hasTranslatable = translatableFields.length > 0;
     const primaryKey = options['primaryKey'] ?? 'id';
@@ -48,17 +54,18 @@ function generateBaseModel(name, schema, reader, config) {
     const isCompositeKey = primaryKey.includes(',');
     const needsUuidTrait = !isCompositeKey && idType === 'Uuid';
     const needsUlidTrait = !isCompositeKey && idType === 'Ulid';
-    const imports = buildImports(baseNamespace, modelName, hasSoftDelete, isAuthenticatable, hasTranslatable, properties, needsUuidTrait, needsUlidTrait);
+    const imports = buildImports(baseNamespace, modelName, hasSoftDelete, isAuthenticatable, hasTranslatable, properties, needsUuidTrait, needsUlidTrait, hasNestedSet, config.nestedset.namespace);
     const docProperties = buildDocProperties(properties, expandedProperties, propertyOrder);
     const baseClass = isAuthenticatable ? 'Authenticatable' : 'BaseModel';
     const implementsClause = hasTranslatable ? ' implements TranslatableContract' : '';
-    const traits = buildTraits(hasSoftDelete, isAuthenticatable, hasTranslatable, needsUuidTrait, needsUlidTrait);
+    const traits = buildTraits(hasSoftDelete, isAuthenticatable, hasTranslatable, needsUuidTrait, needsUlidTrait, hasNestedSet);
     const fillable = buildFillable(properties, expandedProperties, propertyOrder);
     const hidden = buildHidden(properties, expandedProperties, propertyOrder);
     const appends = buildAppends(expandedProperties);
     const casts = buildCasts(properties, expandedProperties, propertyOrder);
     const relations = buildRelations(name, properties, propertyOrder, modelNamespace, reader);
     const accessors = buildAccessors(expandedProperties);
+    const nestedSetMethod = buildNestedSetParentIdMethod(nestedSetParentColumn);
     let keyTypeSection = '';
     if (idType === 'Uuid' || idType === 'Ulid' || idType === 'String') {
         keyTypeSection = `
@@ -155,16 +162,29 @@ ${appends}    ];
         return [
 ${casts}        ];
     }
-${relations}${accessors}
+${relations}${accessors}${nestedSetMethod}
 }
 `;
     return baseFile(`${config.models.basePath}/${modelName}BaseModel.php`, content);
 }
-function generateUserModel(name, config) {
+function generateUserModel(name, config, hasNestedSet = false) {
     const modelName = toPascalCase(name);
     const modelNamespace = config.models.namespace;
     const baseNamespace = config.models.baseNamespace;
     const factoryNamespace = config.factories.namespace;
+    const nestedSetNamespace = config.nestedset.namespace;
+    const imports = [
+        `use ${baseNamespace}\\${modelName}BaseModel;`,
+        `use ${factoryNamespace}\\${modelName}Factory;`,
+        `use Illuminate\\Database\\Eloquent\\Factories\\HasFactory;`,
+    ];
+    if (hasNestedSet) {
+        imports.push(`use ${nestedSetNamespace}\\NodeTrait;`);
+    }
+    const traits = ['    use HasFactory;'];
+    if (hasNestedSet) {
+        traits.push('    use NodeTrait;');
+    }
     const content = `<?php
 
 /**
@@ -175,16 +195,14 @@ function generateUserModel(name, config) {
 
 namespace ${modelNamespace};
 
-use ${baseNamespace}\\${modelName}BaseModel;
-use ${factoryNamespace}\\${modelName}Factory;
-use Illuminate\\Database\\Eloquent\\Factories\\HasFactory;
+${imports.join('\n')}
 
 /**
  * ${modelName} — add project-specific model logic here.
  */
 class ${modelName} extends ${modelName}BaseModel
 {
-    use HasFactory;
+${traits.join('\n')}
 
     /**
      * Create a new factory instance for the model.
@@ -199,7 +217,7 @@ class ${modelName} extends ${modelName}BaseModel
 `;
     return userFile(`${config.models.path}/${modelName}.php`, content);
 }
-function buildImports(baseNamespace, modelName, hasSoftDelete, isAuthenticatable, hasTranslatable, properties, needsUuidTrait = false, needsUlidTrait = false) {
+function buildImports(baseNamespace, modelName, hasSoftDelete, isAuthenticatable, hasTranslatable, properties, needsUuidTrait = false, needsUlidTrait = false, hasNestedSet = false, nestedSetNamespace = 'Aimeos\\Nestedset') {
     const lines = [];
     if (isAuthenticatable) {
         lines.push('use Illuminate\\Foundation\\Auth\\User as Authenticatable;');
@@ -222,6 +240,9 @@ function buildImports(baseNamespace, modelName, hasSoftDelete, isAuthenticatable
     if (hasSoftDelete) {
         lines.push('use Illuminate\\Database\\Eloquent\\SoftDeletes;');
     }
+    if (hasNestedSet) {
+        lines.push(`use ${nestedSetNamespace}\\NodeTrait;`);
+    }
     if (hasTranslatable) {
         lines.push('use Astrotomic\\Translatable\\Contracts\\Translatable as TranslatableContract;');
         lines.push('use Astrotomic\\Translatable\\Translatable;');
@@ -262,7 +283,7 @@ function buildDocProperties(properties, expandedProperties, propertyOrder) {
     }
     return lines.length === 0 ? '' : lines.join('\n') + '\n';
 }
-function buildTraits(hasSoftDelete, isAuthenticatable, hasTranslatable, needsUuidTrait = false, needsUlidTrait = false) {
+function buildTraits(hasSoftDelete, isAuthenticatable, hasTranslatable, needsUuidTrait = false, needsUlidTrait = false, hasNestedSet = false) {
     const lines = [];
     lines.push('    use HasLocalizedDisplayName;');
     if (needsUuidTrait)
@@ -271,6 +292,8 @@ function buildTraits(hasSoftDelete, isAuthenticatable, hasTranslatable, needsUui
         lines.push('    use HasUlids;');
     if (isAuthenticatable)
         lines.push('    use Notifiable;');
+    if (hasNestedSet)
+        lines.push('    use NodeTrait;');
     if (hasSoftDelete)
         lines.push('    use SoftDeletes;');
     if (hasTranslatable)
@@ -455,6 +478,50 @@ class ${modelName} extends Package${modelName}
 `;
     return userFile(`${config.models.path}/${modelName}.php`, content);
 }
+/**
+ * Detect whether a schema uses nested set (tree structure).
+ * Checks both the explicit `nestedSet: true` option and the presence of
+ * nested set columns (_lft, _rgt, parent_id / _parent_id) in properties.
+ */
+function detectNestedSet(options, properties) {
+    if (options['nestedSet'] === true)
+        return true;
+    const propNames = Object.keys(properties);
+    const hasLft = propNames.some(p => p === '_lft' || p === 'lft');
+    const hasRgt = propNames.some(p => p === '_rgt' || p === 'rgt');
+    const hasParent = propNames.some(p => p === 'parent_id' || p === '_parent_id' || p === 'parentId' || p === 'parent');
+    return hasLft && hasRgt && hasParent;
+}
+/**
+ * Detect the parent ID column name for nested set models.
+ * Returns the column name if it differs from the default 'parent_id', or null.
+ */
+function detectNestedSetParentColumn(properties) {
+    const propNames = Object.keys(properties);
+    // Check for non-standard parent_id column names
+    if (propNames.includes('_parent_id'))
+        return '_parent_id';
+    if (propNames.includes('parent_id') || propNames.includes('parentId') || propNames.includes('parent'))
+        return null;
+    return null;
+}
+/**
+ * Build the getParentIdName() method override for nested set models
+ * that use a non-standard parent_id column name.
+ */
+function buildNestedSetParentIdMethod(parentColumn) {
+    if (!parentColumn)
+        return '';
+    return `
+    /**
+     * Get the column name for the parent ID.
+     */
+    public function getParentIdName(): string
+    {
+        return '${parentColumn}';
+    }
+`;
+}
 function fullNameAccessor(prefix, suffix, fields, separator) {
     const methodName = 'get' + toPascalCase(prefix) + suffix + 'Attribute';
     const fieldAccess = fields.map(f => `$this->${f}`).join(', ');

package/dist/php/types.d.ts

@@ -17,6 +17,10 @@ export interface LaravelPathOverride {
     path?: string;
     namespace?: string;
 }
+/** Nested set package configuration. */
+export interface NestedSetOverride {
+    namespace?: string;
+}
 /** Overrides from codegen.laravel YAML config (all optional). */
 export interface LaravelCodegenOverrides {
     model?: LaravelPathOverride;
@@ -25,6 +29,7 @@ export interface LaravelCodegenOverrides {
     factory?: LaravelPathOverride;
     provider?: LaravelPathOverride;
     policy?: LaravelPathOverride;
+    nestedset?: NestedSetOverride;
 }
 /** PHP codegen configuration (resolved with defaults). */
 export interface PhpConfig {
@@ -60,6 +65,9 @@ export interface PhpConfig {
         path: string;
         basePath: string;
     };
+    nestedset: {
+        namespace: string;
+    };
 }
 /**
  * Derive full PHP config from optional overrides.

package/dist/php/types.js

@@ -40,6 +40,7 @@ export function derivePhpConfig(overrides) {
     const providerNs = overrides?.provider?.namespace ?? pathToNamespace(providerPath);
     const policyPath = overrides?.policy?.path ?? DEFAULT_POLICY_PATH;
     const policyNs = overrides?.policy?.namespace ?? pathToNamespace(policyPath);
+    const nestedsetNs = overrides?.nestedset?.namespace ?? 'Aimeos\\Nestedset';
     return {
         models: {
             namespace: modelNs,
@@ -73,5 +74,8 @@ export function derivePhpConfig(overrides) {
             path: policyPath,
             basePath: `${policyPath}/Base`,
         },
+        nestedset: {
+            namespace: nestedsetNs,
+        },
     };
 }

package/dist/types.d.ts

@@ -87,6 +87,7 @@ export interface SchemaOptions {
     readonly timestamps?: boolean;
     readonly softDelete?: boolean;
     readonly hidden?: boolean;
+    readonly nestedSet?: boolean;
     readonly tableName?: string;
     readonly indexes?: readonly unknown[];
     readonly unique?: readonly unknown[];

package/package.json

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