@omnifyjp/ts 0.3.0

package/dist/interface-generator.js

@@ -0,0 +1,341 @@
+/**
+ * @omnify/ts — TypeScript Interface Generator
+ *
+ * Generates TypeScript interfaces from schema definitions.
+ * Handles compound type expansion via expandedProperties, association types,
+ * enum references, and all standard property types.
+ */
+/** Convert PascalCase/camelCase to snake_case. */
+export function toSnakeCase(str) {
+    return str
+        .replace(/([A-Z])/g, '_$1')
+        .replace(/^_/, '')
+        .toLowerCase();
+}
+/** Maps Omnify property types to TypeScript types. */
+const TYPE_MAP = {
+    String: 'string',
+    TinyInt: 'number',
+    Int: 'number',
+    BigInt: 'number',
+    Float: 'number',
+    Decimal: 'number',
+    Boolean: 'boolean',
+    Text: 'string',
+    MediumText: 'string',
+    LongText: 'string',
+    Date: 'DateString',
+    Time: 'string',
+    DateTime: 'DateTimeString',
+    Timestamp: 'DateTimeString',
+    Json: 'unknown',
+    Email: 'string',
+    Password: 'string',
+    Enum: 'string',
+    Select: 'string',
+    Lookup: 'number',
+};
+/** Maps primary key types to TypeScript types. */
+const PK_TYPE_MAP = {
+    Int: 'number',
+    BigInt: 'number',
+    Uuid: 'string',
+    String: 'string',
+};
+/** Gets TypeScript type for a property. */
+export function getPropertyType(property, allSchemas) {
+    if (property.type === 'File') {
+        return 'File | null';
+    }
+    if (property.type === 'Association') {
+        const targetName = property.target ?? 'unknown';
+        switch (property.relation) {
+            case 'OneToOne':
+            case 'ManyToOne':
+                return targetName;
+            case 'OneToMany':
+            case 'ManyToMany':
+                return `${targetName}[]`;
+            case 'MorphTo':
+                if (property.targets && property.targets.length > 0) {
+                    return property.targets.join(' | ');
+                }
+                return 'unknown';
+            case 'MorphOne':
+                return targetName;
+            case 'MorphMany':
+            case 'MorphToMany':
+            case 'MorphedByMany':
+                return `${targetName}[]`;
+            default:
+                return 'unknown';
+        }
+    }
+    if (property.type === 'EnumRef') {
+        if (typeof property.enum === 'string') {
+            return property.enum;
+        }
+        return 'string';
+    }
+    if (property.type === 'Enum') {
+        if (typeof property.enum === 'string') {
+            return property.enum;
+        }
+        if (Array.isArray(property.enum)) {
+            return property.enum.map(v => `'${v}'`).join(' | ');
+        }
+    }
+    return TYPE_MAP[property.type] ?? 'string';
+}
+/**
+ * Convert a property to TSProperty array.
+ * Compound types expand to multiple properties via expandedProperties.
+ * MorphTo and ManyToOne also return multiple properties (FK + relation).
+ */
+export function propertyToTSProperties(propertyName, property, schema, allSchemas, options) {
+    const isReadonly = false;
+    const isNullable = property.nullable ?? false;
+    // Handle compound types via expandedProperties
+    if (schema.expandedProperties?.[propertyName]) {
+        const expanded = schema.expandedProperties[propertyName];
+        const props = [];
+        // Find compound type definition for enum resolution
+        const compoundDef = options.customTypes.compound[expanded.sourceType];
+        for (const col of expanded.columns) {
+            // Determine TypeScript type for expanded column
+            let tsType;
+            if (col.type === 'Enum' && col.enum) {
+                // Check if this field has an enumRef in the compound type definition
+                const compoundField = compoundDef?.fields.find(f => f.suffix === col.suffix);
+                if (compoundField?.enumRef) {
+                    tsType = compoundField.enumRef;
+                }
+                else {
+                    tsType = col.enum.map(v => `'${v}'`).join(' | ');
+                }
+            }
+            else {
+                tsType = TYPE_MAP[col.type] ?? 'string';
+            }
+            props.push({
+                name: col.name,
+                type: tsType,
+                optional: col.nullable ?? false,
+                readonly: isReadonly,
+            });
+        }
+        return props;
+    }
+    // Handle simple custom types (JapanesePhone, JapanesePostalCode, etc.)
+    const simpleType = options.customTypes.simple[property.type];
+    if (simpleType) {
+        const tsType = TYPE_MAP[simpleType.mapsTo] ?? 'string';
+        return [{
+                name: propertyName,
+                type: tsType,
+                optional: isNullable,
+                readonly: isReadonly,
+            }];
+    }
+    // Handle Association: MorphTo — creates _type, _id, and relation properties
+    if (property.type === 'Association' && property.relation === 'MorphTo' && property.targets && property.targets.length > 0) {
+        const targetUnion = property.targets.map(t => `'${t}'`).join(' | ');
+        const relationUnion = property.targets.join(' | ');
+        return [
+            {
+                name: `${propertyName}_type`,
+                type: targetUnion,
+                optional: true,
+                readonly: isReadonly,
+            },
+            {
+                name: `${propertyName}_id`,
+                type: 'number',
+                optional: true,
+                readonly: isReadonly,
+            },
+            {
+                name: propertyName,
+                type: `${relationUnion} | null`,
+                optional: true,
+                readonly: isReadonly,
+            },
+        ];
+    }
+    // Handle Association: ManyToOne / OneToOne (owning side) — creates FK _id and relation
+    if (property.type === 'Association' && (property.relation === 'ManyToOne' || property.relation === 'OneToOne') && !property.mappedBy) {
+        const targetName = property.target ?? 'unknown';
+        // Determine FK type from target schema
+        let fkType = 'number';
+        const targetSchema = property.target ? allSchemas[property.target] : undefined;
+        const effectiveIdType = targetSchema?.options?.idType ?? 'BigInt';
+        if (effectiveIdType === 'Uuid' || effectiveIdType === 'String') {
+            fkType = 'string';
+        }
+        return [
+            {
+                name: `${propertyName}_id`,
+                type: fkType,
+                optional: isNullable,
+                readonly: isReadonly,
+            },
+            {
+                name: propertyName,
+                type: isNullable ? `${targetName} | null` : targetName,
+                optional: true,
+                readonly: isReadonly,
+            },
+        ];
+    }
+    // Handle other Association types (OneToMany, ManyToMany, MorphMany, etc.)
+    if (property.type === 'Association') {
+        const type = getPropertyType(property, allSchemas);
+        return [{
+                name: propertyName,
+                type,
+                optional: true,
+                readonly: isReadonly,
+            }];
+    }
+    // Default: single property
+    const type = getPropertyType(property, allSchemas);
+    return [{
+            name: propertyName,
+            type,
+            optional: isNullable,
+            readonly: isReadonly,
+        }];
+}
+/** Extract referenced schema names from a type string. */
+function extractTypeReferences(type, allSchemaNames) {
+    const primitives = new Set(['string', 'number', 'boolean', 'unknown', 'null', 'undefined', 'void', 'never', 'any']);
+    const refs = [];
+    const cleanType = type.replace(/\[\]/g, '').replace(/\s*\|\s*null/g, '');
+    const parts = cleanType.split(/\s*\|\s*/);
+    for (const part of parts) {
+        const trimmed = part.trim().replace(/^['"]|['"]$/g, '');
+        if (!primitives.has(trimmed) && allSchemaNames.has(trimmed)) {
+            refs.push(trimmed);
+        }
+    }
+    return refs;
+}
+/** Generate a TSInterface from a schema definition. */
+export function schemaToInterface(schema, allSchemas, options) {
+    const properties = [];
+    const allSchemaNames = new Set(Object.keys(allSchemas).filter(name => allSchemas[name]?.kind !== 'enum'));
+    // ID property
+    if (schema.options?.id !== false) {
+        const pkType = (schema.options?.idType ?? 'BigInt');
+        properties.push({
+            name: 'id',
+            type: PK_TYPE_MAP[pkType] ?? 'number',
+            optional: false,
+            readonly: false,
+        });
+    }
+    // Schema properties (in propertyOrder if available)
+    if (schema.properties) {
+        const propNames = schema.propertyOrder ?? Object.keys(schema.properties);
+        for (const propName of propNames) {
+            const property = schema.properties[propName];
+            if (!property)
+                continue;
+            properties.push(...propertyToTSProperties(propName, property, schema, allSchemas, options));
+        }
+    }
+    // Timestamps
+    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
+    if (schema.options?.softDelete) {
+        properties.push({ name: 'deleted_at', type: 'DateTimeString', optional: true, readonly: false });
+    }
+    // Collect dependencies
+    const dependencySet = new Set();
+    for (const prop of properties) {
+        for (const ref of extractTypeReferences(prop.type, allSchemaNames)) {
+            if (ref !== schema.name) {
+                dependencySet.add(ref);
+            }
+        }
+    }
+    // Collect enum dependencies (EnumRef properties + compound enum fields)
+    const enumDependencySet = new Set();
+    if (schema.properties) {
+        for (const property of Object.values(schema.properties)) {
+            if (property.type === 'EnumRef' && typeof property.enum === 'string') {
+                enumDependencySet.add(property.enum);
+            }
+        }
+    }
+    // Check expanded properties for enum references
+    if (schema.expandedProperties) {
+        for (const expanded of Object.values(schema.expandedProperties)) {
+            const compoundDef = options.customTypes.compound[expanded.sourceType];
+            if (!compoundDef)
+                continue;
+            for (const col of expanded.columns) {
+                if (col.type === 'Enum') {
+                    const compoundField = compoundDef.fields.find(f => f.suffix === col.suffix);
+                    if (compoundField?.enumRef) {
+                        enumDependencySet.add(compoundField.enumRef);
+                    }
+                }
+            }
+        }
+    }
+    // Resolve display name
+    const displayName = resolveString(schema.displayName, options.defaultLocale, options.fallbackLocale);
+    return {
+        name: schema.name,
+        properties,
+        comment: displayName ?? schema.name,
+        dependencies: dependencySet.size > 0 ? Array.from(dependencySet).sort() : undefined,
+        enumDependencies: enumDependencySet.size > 0 ? Array.from(enumDependencySet).sort() : undefined,
+    };
+}
+/** Format a TypeScript property line. */
+export function formatProperty(property) {
+    const optional = property.optional ? '?' : '';
+    return `  ${property.name}${optional}: ${property.type};`;
+}
+/** Format a TypeScript interface. */
+export function formatInterface(iface) {
+    const comment = iface.comment ? `/**\n * ${iface.comment}\n */\n` : '';
+    const properties = iface.properties.map(formatProperty).join('\n');
+    return `${comment}export interface ${iface.name} {\n${properties}\n}`;
+}
+/** Generate interfaces for all non-enum, non-hidden schemas. */
+export function generateInterfaces(schemas, options) {
+    const interfaces = [];
+    for (const schema of Object.values(schemas)) {
+        if (schema.kind === 'enum')
+            continue;
+        if (schema.options?.hidden === true)
+            continue;
+        interfaces.push(schemaToInterface(schema, schemas, options));
+    }
+    return interfaces;
+}
+/** Resolve a LocalizedString to a single string. */
+function resolveString(value, defaultLocale, fallbackLocale) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value === 'string')
+        return value;
+    return value[defaultLocale] ?? value[fallbackLocale] ?? value['en'] ?? Object.values(value)[0];
+}
+/** Check if interface uses DateTimeString or DateString types. */
+export function needsDateTimeImports(iface) {
+    let dateTime = false;
+    let date = false;
+    for (const prop of iface.properties) {
+        if (prop.type === 'DateTimeString' || prop.type.includes('DateTimeString'))
+            dateTime = true;
+        if (prop.type === 'DateString' || prop.type.includes('DateString'))
+            date = true;
+    }
+    return { dateTime, date };
+}

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

@@ -0,0 +1,7 @@
+/**
+ * Port of BaseModelGenerator.php — generates abstract BaseModel with morph map.
+ */
+import { SchemaReader } from './schema-reader.js';
+import type { GeneratedFile, PhpConfig } from './types.js';
+/** Generate the abstract BaseModel class with morph map. */
+export declare function generateBaseModel(reader: SchemaReader, config: PhpConfig): GeneratedFile[];

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

@@ -0,0 +1,70 @@
+/**
+ * Port of BaseModelGenerator.php — generates abstract BaseModel with morph map.
+ */
+import { toPascalCase } from './naming-helper.js';
+import { baseFile } from './types.js';
+/** Generate the abstract BaseModel class with morph map. */
+export function generateBaseModel(reader, config) {
+    const baseNamespace = config.models.baseNamespace;
+    const modelNamespace = config.models.namespace;
+    // Build morph map entries from all visible object schemas
+    const morphMap = {};
+    for (const name of Object.keys(reader.getVisibleObjectSchemas())) {
+        const modelName = toPascalCase(name);
+        morphMap[modelName] = `\\${modelNamespace}\\${modelName}::class`;
+    }
+    // Sort for consistent output
+    const sortedKeys = Object.keys(morphMap).sort();
+    const morphEntries = sortedKeys
+        .map(k => `        '${k}' => ${morphMap[k]},`)
+        .join('\n');
+    const content = `<?php
+
+namespace ${baseNamespace};
+
+/**
+ * Base model class for all Omnify-generated models.
+ * Contains model mapping for polymorphic relations.
+ *
+ * DO NOT EDIT - This file is auto-generated by Omnify.
+ * Any changes will be overwritten on next generation.
+ *
+ * @generated by omnify
+ */
+
+use Illuminate\\Database\\Eloquent\\Model;
+use Illuminate\\Database\\Eloquent\\Relations\\Relation;
+
+abstract class BaseModel extends Model
+{
+    /**
+     * Model class map for polymorphic relations.
+     */
+    protected static array $modelMap = [
+${morphEntries}
+    ];
+
+    /**
+     * Boot the model and register morph map.
+     */
+    protected static function boot(): void
+    {
+        parent::boot();
+
+        // Register morph map for polymorphic relations
+        Relation::enforceMorphMap(static::$modelMap);
+    }
+
+    /**
+     * Get the model class for a given morph type.
+     */
+    public static function getModelClass(string $morphType): ?string
+    {
+        return static::$modelMap[$morphType] ?? null;
+    }
+}
+`;
+    return [
+        baseFile(`${config.models.basePath}/BaseModel.php`, content),
+    ];
+}

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

@@ -0,0 +1,7 @@
+/**
+ * Port of FactoryGenerator.php — generates Model Factory classes.
+ */
+import { SchemaReader } from './schema-reader.js';
+import type { GeneratedFile, PhpConfig } from './types.js';
+/** Generate Factory classes for all visible object schemas. */
+export declare function generateFactories(reader: SchemaReader, config: PhpConfig): GeneratedFile[];

package/dist/php/factory-generator.js

@@ -0,0 +1,95 @@
+/**
+ * Port of FactoryGenerator.php — generates Model Factory classes.
+ */
+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. */
+export function generateFactories(reader, config) {
+    const files = [];
+    const schemas = reader.getSchemas();
+    for (const [name, schema] of Object.entries(reader.getVisibleObjectSchemas())) {
+        const file = generateFactory(name, schema, reader, schemas, config);
+        if (file)
+            files.push(file);
+    }
+    return files;
+}
+function generateFactory(name, schema, reader, schemas, config) {
+    const modelName = toPascalCase(name);
+    const modelNamespace = config.models.namespace;
+    const factoryNamespace = config.factories.namespace;
+    const properties = (schema.properties ?? {});
+    const expandedProperties = reader.getExpandedProperties(name);
+    const propertyOrder = reader.getPropertyOrder(name);
+    const attributes = [];
+    const imports = [];
+    for (const propName of propertyOrder) {
+        const prop = properties[propName];
+        if (!prop)
+            continue;
+        const type = prop['type'] ?? 'String';
+        // Handle associations (foreign keys)
+        if (type === 'Association') {
+            const result = associationFaker(propName, prop, modelNamespace, name);
+            if (result) {
+                attributes.push(result.fake);
+                if (result.import)
+                    imports.push(result.import);
+            }
+            continue;
+        }
+        // Handle compound types
+        if (expandedProperties[propName]) {
+            const expansion = expandedProperties[propName];
+            const sourceType = expansion.sourceType ?? '';
+            const fakes = compoundFaker(propName, expansion, sourceType);
+            attributes.push(...fakes);
+            continue;
+        }
+        // Handle regular properties
+        const fake = toFaker(propName, prop, schemas);
+        if (fake)
+            attributes.push(fake);
+    }
+    const attributesStr = attributes.length > 0
+        ? attributes.map(a => `            ${a}`).join('\n')
+        : '';
+    const uniqueImports = [...new Set(imports)];
+    const importsStr = uniqueImports.length > 0
+        ? '\n' + uniqueImports.join('\n')
+        : '';
+    const content = `<?php
+
+namespace ${factoryNamespace};
+
+use ${modelNamespace}\\${modelName};
+use Illuminate\\Database\\Eloquent\\Factories\\Factory;
+${importsStr}
+
+/**
+ * ${modelName} Factory
+ *
+ * SAFE TO EDIT - This file is never overwritten by Omnify.
+ *
+ * @extends Factory<${modelName}>
+ */
+class ${modelName}Factory extends Factory
+{
+    protected $model = ${modelName}::class;
+
+    /**
+     * Define the model's default state.
+     *
+     * @return array<string, mixed>
+     */
+    public function definition(): array
+    {
+        return [
+${attributesStr}
+        ];
+    }
+}
+`;
+    return userFile(`${config.factories.path}/${modelName}Factory.php`, content);
+}

package/dist/php/faker-mapper.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Port of FakerMapper.php — generates Faker expressions for factories.
+ */
+/** Generate faker expression for a property. */
+export declare function toFaker(propName: string, property: Record<string, unknown>, schemas?: Record<string, Record<string, unknown>>): string | null;
+/** Generate faker expressions for compound type expanded columns. */
+export declare function compoundFaker(propName: string, expansion: Record<string, unknown>, sourceType: string): string[];
+/** Generate faker for association (foreign key). */
+export declare function associationFaker(propName: string, property: Record<string, unknown>, modelNamespace: string, currentSchema: string): {
+    fake: string;
+    import: string | null;
+} | null;