@omnifyjp/ts 0.4.1 → 1.0.0

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

@@ -7,9 +7,9 @@ import { baseFile } from './types.js';
 export function generateBaseModel(reader, config) {
     const baseNamespace = config.models.baseNamespace;
     const modelNamespace = config.models.namespace;
-    // Build morph map entries from all visible object schemas
+    // Build morph map entries from project-owned visible object schemas
     const morphMap = {};
-    for (const name of Object.keys(reader.getVisibleObjectSchemas())) {
+    for (const name of Object.keys(reader.getProjectVisibleObjectSchemas())) {
         const modelName = toPascalCase(name);
         morphMap[modelName] = `\\${modelNamespace}\\${modelName}::class`;
     }

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

@@ -3,5 +3,5 @@
  */
 import { SchemaReader } from './schema-reader.js';
 import type { GeneratedFile, PhpConfig } from './types.js';
-/** Generate Factory classes for all visible object schemas. */
+/** Generate Factory classes for all project-owned visible object schemas. */
 export declare function generateFactories(reader: SchemaReader, config: PhpConfig): GeneratedFile[];

package/dist/php/factory-generator.js

@@ -4,11 +4,11 @@
 import { toPascalCase } from './naming-helper.js';
 import { toFaker, compoundFaker, associationFaker } from './faker-mapper.js';
 import { userFile } from './types.js';
-/** Generate Factory classes for all visible object schemas. */
+/** Generate Factory classes for all project-owned visible object schemas. */
 export function generateFactories(reader, config) {
     const files = [];
     const schemas = reader.getSchemas();
-    for (const [name, schema] of Object.entries(reader.getVisibleObjectSchemas())) {
+    for (const [name, schema] of Object.entries(reader.getProjectVisibleObjectSchemas())) {
         const file = generateFactory(name, schema, reader, schemas, config);
         if (file)
             files.push(file);
@@ -31,7 +31,10 @@ function generateFactory(name, schema, reader, schemas, config) {
         const type = prop['type'] ?? 'String';
         // Handle associations (foreign keys)
         if (type === 'Association') {
-            const result = associationFaker(propName, prop, modelNamespace, name);
+            // Resolve namespace per-target (package schemas use their own model namespace)
+            const target = prop['target'] ?? '';
+            const targetNs = target ? reader.resolveModelNamespace(target, modelNamespace) : modelNamespace;
+            const result = associationFaker(propName, prop, targetNs, name);
             if (result) {
                 attributes.push(result.fake);
                 if (result.import)

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

@@ -3,5 +3,5 @@
  */
 import { SchemaReader } from './schema-reader.js';
 import type { GeneratedFile, PhpConfig } from './types.js';
-/** Generate Locales classes for all object schemas. */
+/** Generate Locales classes for all project-owned object schemas. */
 export declare function generateLocales(reader: SchemaReader, config: PhpConfig): GeneratedFile[];

package/dist/php/locales-generator.js

@@ -3,10 +3,10 @@
  */
 import { toPascalCase, toSnakeCase } from './naming-helper.js';
 import { baseFile } from './types.js';
-/** Generate Locales classes for all object schemas. */
+/** Generate Locales classes for all project-owned object schemas. */
 export function generateLocales(reader, config) {
     const files = [];
-    for (const [name, schema] of Object.entries(reader.getObjectSchemas())) {
+    for (const [name, schema] of Object.entries(reader.getProjectObjectSchemas())) {
         const file = generateLocalesClass(name, schema, reader, config);
         if (file)
             files.push(file);

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

@@ -3,5 +3,6 @@
  */
 import { SchemaReader } from './schema-reader.js';
 import type { GeneratedFile, PhpConfig } from './types.js';
-/** Generate base model and user model for all object schemas. */
+/** Generate base model and user model for all project-owned object schemas,
+ *  plus user models for package schemas (extending the package model). */
 export declare function generateModels(reader: SchemaReader, config: PhpConfig): GeneratedFile[];

package/dist/php/model-generator.js

@@ -5,12 +5,21 @@ import { toPascalCase, toSnakeCase } from './naming-helper.js';
 import { toCast, toPhpDocType, isHiddenByDefault } from './type-mapper.js';
 import { buildRelation } from './relation-builder.js';
 import { baseFile, userFile } from './types.js';
-/** Generate base model and user model for all object schemas. */
+/** Generate base model and user model for all project-owned object schemas,
+ *  plus user models for package schemas (extending the package model). */
 export function generateModels(reader, config) {
     const files = [];
-    for (const [name, schema] of Object.entries(reader.getObjectSchemas())) {
+    // Project-owned schemas: base model + user model
+    for (const [name, schema] of Object.entries(reader.getProjectObjectSchemas())) {
         files.push(...generateForSchema(name, schema, reader, config));
     }
+    // Package schemas: user model only (extends package model)
+    for (const [name, schema] of Object.entries(reader.getPackageObjectSchemas())) {
+        const pkgNs = reader.resolveModelNamespace(name, config.models.namespace);
+        if (pkgNs !== config.models.namespace) {
+            files.push(generatePackageUserModel(name, pkgNs, config));
+        }
+    }
     return files;
 }
 function generateForSchema(name, schema, reader, config) {
@@ -39,7 +48,7 @@ function generateBaseModel(name, schema, reader, config) {
     const hidden = buildHidden(properties, expandedProperties, propertyOrder);
     const appends = buildAppends(expandedProperties);
     const casts = buildCasts(properties, expandedProperties, propertyOrder);
-    const relations = buildRelations(properties, propertyOrder, modelNamespace);
+    const relations = buildRelations(properties, propertyOrder, modelNamespace, reader);
     const accessors = buildAccessors(expandedProperties);
     const primaryKey = options['primaryKey'] ?? 'id';
     const rawId = options.id;
@@ -345,13 +354,16 @@ function buildCasts(properties, expandedProperties, propertyOrder) {
         return '';
     return casts.map(c => `            ${c}`).join('\n') + '\n';
 }
-function buildRelations(properties, propertyOrder, modelNamespace) {
+function buildRelations(properties, propertyOrder, modelNamespace, reader) {
     const methods = [];
     for (const propName of propertyOrder) {
         const prop = properties[propName];
         if (!prop || prop['type'] !== 'Association')
             continue;
-        const result = buildRelation(propName, prop, modelNamespace);
+        // Resolve namespace per-target (package schemas use their own namespace)
+        const target = prop['target'] ?? '';
+        const ns = target ? reader.resolveModelNamespace(target, modelNamespace) : modelNamespace;
+        const result = buildRelation(propName, prop, ns);
         if (result) {
             methods.push('\n' + result.method);
         }
@@ -381,6 +393,30 @@ function buildAccessors(expandedProperties) {
     }
     return methods.join('\n');
 }
+/** Generate a user model for a package schema that extends the package's model class. */
+function generatePackageUserModel(name, packageNamespace, config) {
+    const modelName = toPascalCase(name);
+    const modelNamespace = config.models.namespace;
+    const packageModelClass = `${packageNamespace}\\${modelName}`;
+    const content = `<?php
+
+namespace ${modelNamespace};
+
+use ${packageModelClass} as Package${modelName};
+
+/**
+ * ${modelName} Model (extends package model)
+ *
+ * This file is generated once and can be customized.
+ * Add your project-specific methods and relations here.
+ */
+class ${modelName} extends Package${modelName}
+{
+    // Add your custom methods here
+}
+`;
+    return userFile(`${config.models.path}/${modelName}.php`, content);
+}
 function fullNameAccessor(prefix, suffix, fields, separator) {
     const methodName = 'get' + toPascalCase(prefix) + suffix + 'Attribute';
     const fieldAccess = fields.map(f => `$this->${f}`).join(', ');

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

@@ -3,5 +3,5 @@
  */
 import { SchemaReader } from './schema-reader.js';
 import type { GeneratedFile, PhpConfig } from './types.js';
-/** Generate Store/Update request classes for all visible object schemas. */
+/** Generate Store/Update request classes for all project-owned visible object schemas. */
 export declare function generateRequests(reader: SchemaReader, config: PhpConfig): GeneratedFile[];

package/dist/php/request-generator.js

@@ -4,10 +4,10 @@
 import { toPascalCase, toSnakeCase, toCamelCase } from './naming-helper.js';
 import { toStoreRules, toUpdateRules, formatRules, hasRuleObject } from './type-mapper.js';
 import { baseFile, userFile } from './types.js';
-/** Generate Store/Update request classes for all visible object schemas. */
+/** Generate Store/Update request classes for all project-owned visible object schemas. */
 export function generateRequests(reader, config) {
     const files = [];
-    for (const [name, schema] of Object.entries(reader.getVisibleObjectSchemas())) {
+    for (const [name, schema] of Object.entries(reader.getProjectVisibleObjectSchemas())) {
         files.push(...generateForSchema(name, schema, reader, config));
     }
     return files;

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

@@ -3,5 +3,5 @@
  */
 import { SchemaReader } from './schema-reader.js';
 import type { GeneratedFile, PhpConfig } from './types.js';
-/** Generate Resource classes for all visible object schemas. */
+/** Generate Resource classes for all project-owned visible object schemas. */
 export declare function generateResources(reader: SchemaReader, config: PhpConfig): GeneratedFile[];

package/dist/php/resource-generator.js

@@ -4,10 +4,10 @@
 import { toPascalCase, toSnakeCase, toCamelCase } from './naming-helper.js';
 import { isHiddenByDefault, toResourceExpression } from './type-mapper.js';
 import { baseFile, userFile } from './types.js';
-/** Generate Resource classes for all visible object schemas. */
+/** Generate Resource classes for all project-owned visible object schemas. */
 export function generateResources(reader, config) {
     const files = [];
-    for (const [name, schema] of Object.entries(reader.getVisibleObjectSchemas())) {
+    for (const [name, schema] of Object.entries(reader.getProjectVisibleObjectSchemas())) {
         files.push(generateBaseResource(name, schema, reader, config));
         files.push(generateUserResource(name, config));
     }
@@ -38,7 +38,7 @@ function generateBaseResource(name, schema, reader, config) {
         if (isHiddenByDefault(type) || hidden)
             continue;
         if (type === 'Association') {
-            addAssociationFields(propName, prop, fields, resourceNamespace, modelNamespace);
+            addAssociationFields(propName, prop, fields, resourceNamespace, modelNamespace, reader);
             continue;
         }
         if (expandedProperties[propName]) {
@@ -150,26 +150,37 @@ class ${modelName}Resource extends ${modelName}ResourceBase
 `;
     return userFile(`${config.resources.path}/${modelName}Resource.php`, content);
 }
-function addAssociationFields(propName, prop, fields, resourceNamespace, modelNamespace) {
+function addAssociationFields(propName, prop, fields, resourceNamespace, modelNamespace, reader) {
     const relation = prop['relation'] ?? '';
     const target = prop['target'] ?? '';
     const methodName = toCamelCase(propName);
+    // Resolve resource namespace for the target (null if package without resource ns)
+    const targetResNs = target ? reader.resolveResourceNamespace(target, resourceNamespace) : resourceNamespace;
+    // If target is a package schema without a resource namespace, use simple whenLoaded
+    if (!targetResNs && relation !== 'MorphTo') {
+        if (relation === 'ManyToOne') {
+            const snakeName = toSnakeCase(propName) + '_id';
+            fields.push(`            '${snakeName}' => $this->${snakeName},`);
+        }
+        fields.push(`            '${methodName}' => $this->whenLoaded('${methodName}'),`);
+        return;
+    }
     const targetResource = toPascalCase(target) + 'Resource';
     switch (relation) {
         case 'ManyToOne': {
             const snakeName = toSnakeCase(propName) + '_id';
             fields.push(`            '${snakeName}' => $this->${snakeName},`);
-            fields.push(`            '${methodName}' => $this->whenLoaded('${methodName}', fn() => new \\${resourceNamespace}\\${targetResource}($this->${methodName})),`);
+            fields.push(`            '${methodName}' => $this->whenLoaded('${methodName}', fn() => new \\${targetResNs}\\${targetResource}($this->${methodName})),`);
             break;
         }
         case 'OneToMany':
         case 'ManyToMany':
         case 'MorphMany':
-            fields.push(`            '${methodName}' => $this->whenLoaded('${methodName}', fn() => \\${resourceNamespace}\\${targetResource}::collection($this->${methodName})),`);
+            fields.push(`            '${methodName}' => $this->whenLoaded('${methodName}', fn() => \\${targetResNs}\\${targetResource}::collection($this->${methodName})),`);
             break;
         case 'OneToOne':
         case 'MorphOne':
-            fields.push(`            '${methodName}' => $this->whenLoaded('${methodName}', fn() => new \\${resourceNamespace}\\${targetResource}($this->${methodName})),`);
+            fields.push(`            '${methodName}' => $this->whenLoaded('${methodName}', fn() => new \\${targetResNs}\\${targetResource}($this->${methodName})),`);
             break;
         case 'MorphTo':
             fields.push(`            '${methodName}' => $this->whenLoaded('${methodName}'),`);

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

@@ -1,7 +1,7 @@
 /**
  * Port of SchemaReader.php — reads schemas.json data.
  */
-import type { SchemasJson, SchemaDefinition, ExpandedProperty } from '../types.js';
+import type { SchemasJson, SchemaDefinition, ExpandedProperty, PackageExportInfo } from '../types.js';
 export declare class SchemaReader {
     private data;
     constructor(data: SchemasJson);
@@ -11,6 +11,28 @@ export declare class SchemaReader {
     getObjectSchemas(): Record<string, SchemaDefinition>;
     getVisibleObjectSchemas(): Record<string, SchemaDefinition>;
     getEnumSchemas(): Record<string, SchemaDefinition>;
+    /** Check if a schema belongs to a package. */
+    isPackageSchema(name: string): boolean;
+    /** Object schemas owned by the project (not from packages). */
+    getProjectObjectSchemas(): Record<string, SchemaDefinition>;
+    /** Object schemas from packages (not project-owned). */
+    getPackageObjectSchemas(): Record<string, SchemaDefinition>;
+    /** Visible object schemas owned by the project. */
+    getProjectVisibleObjectSchemas(): Record<string, SchemaDefinition>;
+    /** Get the top-level packages map. */
+    getPackages(): Record<string, PackageExportInfo>;
+    /**
+     * Resolve the model namespace for a target schema.
+     * - Project schema → uses the project's model namespace
+     * - Package schema → uses the package's codegen.laravel.model.namespace (if set)
+     */
+    resolveModelNamespace(targetName: string, projectModelNamespace: string): string;
+    /**
+     * Resolve the resource namespace for a target schema.
+     * Returns null if the target is a package schema without a resource namespace
+     * (meaning no resource class exists for it in the project).
+     */
+    resolveResourceNamespace(targetName: string, projectResourceNamespace: string): string | null;
     getCompoundTypes(): Record<string, unknown>;
     getSimpleTypes(): Record<string, unknown>;
     getCustomEnums(): Record<string, string[]>;

package/dist/php/schema-reader.js

@@ -9,6 +9,9 @@ export class SchemaReader {
     static fromData(data) {
         return new SchemaReader(data);
     }
+    // ---------------------------------------------------------------------------
+    // All schemas (project + package)
+    // ---------------------------------------------------------------------------
     getSchemas() {
         return this.data.schemas ?? {};
     }
@@ -43,6 +46,85 @@ export class SchemaReader {
         }
         return result;
     }
+    // ---------------------------------------------------------------------------
+    // Project-only schemas (package === null or undefined)
+    // ---------------------------------------------------------------------------
+    /** Check if a schema belongs to a package. */
+    isPackageSchema(name) {
+        const schema = this.getSchema(name);
+        return schema?.package != null;
+    }
+    /** Object schemas owned by the project (not from packages). */
+    getProjectObjectSchemas() {
+        const result = {};
+        for (const [name, schema] of Object.entries(this.getObjectSchemas())) {
+            if (schema.package == null) {
+                result[name] = schema;
+            }
+        }
+        return result;
+    }
+    /** Object schemas from packages (not project-owned). */
+    getPackageObjectSchemas() {
+        const result = {};
+        for (const [name, schema] of Object.entries(this.getObjectSchemas())) {
+            if (schema.package != null) {
+                result[name] = schema;
+            }
+        }
+        return result;
+    }
+    /** Visible object schemas owned by the project. */
+    getProjectVisibleObjectSchemas() {
+        const result = {};
+        for (const [name, schema] of Object.entries(this.getProjectObjectSchemas())) {
+            if (!schema.options?.hidden) {
+                result[name] = schema;
+            }
+        }
+        return result;
+    }
+    // ---------------------------------------------------------------------------
+    // Packages
+    // ---------------------------------------------------------------------------
+    /** Get the top-level packages map. */
+    getPackages() {
+        return this.data.packages ?? {};
+    }
+    /**
+     * Resolve the model namespace for a target schema.
+     * - Project schema → uses the project's model namespace
+     * - Package schema → uses the package's codegen.laravel.model.namespace (if set)
+     */
+    resolveModelNamespace(targetName, projectModelNamespace) {
+        const target = this.getSchema(targetName);
+        if (target?.package) {
+            const pkg = this.getPackages()[target.package];
+            const pkgNs = pkg?.codegen?.laravel?.model?.namespace;
+            if (pkgNs)
+                return pkgNs;
+        }
+        return projectModelNamespace;
+    }
+    /**
+     * Resolve the resource namespace for a target schema.
+     * Returns null if the target is a package schema without a resource namespace
+     * (meaning no resource class exists for it in the project).
+     */
+    resolveResourceNamespace(targetName, projectResourceNamespace) {
+        const target = this.getSchema(targetName);
+        if (target?.package) {
+            const pkg = this.getPackages()[target.package];
+            const pkgNs = pkg?.codegen?.laravel?.resource?.namespace;
+            if (pkgNs)
+                return pkgNs;
+            return null; // no resource namespace → no resource class
+        }
+        return projectResourceNamespace;
+    }
+    // ---------------------------------------------------------------------------
+    // Property helpers
+    // ---------------------------------------------------------------------------
     getCompoundTypes() {
         return this.data.customTypes?.compound ?? {};
     }

package/dist/php/service-provider-generator.js

@@ -6,9 +6,9 @@ import { baseFile } from './types.js';
 /** Generate the OmnifyServiceProvider for the application. */
 export function generateServiceProvider(reader, config) {
     const modelNamespace = config.models.namespace;
-    // Build morph map entries
+    // Build morph map entries (project-owned schemas only)
     const morphEntries = [];
-    for (const name of Object.keys(reader.getVisibleObjectSchemas())) {
+    for (const name of Object.keys(reader.getProjectVisibleObjectSchemas())) {
         const modelName = toPascalCase(name);
         morphEntries.push(`            '${modelName}' => \\${modelNamespace}\\${modelName}::class,`);
     }

package/dist/types.d.ts

@@ -22,8 +22,33 @@ export interface SchemasJson {
         readonly simple: Record<string, SimpleTypeDefinition>;
         readonly enums: Record<string, string[]>;
     };
+    readonly packages?: Record<string, PackageExportInfo>;
     readonly schemas: Record<string, SchemaDefinition>;
 }
+/** Package metadata in schemas.json (codegen namespace references). */
+export interface PackageExportInfo {
+    readonly codegen?: PackageCodegenExport;
+}
+/** Codegen namespace info from a package. */
+export interface PackageCodegenExport {
+    readonly laravel?: {
+        readonly model?: {
+            readonly namespace?: string;
+        };
+        readonly request?: {
+            readonly namespace?: string;
+        };
+        readonly resource?: {
+            readonly namespace?: string;
+        };
+        readonly factory?: {
+            readonly namespace?: string;
+        };
+    };
+    readonly typescript?: {
+        readonly modelsPath?: string;
+    };
+}
 /** Compound type definition (e.g., JapaneseName). */
 export interface CompoundTypeDefinition {
     readonly fields: readonly CompoundField[];
@@ -68,6 +93,7 @@ export interface SchemaOptions {
 /** Schema definition from schemas.json. */
 export interface SchemaDefinition {
     readonly name: string;
+    readonly package?: string | null;
     readonly tableName?: string;
     readonly connection?: string;
     readonly displayName?: LocalizedString;

package/package.json

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