@omnifyjp/ts 0.4.2 → 1.0.1

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(name, properties, propertyOrder, modelNamespace, reader);
     const accessors = buildAccessors(expandedProperties);
     const primaryKey = options['primaryKey'] ?? 'id';
     const rawId = options.id;
@@ -345,13 +354,18 @@ function buildCasts(properties, expandedProperties, propertyOrder) {
         return '';
     return casts.map(c => `            ${c}`).join('\n') + '\n';
 }
-function buildRelations(properties, propertyOrder, modelNamespace) {
+function buildRelations(schemaName, properties, propertyOrder, modelNamespace, reader) {
     const methods = [];
+    const sourceTableName = reader.getTableName(schemaName);
     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 targetTableName = target ? reader.getTableName(target) : '';
+        const result = buildRelation(propName, prop, ns, { sourceTableName, targetTableName });
         if (result) {
             methods.push('\n' + result.method);
         }
@@ -381,6 +395,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/naming-helper.d.ts

@@ -12,6 +12,10 @@ export declare function toCamelCase(value: string): string;
  * Handles common cases: -y → -ies, -s/-sh/-ch/-x/-z → -es, default → -s
  */
 export declare function pluralize(value: string): string;
+/**
+ * Singularize a word (simple English rules — reverse of pluralize).
+ */
+export declare function singularize(value: string): string;
 /** Convert a schema name to a table name (snake_case + pluralized). */
 export declare function toTableName(schemaName: string): string;
 /**

package/dist/php/naming-helper.js

@@ -38,6 +38,30 @@ export function pluralize(value) {
     }
     return value + 's';
 }
+/**
+ * Singularize a word (simple English rules — reverse of pluralize).
+ */
+export function singularize(value) {
+    // Already singular or empty
+    if (!value || value.length <= 2)
+        return value;
+    if (value.endsWith('ies')) {
+        return value.slice(0, -3) + 'y';
+    }
+    if (value.endsWith('ves')) {
+        // knives → knife, leaves → leaf
+        const stem = value.slice(0, -3);
+        // Try -fe first (e.g., "knives" → "knife"), fallback to -f (e.g., "leaves" → "leaf")
+        return stem + 'f';
+    }
+    if (value.endsWith('ses') || value.endsWith('shes') || value.endsWith('ches') || value.endsWith('xes') || value.endsWith('zes')) {
+        return value.slice(0, -2);
+    }
+    if (value.endsWith('s') && !value.endsWith('ss')) {
+        return value.slice(0, -1);
+    }
+    return value;
+}
 /** Convert a schema name to a table name (snake_case + pluralized). */
 export function toTableName(schemaName) {
     return pluralize(toSnakeCase(schemaName));

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

@@ -5,8 +5,14 @@ interface RelationResult {
     method: string;
     imports: string[];
 }
+interface RelationContext {
+    sourceTableName: string;
+    targetTableName: string;
+}
 /** Build Eloquent relation method PHP code. */
-export declare function buildRelation(propName: string, property: Record<string, unknown>, modelNamespace: string): RelationResult | null;
+export declare function buildRelation(propName: string, property: Record<string, unknown>, modelNamespace: string, context?: RelationContext): RelationResult | null;
+/** Generate pivot table name matching Go's GeneratePivotTableName logic. */
+export declare function generatePivotTableName(sourceTable: string, targetTable: string): string;
 /** Get the return type hint for a relation. */
 export declare function getReturnType(relation: string): string;
 export {};

package/dist/php/relation-builder.js

@@ -1,9 +1,9 @@
 /**
  * Port of RelationBuilder.php — generates Eloquent relation methods.
  */
-import { toSnakeCase, toCamelCase } from './naming-helper.js';
+import { toSnakeCase, toCamelCase, singularize } from './naming-helper.js';
 /** Build Eloquent relation method PHP code. */
-export function buildRelation(propName, property, modelNamespace) {
+export function buildRelation(propName, property, modelNamespace, context) {
     const relation = property['relation'] ?? '';
     const target = property['target'] ?? '';
     const imports = [];
@@ -19,7 +19,7 @@ export function buildRelation(propName, property, modelNamespace) {
             method = hasMany(propName, property, target, modelNamespace);
             break;
         case 'ManyToMany':
-            method = belongsToMany(propName, property, target, modelNamespace);
+            method = belongsToMany(propName, property, target, modelNamespace, context);
             break;
         case 'MorphTo':
             method = morphTo(propName);
@@ -35,6 +35,11 @@ export function buildRelation(propName, property, modelNamespace) {
         return null;
     return { method, imports };
 }
+/** Generate pivot table name matching Go's GeneratePivotTableName logic. */
+export function generatePivotTableName(sourceTable, targetTable) {
+    const tables = [singularize(sourceTable), singularize(targetTable)].sort();
+    return tables.join('_');
+}
 /** Get the return type hint for a relation. */
 export function getReturnType(relation) {
     switch (relation) {
@@ -90,8 +95,11 @@ function hasMany(propName, property, target, ns) {
         return $this->hasMany(${fqcn}::class, '${foreignKey}');
     }`;
 }
-function belongsToMany(propName, property, target, ns) {
-    const joinTable = property['joinTable'] ?? '';
+function belongsToMany(propName, property, target, ns, context) {
+    let joinTable = property['joinTable'] ?? '';
+    if (!joinTable && context?.sourceTableName && context?.targetTableName) {
+        joinTable = generatePivotTableName(context.sourceTableName, context.targetTableName);
+    }
     const methodName = toCamelCase(propName);
     const pivotFields = property['pivotFields'] ?? {};
     const fqcn = `\\${ns}\\${target}`;

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.2",
+  "version": "1.0.1",
   "description": "TypeScript model type generator from Omnify schemas.json",
   "type": "module",
   "main": "dist/index.js",