@omnifyjp/omnify 0.1.1 → 0.1.3

package/ts-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/ts-dist/types.d.ts

@@ -0,0 +1,196 @@
+/**
+ * @omnify/ts — Internal types
+ *
+ * Types for schemas.json input and TypeScript code generation output.
+ */
+/** Localized string — either a plain string or a locale map. */
+export type LocalizedString = string | Record<string, string>;
+/** Top-level schemas.json structure. */
+export interface SchemasJson {
+    readonly generatedAt: string;
+    readonly database: {
+        readonly driver: string;
+    };
+    readonly connections: Record<string, string>;
+    readonly locale: {
+        readonly locales: string[];
+        readonly defaultLocale: string;
+        readonly fallbackLocale: string;
+    };
+    readonly customTypes: {
+        readonly compound: Record<string, CompoundTypeDefinition>;
+        readonly simple: Record<string, SimpleTypeDefinition>;
+        readonly enums: Record<string, string[]>;
+    };
+    readonly schemas: Record<string, SchemaDefinition>;
+}
+/** Compound type definition (e.g., JapaneseName). */
+export interface CompoundTypeDefinition {
+    readonly fields: readonly CompoundField[];
+}
+/** A field within a compound type. */
+export interface CompoundField {
+    readonly suffix: string;
+    readonly mapsTo?: string;
+    readonly length?: number;
+    readonly nullable?: boolean;
+    readonly enumRef?: string;
+}
+/** Simple custom type (e.g., JapanesePhone). */
+export interface SimpleTypeDefinition {
+    readonly mapsTo: string;
+    readonly length?: number;
+}
+/** Expanded property info (pre-computed by omnify-go). */
+export interface ExpandedProperty {
+    readonly sourceType: string;
+    readonly columns: readonly ExpandedColumn[];
+}
+/** A single expanded column from a compound type. */
+export interface ExpandedColumn {
+    readonly name: string;
+    readonly suffix: string;
+    readonly type: string;
+    readonly length?: number;
+    readonly nullable?: boolean;
+    readonly enum?: readonly string[];
+}
+/** Schema options. */
+export interface SchemaOptions {
+    readonly id?: boolean;
+    readonly idType?: string;
+    readonly timestamps?: boolean;
+    readonly softDelete?: boolean;
+    readonly hidden?: boolean;
+    readonly tableName?: string;
+    readonly indexes?: readonly unknown[];
+    readonly unique?: readonly unknown[];
+}
+/** Schema definition from schemas.json. */
+export interface SchemaDefinition {
+    readonly name: string;
+    readonly tableName?: string;
+    readonly connection?: string;
+    readonly displayName?: LocalizedString;
+    readonly group?: string;
+    readonly kind?: 'object' | 'enum' | 'pivot' | 'partial' | 'extend';
+    readonly options?: SchemaOptions;
+    readonly properties?: Record<string, PropertyDefinition>;
+    readonly propertyOrder?: readonly string[];
+    readonly expandedProperties?: Record<string, ExpandedProperty>;
+    readonly values?: readonly EnumValueDefinition[];
+    readonly pivotFor?: readonly string[];
+}
+/** Property definition within a schema. */
+export interface PropertyDefinition {
+    readonly type: string;
+    readonly displayName?: LocalizedString;
+    readonly description?: LocalizedString;
+    readonly placeholder?: LocalizedString;
+    readonly nullable?: boolean;
+    readonly unique?: boolean;
+    readonly primary?: boolean;
+    readonly default?: unknown;
+    readonly length?: number;
+    readonly minLength?: number;
+    readonly maxLength?: number;
+    readonly min?: number;
+    readonly max?: number;
+    readonly unsigned?: boolean;
+    readonly precision?: number;
+    readonly scale?: number;
+    readonly pattern?: string;
+    readonly enum?: string | readonly string[];
+    readonly relation?: string;
+    readonly target?: string;
+    readonly targets?: readonly string[];
+    readonly onDelete?: string;
+    readonly morphName?: string;
+    readonly joinTable?: string;
+    readonly mappedBy?: string;
+    readonly useCurrent?: boolean;
+    readonly fields?: Record<string, FieldOverride>;
+}
+/** Field override for compound type properties. */
+export interface FieldOverride {
+    readonly nullable?: boolean;
+    readonly length?: number;
+    readonly hidden?: boolean;
+    readonly displayName?: LocalizedString;
+    readonly placeholder?: LocalizedString;
+}
+/** Enum value definition (for schema enums). */
+export interface EnumValueDefinition {
+    readonly value: string;
+    readonly label?: LocalizedString;
+    readonly extra?: Record<string, unknown>;
+}
+/** File category for organizing output. */
+export type FileCategory = 'schema' | 'base' | 'enum' | 'plugin-enum';
+/** Generated TypeScript file. */
+export interface TypeScriptFile {
+    readonly filePath: string;
+    readonly content: string;
+    readonly types: readonly string[];
+    readonly overwrite: boolean;
+    readonly category?: FileCategory;
+}
+/** TypeScript property definition. */
+export interface TSProperty {
+    readonly name: string;
+    readonly type: string;
+    readonly optional: boolean;
+    readonly readonly: boolean;
+    readonly comment?: string;
+}
+/** TypeScript interface definition. */
+export interface TSInterface {
+    readonly name: string;
+    readonly properties: readonly TSProperty[];
+    readonly extends?: readonly string[];
+    readonly comment?: string;
+    readonly dependencies?: readonly string[];
+    readonly enumDependencies?: readonly string[];
+}
+/** TypeScript enum definition. */
+export interface TSEnum {
+    readonly name: string;
+    readonly values: readonly TSEnumValue[];
+    readonly comment?: string;
+}
+/** Multi-locale string map. */
+export type LocaleMap = Record<string, string>;
+/** TypeScript enum value. */
+export interface TSEnumValue {
+    readonly name: string;
+    readonly value: string | number;
+    readonly label?: string | LocaleMap;
+    readonly extra?: Record<string, unknown>;
+}
+/** TypeScript type alias definition. */
+export interface TSTypeAlias {
+    readonly name: string;
+    readonly type: string;
+    readonly comment?: string;
+}
+/** Zod schema information for a property. */
+export interface ZodPropertySchema {
+    readonly fieldName: string;
+    readonly schema: string;
+    readonly inCreate: boolean;
+    readonly inUpdate: boolean;
+    readonly comment?: string;
+}
+/** Display names for a schema. */
+export interface SchemaDisplayNames {
+    readonly displayName: LocaleMap;
+    readonly propertyDisplayNames: Record<string, LocaleMap>;
+    readonly propertyPlaceholders: Record<string, LocaleMap>;
+}
+/** Generation options (internal). */
+export interface GeneratorOptions {
+    readonly locales: string[];
+    readonly defaultLocale: string;
+    readonly fallbackLocale: string;
+    readonly customTypes: SchemasJson['customTypes'];
+}

package/ts-dist/types.js

@@ -0,0 +1,6 @@
+/**
+ * @omnify/ts — Internal types
+ *
+ * Types for schemas.json input and TypeScript code generation output.
+ */
+export {};

package/ts-dist/zod-generator.d.ts

@@ -0,0 +1,32 @@
+/**
+ * @omnify/ts — Zod Schema Generator
+ *
+ * Generates Zod schemas alongside TypeScript interfaces for form validation.
+ */
+import type { SchemaDefinition, ZodPropertySchema, SchemaDisplayNames, GeneratorOptions } from './types.js';
+/**
+ * Generate Zod schemas for all properties in a schema.
+ */
+export declare function generateZodSchemas(schema: SchemaDefinition, options: GeneratorOptions): ZodPropertySchema[];
+/**
+ * Generate display names and placeholders for a schema.
+ */
+export declare function generateDisplayNames(schema: SchemaDefinition, options: GeneratorOptions): SchemaDisplayNames;
+/**
+ * Get fields to exclude from create/update schemas.
+ */
+export declare function getExcludedFields(schema: SchemaDefinition): {
+    create: Set<string>;
+    update: Set<string>;
+};
+/**
+ * Format Zod schemas section for a base file.
+ */
+export declare function formatZodSchemasSection(schemaName: string, zodSchemas: ZodPropertySchema[], displayNames: SchemaDisplayNames, excludedFields: {
+    create: Set<string>;
+    update: Set<string>;
+}): string;
+/**
+ * Format user model file with Zod re-exports.
+ */
+export declare function formatZodModelFile(schemaName: string): string;