@omnifyjp/ts 0.3.7 → 0.4.0

package/dist/interface-generator.js

@@ -40,8 +40,16 @@ const PK_TYPE_MAP = {
     Int: 'number',
     BigInt: 'number',
     Uuid: 'string',
+    Ulid: 'string',
     String: 'string',
 };
+/** Extract IdType from the unified `id` field. Returns 'BigInt' as default. */
+function getIdType(options) {
+    const id = options?.id;
+    if (typeof id === 'string')
+        return id;
+    return 'BigInt';
+}
 /** Gets TypeScript type for a property. */
 export function getPropertyType(property, allSchemas) {
     if (property.type === 'File') {
@@ -168,7 +176,7 @@ export function propertyToTSProperties(propertyName, property, schema, allSchema
         // Determine FK type from target schema
         let fkType = 'number';
         const targetSchema = property.target ? allSchemas[property.target] : undefined;
-        const effectiveIdType = targetSchema?.options?.idType ?? 'BigInt';
+        const effectiveIdType = getIdType(targetSchema?.options);
         if (effectiveIdType === 'Uuid' || effectiveIdType === 'String') {
             fkType = 'string';
         }
@@ -226,7 +234,7 @@ export function schemaToInterface(schema, allSchemas, options) {
     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');
+        const pkType = getIdType(schema.options);
         properties.push({
             name: 'id',
             type: PK_TYPE_MAP[pkType] ?? 'number',

package/dist/php/model-generator.js

@@ -42,9 +42,10 @@ function generateBaseModel(name, schema, reader, config) {
     const relations = buildRelations(properties, propertyOrder, modelNamespace);
     const accessors = buildAccessors(expandedProperties);
     const primaryKey = options['primaryKey'] ?? 'id';
-    const idType = options.idType ?? 'BigInt';
+    const rawId = options.id;
+    const idType = typeof rawId === 'string' ? rawId : 'BigInt';
     let keyTypeSection = '';
-    if (idType === 'Uuid' || idType === 'String') {
+    if (idType === 'Uuid' || idType === 'Ulid' || idType === 'String') {
         keyTypeSection = `
     /**
      * The type of the primary key.

package/dist/php/type-mapper.js

@@ -63,13 +63,25 @@ export function toPhpDocType(type, nullable = false) {
     }
     return nullable ? `${phpType}|null` : phpType;
 }
+/** Type categories for rule applicability. */
+const STRING_TYPES = new Set([
+    'String', 'Email', 'Password', 'Text', 'MediumText', 'LongText',
+    'Slug', 'Url', 'Phone', 'Uuid',
+]);
+const NUMERIC_TYPES = new Set(['Int', 'BigInt', 'TinyInt', 'Float', 'Decimal']);
+const ARRAY_TYPES = new Set(['Json']);
 /** Generate validation rules for a property (Store request). */
 export function toStoreRules(property, tableName) {
     const type = property['type'] ?? 'String';
     const nullable = property['nullable'] ?? false;
     const unique = property['unique'] ?? false;
+    const vr = property['rules'];
     const rules = [];
-    rules.push(nullable ? 'nullable' : 'required');
+    // required/nullable — rules.required can override
+    const isRequired = vr?.['required'] !== undefined
+        ? vr['required']
+        : !nullable;
+    rules.push(isRequired ? 'required' : 'nullable');
     switch (type) {
         case 'String':
         case 'Slug':
@@ -143,8 +155,87 @@ export function toStoreRules(property, tableName) {
     if (unique && type !== 'Email') {
         rules.push(`unique:${tableName}`);
     }
+    // Merge explicit validation rules (additive/override)
+    if (vr) {
+        mergeValidationRules(rules, vr, type);
+    }
     return rules;
 }
+/** Merge explicit ValidationRules into the inferred rules array. */
+function mergeValidationRules(rules, vr, type) {
+    const isString = STRING_TYPES.has(type);
+    const isNumeric = NUMERIC_TYPES.has(type);
+    const isArray = ARRAY_TYPES.has(type);
+    if (isString) {
+        if (vr['minLength'] != null)
+            rules.push(`min:${vr['minLength']}`);
+        if (vr['maxLength'] != null) {
+            const idx = rules.findIndex(r => typeof r === 'string' && r.startsWith('max:'));
+            if (idx !== -1)
+                rules[idx] = `max:${vr['maxLength']}`;
+            else
+                rules.push(`max:${vr['maxLength']}`);
+        }
+        if (vr['url'] === true)
+            rules.push('url');
+        if (vr['uuid'] === true)
+            rules.push('uuid');
+        if (vr['ip'] === true)
+            rules.push('ip');
+        if (vr['ipv4'] === true)
+            rules.push('ipv4');
+        if (vr['ipv6'] === true)
+            rules.push('ipv6');
+        if (vr['alpha'] === true)
+            rules.push('alpha');
+        if (vr['alphaNum'] === true)
+            rules.push('alpha_num');
+        if (vr['alphaDash'] === true)
+            rules.push('alpha_dash');
+        if (vr['numeric'] === true)
+            rules.push('numeric');
+        if (vr['lowercase'] === true)
+            rules.push('lowercase');
+        if (vr['uppercase'] === true)
+            rules.push('uppercase');
+        if (vr['digits'] != null)
+            rules.push(`digits:${vr['digits']}`);
+        if (vr['digitsBetween'] != null) {
+            const [a, b] = vr['digitsBetween'];
+            rules.push(`digits_between:${a},${b}`);
+        }
+        if (vr['startsWith'] != null) {
+            const v = vr['startsWith'];
+            rules.push(`starts_with:${Array.isArray(v) ? v.join(',') : v}`);
+        }
+        if (vr['endsWith'] != null) {
+            const v = vr['endsWith'];
+            rules.push(`ends_with:${Array.isArray(v) ? v.join(',') : v}`);
+        }
+    }
+    if (isNumeric) {
+        if (vr['min'] != null)
+            rules.push(`min:${vr['min']}`);
+        if (vr['max'] != null)
+            rules.push(`max:${vr['max']}`);
+        if (vr['between'] != null) {
+            const [a, b] = vr['between'];
+            rules.push(`between:${a},${b}`);
+        }
+        if (vr['gt'] != null)
+            rules.push(`gt:${vr['gt']}`);
+        if (vr['lt'] != null)
+            rules.push(`lt:${vr['lt']}`);
+        if (vr['multipleOf'] != null)
+            rules.push(`multiple_of:${vr['multipleOf']}`);
+    }
+    if (isArray) {
+        if (vr['arrayMin'] != null)
+            rules.push(`min:${vr['arrayMin']}`);
+        if (vr['arrayMax'] != null)
+            rules.push(`max:${vr['arrayMax']}`);
+    }
+}
 /** Generate validation rules for a property (Update request). */
 export function toUpdateRules(property, tableName, modelRouteParam) {
     let rules = toStoreRules(property, tableName);

package/dist/types.d.ts

@@ -57,8 +57,7 @@ export interface ExpandedColumn {
 }
 /** Schema options. */
 export interface SchemaOptions {
-    readonly id?: boolean;
-    readonly idType?: string;
+    readonly id?: boolean | string;
     readonly timestamps?: boolean;
     readonly softDelete?: boolean;
     readonly hidden?: boolean;
@@ -81,6 +80,35 @@ export interface SchemaDefinition {
     readonly values?: readonly EnumValueDefinition[];
     readonly pivotFor?: readonly string[];
 }
+/** Application-level validation rules. Single source of truth for both Laravel validation and Zod schemas. */
+export interface ValidationRules {
+    readonly required?: boolean;
+    readonly minLength?: number;
+    readonly maxLength?: number;
+    readonly url?: boolean;
+    readonly uuid?: boolean;
+    readonly ip?: boolean;
+    readonly ipv4?: boolean;
+    readonly ipv6?: boolean;
+    readonly alpha?: boolean;
+    readonly alphaNum?: boolean;
+    readonly alphaDash?: boolean;
+    readonly numeric?: boolean;
+    readonly digits?: number;
+    readonly digitsBetween?: readonly [number, number];
+    readonly startsWith?: string | readonly string[];
+    readonly endsWith?: string | readonly string[];
+    readonly lowercase?: boolean;
+    readonly uppercase?: boolean;
+    readonly min?: number;
+    readonly max?: number;
+    readonly between?: readonly [number, number];
+    readonly gt?: number;
+    readonly lt?: number;
+    readonly multipleOf?: number;
+    readonly arrayMin?: number;
+    readonly arrayMax?: number;
+}
 /** Property definition within a schema. */
 export interface PropertyDefinition {
     readonly type: string;
@@ -100,6 +128,7 @@ export interface PropertyDefinition {
     readonly precision?: number;
     readonly scale?: number;
     readonly pattern?: string;
+    readonly rules?: ValidationRules;
     readonly enum?: string | readonly string[];
     readonly relation?: string;
     readonly target?: string;

package/dist/zod-generator.js

@@ -26,11 +26,112 @@ function getMultiLocaleDisplayName(value, locales, fallbackLocale, defaultValue)
     }
     return result;
 }
+/** Type categories for Zod rule applicability. */
+const ZOD_STRING_TYPES = new Set([
+    'String', 'Email', 'Password', 'Text', 'MediumText', 'LongText',
+    'Slug', 'Url', 'Phone', 'Uuid',
+]);
+const ZOD_NUMERIC_TYPES = new Set(['Int', 'BigInt', 'TinyInt', 'Float', 'Decimal']);
+/** Replace an existing Zod method call or append it. */
+function replaceZodMethod(schema, methodName, replacement) {
+    const regex = new RegExp(`\\.${methodName}\\([^)]*\\)`);
+    if (regex.test(schema)) {
+        return schema.replace(regex, replacement);
+    }
+    return schema + replacement;
+}
+/** Apply validation rules to a Zod schema string (additive/override). */
+function applyZodRules(schema, rules, type) {
+    const isString = ZOD_STRING_TYPES.has(type);
+    const isNumeric = ZOD_NUMERIC_TYPES.has(type);
+    if (isString) {
+        if (rules.minLength != null) {
+            schema = replaceZodMethod(schema, 'min', `.min(${rules.minLength})`);
+        }
+        if (rules.maxLength != null) {
+            schema = replaceZodMethod(schema, 'max', `.max(${rules.maxLength})`);
+        }
+        if (rules.url)
+            schema += '.url()';
+        if (rules.uuid)
+            schema += '.uuid()';
+        if (rules.ip)
+            schema += '.ip()';
+        if (rules.ipv4)
+            schema += `.ip({ version: "v4" })`;
+        if (rules.ipv6)
+            schema += `.ip({ version: "v6" })`;
+        if (rules.alpha)
+            schema += `.regex(/^[a-zA-Z]+$/)`;
+        if (rules.alphaNum)
+            schema += `.regex(/^[a-zA-Z0-9]+$/)`;
+        if (rules.alphaDash)
+            schema += `.regex(/^[a-zA-Z0-9_-]+$/)`;
+        if (rules.numeric)
+            schema += `.regex(/^[0-9]+$/)`;
+        if (rules.lowercase)
+            schema += `.regex(/^[^A-Z]*$/)`;
+        if (rules.uppercase)
+            schema += `.regex(/^[^a-z]*$/)`;
+        if (rules.digits != null) {
+            schema += `.length(${rules.digits}).regex(/^[0-9]+$/)`;
+        }
+        if (rules.digitsBetween != null) {
+            const [a, b] = rules.digitsBetween;
+            schema = replaceZodMethod(schema, 'min', `.min(${a})`);
+            schema = replaceZodMethod(schema, 'max', `.max(${b})`);
+            schema += `.regex(/^[0-9]+$/)`;
+        }
+        if (rules.startsWith != null) {
+            const v = rules.startsWith;
+            if (Array.isArray(v)) {
+                const escaped = v.map(s => s.replace(/[.*+?^${}()|[\]\\/]/g, '\\$&'));
+                schema += `.regex(/^(${escaped.join('|')})/)`;
+            }
+            else {
+                schema += `.startsWith('${v}')`;
+            }
+        }
+        if (rules.endsWith != null) {
+            const v = rules.endsWith;
+            if (Array.isArray(v)) {
+                const escaped = v.map(s => s.replace(/[.*+?^${}()|[\]\\/]/g, '\\$&'));
+                schema += `.regex(/(${escaped.join('|')})$/)`;
+            }
+            else {
+                schema += `.endsWith('${v}')`;
+            }
+        }
+    }
+    if (isNumeric) {
+        if (rules.min != null) {
+            schema = replaceZodMethod(schema, 'gte', `.gte(${rules.min})`);
+        }
+        if (rules.max != null) {
+            schema = replaceZodMethod(schema, 'lte', `.lte(${rules.max})`);
+        }
+        if (rules.between != null) {
+            const [a, b] = rules.between;
+            schema = replaceZodMethod(schema, 'gte', `.gte(${a})`);
+            schema = replaceZodMethod(schema, 'lte', `.lte(${b})`);
+        }
+        if (rules.gt != null)
+            schema += `.gt(${rules.gt})`;
+        if (rules.lt != null)
+            schema += `.lt(${rules.lt})`;
+        if (rules.multipleOf != null)
+            schema += `.multipleOf(${rules.multipleOf})`;
+    }
+    return schema;
+}
 /**
  * Generate Zod schema string for a property type.
  */
 function getZodSchemaForType(propDef, _fieldName, options) {
-    const isNullable = propDef.nullable ?? false;
+    // rules.required overrides nullable inference
+    const isNullable = propDef.rules?.required !== undefined
+        ? !propDef.rules.required
+        : (propDef.nullable ?? false);
     let schema = '';
     // Check for simple custom types
     const simpleType = options.customTypes.simple[propDef.type];
@@ -39,6 +140,9 @@ function getZodSchemaForType(propDef, _fieldName, options) {
         if (simpleType.length) {
             schema += `.max(${simpleType.length})`;
         }
+        if (propDef.rules) {
+            schema = applyZodRules(schema, propDef.rules, propDef.type);
+        }
         if (isNullable) {
             schema += '.optional().nullable()';
         }
@@ -128,12 +232,17 @@ function getZodSchemaForType(propDef, _fieldName, options) {
         default:
             schema = 'z.string()';
     }
-    if (isNullable && schema) {
-        schema += '.optional().nullable()';
+    // Apply validation rules (additive/override)
+    if (propDef.rules && schema) {
+        schema = applyZodRules(schema, propDef.rules, propDef.type);
     }
+    // Pattern (before nullable so validators chain correctly)
     if (propDef.pattern && schema) {
         schema += `.regex(/${propDef.pattern}/)`;
     }
+    if (isNullable && schema) {
+        schema += '.optional().nullable()';
+    }
     return schema;
 }
 /**

package/package.json

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