@omnifyjp/ts 0.3.0

package/dist/php/faker-mapper.js

@@ -0,0 +1,206 @@
+/**
+ * Port of FakerMapper.php — generates Faker expressions for factories.
+ */
+import { toSnakeCase } from './naming-helper.js';
+import { resolveEnumValues } from './type-mapper.js';
+/** Generate faker expression for a property. */
+export function toFaker(propName, property, schemas = {}) {
+    const type = property['type'] ?? 'String';
+    const snakeName = toSnakeCase(propName);
+    if (['deleted_at', 'created_at', 'updated_at'].includes(propName))
+        return null;
+    if (type === 'Association')
+        return null;
+    switch (type) {
+        case 'String': return stringFaker(propName, snakeName, property);
+        case 'Email': return `'${snakeName}' => fake()->unique()->safeEmail(),`;
+        case 'Password': return `'${snakeName}' => bcrypt('password'),`;
+        case 'Int':
+        case 'BigInt': return intFaker(snakeName, property);
+        case 'TinyInt': return `'${snakeName}' => fake()->numberBetween(0, 127),`;
+        case 'Float':
+        case 'Decimal': return `'${snakeName}' => fake()->randomFloat(2, 1, 10000),`;
+        case 'Boolean': return `'${snakeName}' => fake()->boolean(),`;
+        case 'Text': return `'${snakeName}' => fake()->paragraphs(3, true),`;
+        case 'MediumText': return `'${snakeName}' => fake()->paragraphs(3, true),`;
+        case 'LongText': return `'${snakeName}' => fake()->paragraphs(5, true),`;
+        case 'Date': return `'${snakeName}' => fake()->date(),`;
+        case 'Time': return `'${snakeName}' => fake()->time(),`;
+        case 'DateTime':
+        case 'Timestamp': return `'${snakeName}' => fake()->dateTime(),`;
+        case 'Json': return `'${snakeName}' => [],`;
+        case 'Uuid': return `'${snakeName}' => (string) \\Illuminate\\Support\\Str::uuid(),`;
+        case 'Enum': return enumFaker(snakeName, property);
+        case 'EnumRef': return enumRefFaker(snakeName, property, schemas);
+        case 'JapanesePhone': return `'${snakeName}' => fake('ja_JP')->phoneNumber(),`;
+        case 'JapanesePostalCode': return `'${snakeName}' => fake('ja_JP')->postcode(),`;
+        default: return `'${snakeName}' => fake()->sentence(),`;
+    }
+}
+/** Generate faker expressions for compound type expanded columns. */
+export function compoundFaker(propName, expansion, sourceType) {
+    const snakeName = toSnakeCase(propName);
+    const jaFaker = "fake('ja_JP')";
+    switch (sourceType) {
+        case 'JapaneseName':
+            return [
+                `'${snakeName}_lastname' => ${jaFaker}->lastName(),`,
+                `'${snakeName}_firstname' => ${jaFaker}->firstName(),`,
+                `'${snakeName}_kana_lastname' => ${jaFaker}->lastKanaName(),`,
+                `'${snakeName}_kana_firstname' => ${jaFaker}->firstKanaName(),`,
+            ];
+        case 'JapaneseAddress':
+            return japaneseAddressFaker(snakeName, expansion);
+        case 'JapaneseBankAccount':
+            return [
+                `'${snakeName}_bank_code' => ${jaFaker}->regexify('[0-9]{4}'),`,
+                `'${snakeName}_branch_code' => ${jaFaker}->regexify('[0-9]{3}'),`,
+                `'${snakeName}_account_type' => ${jaFaker}->randomElement(['1', '2', '4']),`,
+                `'${snakeName}_account_number' => ${jaFaker}->regexify('[0-9]{7}'),`,
+                `'${snakeName}_account_holder' => ${jaFaker}->lastKanaName() . ' ' . ${jaFaker}->firstKanaName(),`,
+            ];
+        default:
+            return genericCompoundFaker(snakeName, expansion);
+    }
+}
+/** Generate faker for association (foreign key). */
+export function associationFaker(propName, property, modelNamespace, currentSchema) {
+    const relation = property['relation'] ?? '';
+    const target = property['target'] ?? '';
+    if (relation !== 'ManyToOne' || !target)
+        return null;
+    const snakeName = toSnakeCase(propName);
+    const foreignKey = `${snakeName}_id`;
+    const nullable = property['nullable'] ?? false;
+    const fake = nullable
+        ? `'${foreignKey}' => ${target}::query()->inRandomOrder()->first()?->id,`
+        : `'${foreignKey}' => ${target}::query()->inRandomOrder()->first()?->id ?? ${target}::factory()->create()->id,`;
+    let importLine = null;
+    if (target !== currentSchema) {
+        const targetNs = property['targetNamespace'] ?? modelNamespace;
+        importLine = `use ${targetNs}\\${target};`;
+    }
+    return { fake, import: importLine };
+}
+function stringFaker(propName, snakeName, property) {
+    const lower = propName.toLowerCase();
+    if (propName === 'slug')
+        return `'${snakeName}' => fake()->unique()->slug(2),`;
+    if (propName === 'uuid' || propName === 'uid')
+        return `'${snakeName}' => (string) \\Illuminate\\Support\\Str::uuid(),`;
+    if (lower.includes('email'))
+        return `'${snakeName}' => fake()->unique()->safeEmail(),`;
+    if (lower.includes('phone'))
+        return `'${snakeName}' => fake()->phoneNumber(),`;
+    if (lower.includes('image') || lower.includes('photo') || lower.includes('avatar'))
+        return `'${snakeName}' => fake()->imageUrl(),`;
+    if (lower.includes('url') || lower.includes('website'))
+        return `'${snakeName}' => fake()->url(),`;
+    if (lower.includes('path') || lower.includes('file'))
+        return `'${snakeName}' => 'uploads/' . fake()->uuid() . '.jpg',`;
+    if (propName === 'name' || propName === 'title')
+        return `'${snakeName}' => fake()->sentence(3),`;
+    if (lower.includes('name'))
+        return `'${snakeName}' => fake()->name(),`;
+    if (lower.includes('address'))
+        return `'${snakeName}' => fake()->address(),`;
+    if (lower.includes('city'))
+        return `'${snakeName}' => fake()->city(),`;
+    if (lower.includes('country'))
+        return `'${snakeName}' => fake()->country(),`;
+    if (lower.includes('zip') || lower.includes('postal'))
+        return `'${snakeName}' => fake()->postcode(),`;
+    if (lower.includes('color'))
+        return `'${snakeName}' => fake()->hexColor(),`;
+    if (lower.includes('token') || lower.includes('secret') || lower.includes('key'))
+        return `'${snakeName}' => \\Illuminate\\Support\\Str::random(32),`;
+    if (lower.includes('code'))
+        return `'${snakeName}' => fake()->unique()->regexify('[A-Z0-9]{8}'),`;
+    const length = property['length'];
+    if (length != null && length <= 50)
+        return `'${snakeName}' => fake()->words(3, true),`;
+    return `'${snakeName}' => fake()->sentence(),`;
+}
+function intFaker(snakeName, property) {
+    const isUnique = property['unique'] ?? false;
+    const up = isUnique ? 'unique()->' : '';
+    if (snakeName.includes('count') || snakeName.includes('quantity'))
+        return `'${snakeName}' => fake()->${up}numberBetween(0, 100),`;
+    if (snakeName.includes('price') || snakeName.includes('amount') || snakeName.includes('cost'))
+        return `'${snakeName}' => fake()->${up}numberBetween(100, 10000),`;
+    if (snakeName.includes('order') || snakeName.includes('sort') || snakeName.includes('position'))
+        return `'${snakeName}' => fake()->${up}numberBetween(1, 100),`;
+    if (snakeName.includes('age'))
+        return `'${snakeName}' => fake()->${up}numberBetween(18, 80),`;
+    if (snakeName.includes('year'))
+        return `'${snakeName}' => fake()->${up}year(),`;
+    const range = isUnique ? '1, 1000000' : '1, 1000';
+    return `'${snakeName}' => fake()->${up}numberBetween(${range}),`;
+}
+function enumFaker(snakeName, property) {
+    const values = resolveEnumValues(property);
+    if (!values)
+        return `'${snakeName}' => null,`;
+    const valuesStr = values.map(v => `'${v}'`).join(', ');
+    return `'${snakeName}' => fake()->randomElement([${valuesStr}]),`;
+}
+function enumRefFaker(snakeName, property, schemas) {
+    const enumName = property['enum'];
+    if (!enumName || typeof enumName !== 'string')
+        return `'${snakeName}' => null,`;
+    const enumSchema = schemas[enumName];
+    if (!enumSchema || enumSchema['kind'] !== 'enum' || !Array.isArray(enumSchema['values']))
+        return `'${snakeName}' => null,`;
+    const values = [];
+    for (const v of enumSchema['values']) {
+        if (typeof v === 'string')
+            values.push(v);
+        else if (typeof v === 'object' && v !== null && 'value' in v)
+            values.push(v.value);
+    }
+    if (values.length === 0)
+        return `'${snakeName}' => null,`;
+    const valuesStr = values.map(v => `'${v}'`).join(', ');
+    return `'${snakeName}' => fake()->randomElement([${valuesStr}]),`;
+}
+function japaneseAddressFaker(snakeName, expansion) {
+    const jaFaker = "fake('ja_JP')";
+    const lines = [`'${snakeName}_postal_code' => ${jaFaker}->postcode(),`];
+    // Check for prefecture enum values
+    let prefectureValues = null;
+    const columns = expansion['columns'] ?? [];
+    for (const col of columns) {
+        if (col['suffix'] === 'Prefecture' && col['enum']) {
+            const enumDef = col['enum'];
+            if (Array.isArray(enumDef['values'])) {
+                prefectureValues = enumDef['values'];
+            }
+        }
+    }
+    if (prefectureValues) {
+        const keys = prefectureValues.map(v => `'${typeof v === 'string' ? v : (v['value'] ?? v)}'`).join(', ');
+        lines.push(`'${snakeName}_prefecture' => fake()->randomElement([${keys}]),`);
+    }
+    else {
+        lines.push(`'${snakeName}_prefecture' => fake()->randomElement(['hokkaido', 'aomori', 'iwate', 'miyagi', 'akita', 'yamagata', 'fukushima', 'ibaraki', 'tochigi', 'gunma', 'saitama', 'chiba', 'tokyo', 'kanagawa', 'niigata', 'toyama', 'ishikawa', 'fukui', 'yamanashi', 'nagano', 'gifu', 'shizuoka', 'aichi', 'mie', 'shiga', 'kyoto', 'osaka', 'hyogo', 'nara', 'wakayama', 'tottori', 'shimane', 'okayama', 'hiroshima', 'yamaguchi', 'tokushima', 'kagawa', 'ehime', 'kochi', 'fukuoka', 'saga', 'nagasaki', 'kumamoto', 'oita', 'miyazaki', 'kagoshima', 'okinawa']),`);
+    }
+    lines.push(`'${snakeName}_address1' => ${jaFaker}->city() . ${jaFaker}->ward(),`);
+    lines.push(`'${snakeName}_address2' => ${jaFaker}->streetAddress(),`);
+    lines.push(`'${snakeName}_address3' => ${jaFaker}->optional()->secondaryAddress(),`);
+    return lines;
+}
+function genericCompoundFaker(snakeName, expansion) {
+    const lines = [];
+    const columns = expansion['columns'] ?? [];
+    for (const col of columns) {
+        const colName = col['name'] ?? `${snakeName}_${toSnakeCase(col['suffix'] ?? '')}`;
+        const colType = col['type'] ?? 'String';
+        if (['Int', 'BigInt', 'TinyInt'].includes(colType)) {
+            lines.push(`'${colName}' => fake()->numberBetween(1, 100),`);
+        }
+        else {
+            lines.push(`'${colName}' => fake()->words(2, true),`);
+        }
+    }
+    return lines;
+}

package/dist/php/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * PHP code generation orchestrator.
+ *
+ * Reads schemas.json and generates all Laravel PHP files:
+ * - BaseModel, Models
+ * - Form Requests (Store + Update)
+ * - API Resources
+ * - Factories
+ * - Traits
+ * - Locales
+ * - OmnifyServiceProvider
+ */
+import type { SchemasJson } from '../types.js';
+import type { GeneratedFile, LaravelCodegenOverrides } from './types.js';
+export type { GeneratedFile, PhpConfig, LaravelCodegenOverrides } from './types.js';
+export { derivePhpConfig } from './types.js';
+/** Generate all PHP files from schemas.json data. */
+export declare function generatePhp(data: SchemasJson, overrides?: LaravelCodegenOverrides): GeneratedFile[];

package/dist/php/index.js

@@ -0,0 +1,40 @@
+/**
+ * PHP code generation orchestrator.
+ *
+ * Reads schemas.json and generates all Laravel PHP files:
+ * - BaseModel, Models
+ * - Form Requests (Store + Update)
+ * - API Resources
+ * - Factories
+ * - Traits
+ * - Locales
+ * - OmnifyServiceProvider
+ */
+import { derivePhpConfig } from './types.js';
+import { SchemaReader } from './schema-reader.js';
+import { generateBaseModel } from './base-model-generator.js';
+import { generateTrait } from './trait-generator.js';
+import { generateLocales } from './locales-generator.js';
+import { generateModels } from './model-generator.js';
+import { generateRequests } from './request-generator.js';
+import { generateResources } from './resource-generator.js';
+import { generateFactories } from './factory-generator.js';
+import { generateServiceProvider } from './service-provider-generator.js';
+export { derivePhpConfig } from './types.js';
+/** Generate all PHP files from schemas.json data. */
+export function generatePhp(data, overrides) {
+    const reader = SchemaReader.fromData(data);
+    const config = derivePhpConfig(overrides);
+    const files = [];
+    // Infrastructure files
+    files.push(...generateBaseModel(reader, config));
+    files.push(...generateTrait(config));
+    files.push(...generateServiceProvider(reader, config));
+    // Per-schema files
+    files.push(...generateLocales(reader, config));
+    files.push(...generateModels(reader, config));
+    files.push(...generateRequests(reader, config));
+    files.push(...generateResources(reader, config));
+    files.push(...generateFactories(reader, config));
+    return files;
+}

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

@@ -0,0 +1,7 @@
+/**
+ * Port of LocalesGenerator.php — generates Locales classes with display name constants.
+ */
+import { SchemaReader } from './schema-reader.js';
+import type { GeneratedFile, PhpConfig } from './types.js';
+/** Generate Locales classes for all object schemas. */
+export declare function generateLocales(reader: SchemaReader, config: PhpConfig): GeneratedFile[];

package/dist/php/locales-generator.js

@@ -0,0 +1,135 @@
+/**
+ * Port of LocalesGenerator.php — generates Locales classes with display name constants.
+ */
+import { toPascalCase, toSnakeCase } from './naming-helper.js';
+import { baseFile } from './types.js';
+/** Generate Locales classes for all object schemas. */
+export function generateLocales(reader, config) {
+    const files = [];
+    for (const [name, schema] of Object.entries(reader.getObjectSchemas())) {
+        const file = generateLocalesClass(name, schema, reader, config);
+        if (file)
+            files.push(file);
+    }
+    return files;
+}
+function generateLocalesClass(name, schema, reader, config) {
+    const modelName = toPascalCase(name);
+    const baseNamespace = config.models.baseNamespace;
+    const displayNames = buildDisplayNames(schema);
+    const propertyDisplayNames = buildPropertyDisplayNames(schema, reader, name);
+    const displayNamesPhp = formatArrayConstant(displayNames, 8);
+    const propertyDisplayNamesPhp = formatNestedArrayConstant(propertyDisplayNames, 8);
+    const content = `<?php
+
+namespace ${baseNamespace}\\Locales;
+
+/**
+ * Localized display names for ${modelName}.
+ *
+ * DO NOT EDIT - This file is auto-generated by Omnify.
+ * Any changes will be overwritten on next generation.
+ *
+ * @generated by omnify
+ */
+class ${modelName}Locales
+{
+    /**
+     * Localized display names for the model.
+     *
+     * @var array<string, string>
+     */
+    public const DISPLAY_NAMES = ${displayNamesPhp};
+
+    /**
+     * Localized display names for properties.
+     *
+     * @var array<string, array<string, string>>
+     */
+    public const PROPERTY_DISPLAY_NAMES = ${propertyDisplayNamesPhp};
+}
+`;
+    return baseFile(`${config.models.basePath}/Locales/${modelName}Locales.php`, content);
+}
+function buildDisplayNames(schema) {
+    const displayName = schema.displayName;
+    if (displayName == null)
+        return { en: schema.name ?? '' };
+    if (typeof displayName === 'string')
+        return { en: displayName };
+    if (typeof displayName === 'object')
+        return displayName;
+    return { en: schema.name ?? '' };
+}
+function buildPropertyDisplayNames(schema, reader, schemaName) {
+    const result = {};
+    const properties = schema.properties ?? {};
+    const expandedProperties = reader.getExpandedProperties(schemaName);
+    const propertyOrder = reader.getPropertyOrder(schemaName);
+    for (const propName of propertyOrder) {
+        const prop = properties[propName];
+        if (!prop)
+            continue;
+        const type = prop.type ?? 'String';
+        if (type === 'Association')
+            continue;
+        // Compound type: use column-level displayNames
+        if (expandedProperties[propName]) {
+            const expansion = expandedProperties[propName];
+            for (const col of expansion.columns ?? []) {
+                const colAny = col;
+                const colName = colAny['name'] ?? '';
+                const colDisplayName = colAny['displayName'];
+                if (colDisplayName) {
+                    result[colName] = typeof colDisplayName === 'string'
+                        ? { en: colDisplayName }
+                        : colDisplayName;
+                }
+            }
+            continue;
+        }
+        // Regular property
+        const displayName = prop.displayName;
+        const snakeName = toSnakeCase(propName);
+        if (displayName == null)
+            continue;
+        if (typeof displayName === 'string') {
+            result[snakeName] = { en: displayName };
+        }
+        else if (typeof displayName === 'object') {
+            result[snakeName] = displayName;
+        }
+    }
+    return result;
+}
+function formatArrayConstant(data, indent) {
+    const entries = Object.entries(data);
+    if (entries.length === 0)
+        return '[]';
+    const pad = ' '.repeat(indent);
+    const lines = ['['];
+    for (const [key, value] of entries) {
+        const escaped = value.replace(/\\/g, '\\\\').replace(/'/g, "\\'");
+        lines.push(`${pad}'${key}' => '${escaped}',`);
+    }
+    lines.push(' '.repeat(indent - 4) + ']');
+    return lines.join('\n');
+}
+function formatNestedArrayConstant(data, indent) {
+    const entries = Object.entries(data);
+    if (entries.length === 0)
+        return '[]';
+    const pad = ' '.repeat(indent);
+    const innerPad = ' '.repeat(indent + 4);
+    const lines = ['['];
+    for (const [propName, locales] of entries) {
+        lines.push(`${pad}'${propName}' => [`);
+        for (const [locale, value] of Object.entries(locales)) {
+            const escaped = value.replace(/\\/g, '\\\\').replace(/'/g, "\\'");
+            lines.push(`${innerPad}'${locale}' => '${escaped}',`);
+        }
+        lines.push(`${pad}],`);
+    }
+    lines.push(' '.repeat(indent - 4) + ']');
+    return lines.join('\n');
+}

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

@@ -0,0 +1,7 @@
+/**
+ * Port of ModelGenerator.php — generates Eloquent model base + user classes.
+ */
+import { SchemaReader } from './schema-reader.js';
+import type { GeneratedFile, PhpConfig } from './types.js';
+/** Generate base model and user model for all object schemas. */
+export declare function generateModels(reader: SchemaReader, config: PhpConfig): GeneratedFile[];