@omnifyjp/omnify 0.3.7 → 0.4.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@omnifyjp/omnify",
-  "version": "0.3.7",
+  "version": "0.4.1",
   "description": "Schema-driven code generation for Laravel, TypeScript, and SQL",
   "license": "MIT",
   "repository": {
@@ -36,10 +36,10 @@
     "zod": "^3.24.0"
   },
   "optionalDependencies": {
-    "@omnifyjp/omnify-darwin-arm64": "0.3.7",
-    "@omnifyjp/omnify-darwin-x64": "0.3.7",
-    "@omnifyjp/omnify-linux-x64": "0.3.7",
-    "@omnifyjp/omnify-linux-arm64": "0.3.7",
-    "@omnifyjp/omnify-win32-x64": "0.3.7"
+    "@omnifyjp/omnify-darwin-arm64": "0.4.1",
+    "@omnifyjp/omnify-darwin-x64": "0.4.1",
+    "@omnifyjp/omnify-linux-x64": "0.4.1",
+    "@omnifyjp/omnify-linux-arm64": "0.4.1",
+    "@omnifyjp/omnify-win32-x64": "0.4.1"
   }
 }

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

@@ -55,7 +55,7 @@ export type ReferentialAction =
 export type SchemaKind = "object" | "enum" | "partial" | "extend" | "pivot";
 
 /** Primary key column type. */
-export type IdType = "BigInt" | "Int" | "Uuid" | "String";
+export type IdType = "BigInt" | "Int" | "Uuid" | "Ulid" | "String";
 
 /** Database index type. */
 export type IndexType = "btree" | "hash" | "fulltext" | "spatial" | "gin" | "gist";
@@ -97,36 +97,85 @@ export interface PivotFieldDefinition {
   displayName?: LocalizedString;
 }
 
-/** Application-level validation rules. */
+/**
+ * Application-level validation rules. Single source of truth for both Laravel validation and Zod schemas.
+ * Rules are **additive** — generators infer base rules from type, `rules:` adds/overrides on top.
+ *
+ * **Mutually exclusive groups** (using more than one triggers a validation error):
+ * - `lowercase` + `uppercase`
+ * - `alpha` / `alphaNum` / `alphaDash` / `numeric` (pick one)
+ * - `url` + `uuid`
+ * - `min` + `gt` (both define lower bound)
+ * - `max` + `lt` (both define upper bound)
+ * - `between` + any of `min`/`max`/`gt`/`lt`
+ * - `digits` + `digitsBetween`
+ *
+ * **Redundancy warnings**:
+ * - `ip` + `ipv4` or `ip` + `ipv6` → ipv4/ipv6 is redundant
+ *
+ * **Cross-field**: `maxLength` vs property `length` — if both set and differ, omnify warns.
+ */
 export interface ValidationRules {
+  /** [All types] Override required/nullable inference. */
   required?: boolean;
-  // String rules
+
+  // ── String rules (apply to: String, Email, Password, Text, MediumText, LongText, Uuid) ──
+
+  /** Minimum string length. Must be >= 0. Must be <= maxLength when both set. */
   minLength?: number;
+  /** Maximum string length. Must be >= 1. Overrides length-based max. */
   maxLength?: number;
+  /** Must be valid URL. Mutually exclusive with uuid. */
   url?: boolean;
+  /** Must be valid UUID. Mutually exclusive with url. */
   uuid?: boolean;
+  /** Must be valid IP (v4 or v6). Makes ipv4/ipv6 redundant. */
   ip?: boolean;
+  /** Must be valid IPv4. Redundant when ip is set. */
   ipv4?: boolean;
+  /** Must be valid IPv6. Redundant when ip is set. */
   ipv6?: boolean;
+  /** Only letters (a-z, A-Z). Mutually exclusive with alphaNum, alphaDash, numeric. */
   alpha?: boolean;
+  /** Only letters and numbers. Mutually exclusive with alpha, alphaDash, numeric. */
   alphaNum?: boolean;
+  /** Letters, numbers, dash, underscore. Mutually exclusive with alpha, alphaNum, numeric. */
   alphaDash?: boolean;
+  /** Only digits (0-9) as string. Mutually exclusive with alpha, alphaNum, alphaDash. */
   numeric?: boolean;
+  /** Exactly N digits. Must be >= 1. Mutually exclusive with digitsBetween. */
   digits?: number;
+  /** Digit count between [min, max]. Both >= 1, min <= max. Mutually exclusive with digits. */
   digitsBetween?: [number, number];
+  /** Must start with prefix(es). */
   startsWith?: string | string[];
+  /** Must end with suffix(es). */
   endsWith?: string | string[];
+  /** Must be entirely lowercase. Mutually exclusive with uppercase. */
   lowercase?: boolean;
+  /** Must be entirely uppercase. Mutually exclusive with lowercase. */
   uppercase?: boolean;
-  // Numeric rules
+
+  // ── Numeric rules (apply to: TinyInt, Int, BigInt, Float, Decimal) ──
+
+  /** Minimum value (inclusive). Must be <= max. Mutually exclusive with gt. Redundant with between. */
   min?: number;
+  /** Maximum value (inclusive). Must be >= min. Mutually exclusive with lt. Redundant with between. */
   max?: number;
+  /** Value between [min, max] inclusive. min <= max. Do not combine with min/max/gt/lt. */
   between?: [number, number];
+  /** Greater than (exclusive). Must be < lt. Mutually exclusive with min. Redundant with between. */
   gt?: number;
+  /** Less than (exclusive). Must be > gt. Mutually exclusive with max. Redundant with between. */
   lt?: number;
+  /** Must be a multiple of value. Must be > 0. */
   multipleOf?: number;
-  // Array rules
+
+  // ── Array rules (apply to: Json) ──
+
+  /** Minimum items. Must be >= 0. Must be <= arrayMax when both set. */
   arrayMin?: number;
+  /** Maximum items. Must be >= 1. Must be >= arrayMin when both set. */
   arrayMax?: number;
 }
 
@@ -194,9 +243,8 @@ export interface IndexDefinition {
 
 /** Schema-level configuration options. */
 export interface SchemaOptions {
-  /** Whether to auto-generate an 'id' primary key column. */
-  id?: boolean;
-  idType?: IdType;
+  /** ID column: true (BigInt), false (no ID), or type string (BigInt, Int, Uuid, String). */
+  id?: boolean | IdType;
   /** Custom primary key — single column or composite. */
   primaryKey?: string | string[];
   timestamps?: boolean;
@@ -204,7 +252,6 @@ export interface SchemaOptions {
   /** Unique constraints — column list or array of column lists. */
   unique?: string[] | string[][];
   indexes?: IndexDefinition[];
-  translations?: boolean;
   tableName?: string;
   authenticatable?: boolean;
   hidden?: boolean;