@famgia/omnify-typescript 0.0.25 → 0.0.27

package/dist/{chunk-4NNFIIZ4.js → chunk-HPORV62S.js}

@@ -117,6 +117,18 @@ function propertyToTSProperties(propertyName, property, allSchemas, options = {}
           comment: `${displayName ?? propertyName} (${field.suffix})`
         });
       }
+      if (customType.accessors) {
+        for (const accessor of customType.accessors) {
+          const accessorName = `${propertyName}_${toSnakeCase(accessor.name)}`;
+          expandedProps.push({
+            name: accessorName,
+            type: "string | null",
+            optional: true,
+            readonly: isReadonly,
+            comment: `${displayName ?? propertyName} (computed)`
+          });
+        }
+      }
       return expandedProps;
     }
     if (customType && !customType.compound) {
@@ -174,8 +186,22 @@ function propertyToTSProperties(propertyName, property, allSchemas, options = {}
 function propertyToTSProperty(propertyName, property, allSchemas, options = {}) {
   return propertyToTSProperties(propertyName, property, allSchemas, options)[0];
 }
+function extractTypeReferences(type, allSchemaNames) {
+  const primitives = /* @__PURE__ */ 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;
+}
 function schemaToInterface(schema, allSchemas, options = {}) {
   const properties = [];
+  const allSchemaNames = new Set(Object.keys(allSchemas).filter((name) => allSchemas[name].kind !== "enum"));
   if (schema.options?.id !== false) {
     const pkType = schema.options?.idType ?? "BigInt";
     properties.push({
@@ -218,11 +244,20 @@ function schemaToInterface(schema, allSchemas, options = {}) {
       comment: "Soft delete timestamp"
     });
   }
+  const dependencySet = /* @__PURE__ */ new Set();
+  for (const prop of properties) {
+    for (const ref of extractTypeReferences(prop.type, allSchemaNames)) {
+      if (ref !== schema.name) {
+        dependencySet.add(ref);
+      }
+    }
+  }
   const schemaDisplayName = resolveDisplayName(schema.displayName, options);
   return {
     name: toInterfaceName(schema.name),
     properties,
-    comment: schemaDisplayName ?? schema.name
+    comment: schemaDisplayName ?? schema.name,
+    dependencies: dependencySet.size > 0 ? Array.from(dependencySet).sort() : void 0
   };
 }
 function formatProperty(property) {
@@ -279,11 +314,18 @@ function parseEnumValue(value, options = {}) {
       // No label or extra - will fallback to value
     };
   }
-  const resolvedLabel = resolveDisplayName2(value.label, options);
+  let label;
+  if (value.label !== void 0) {
+    if (options.multiLocale && typeof value.label === "object") {
+      label = value.label;
+    } else {
+      label = resolveDisplayName2(value.label, options);
+    }
+  }
   return {
     name: toEnumMemberName(value.value),
     value: value.value,
-    label: resolvedLabel,
+    label,
     extra: value.extra
   };
 }
@@ -313,6 +355,9 @@ function generateEnums(schemas, options = {}) {
   }
   return enums;
 }
+function isMultiLocaleLabel(label) {
+  return label !== void 0 && typeof label === "object";
+}
 function formatEnum(enumDef) {
   const { name, values, comment } = enumDef;
   const parts = [];
@@ -343,28 +388,64 @@ ${enumValues}
 
 `);
   const hasLabels = values.some((v) => v.label !== void 0);
+  const hasMultiLocale = values.some((v) => isMultiLocaleLabel(v.label));
   if (hasLabels) {
-    const labelEntries = values.filter((v) => v.label !== void 0).map((v) => `  [${name}.${v.name}]: '${v.label}',`).join("\n");
-    parts.push(`const ${lowerFirst(name)}Labels: Partial<Record<${name}, string>> = {
+    if (hasMultiLocale) {
+      const labelEntries = values.filter((v) => v.label !== void 0).map((v) => {
+        if (isMultiLocaleLabel(v.label)) {
+          const locales = Object.entries(v.label).map(([locale, text]) => `${locale}: '${text}'`).join(", ");
+          return `  [${name}.${v.name}]: { ${locales} },`;
+        }
+        return `  [${name}.${v.name}]: { default: '${v.label}' },`;
+      }).join("\n");
+      parts.push(`const ${lowerFirst(name)}Labels: Partial<Record<${name}, Record<string, string>>> = {
 ${labelEntries}
 };
 
 `);
-  }
-  parts.push(`/** Get label for ${name} value (fallback to value if no label) */
+      parts.push(`/** Get label for ${name} value with locale support */
 `);
-  parts.push(`export function get${name}Label(value: ${name}): string {
+      parts.push(`export function get${name}Label(value: ${name}, locale?: string): string {
 `);
-  if (hasLabels) {
-    parts.push(`  return ${lowerFirst(name)}Labels[value] ?? value;
+      parts.push(`  const labels = ${lowerFirst(name)}Labels[value];
+`);
+      parts.push(`  if (!labels) return value;
 `);
+      parts.push(`  if (locale && labels[locale]) return labels[locale];
+`);
+      parts.push(`  return Object.values(labels)[0] ?? value;
+`);
+      parts.push(`}
+
+`);
+    } else {
+      const labelEntries = values.filter((v) => v.label !== void 0).map((v) => `  [${name}.${v.name}]: '${v.label}',`).join("\n");
+      parts.push(`const ${lowerFirst(name)}Labels: Partial<Record<${name}, string>> = {
+${labelEntries}
+};
+
+`);
+      parts.push(`/** Get label for ${name} value (fallback to value if no label) */
+`);
+      parts.push(`export function get${name}Label(value: ${name}): string {
+`);
+      parts.push(`  return ${lowerFirst(name)}Labels[value] ?? value;
+`);
+      parts.push(`}
+
+`);
+    }
   } else {
+    parts.push(`/** Get label for ${name} value (returns value as-is) */
+`);
+    parts.push(`export function get${name}Label(value: ${name}): string {
+`);
     parts.push(`  return value;
 `);
-  }
-  parts.push(`}
+    parts.push(`}
 
 `);
+  }
   const hasExtra = values.some((v) => v.extra !== void 0);
   if (hasExtra) {
     const extraEntries = values.filter((v) => v.extra !== void 0).map((v) => `  [${name}.${v.name}]: ${JSON.stringify(v.extra)},`).join("\n");
@@ -486,6 +567,347 @@ function extractInlineEnums(schemas, options = {}) {
   return typeAliases;
 }
 
+// src/validation-templates.ts
+var DEFAULT_VALIDATION_TEMPLATES = {
+  required: {
+    ja: "${displayName}\u306F\u5FC5\u9808\u3067\u3059",
+    en: "${displayName} is required",
+    vi: "${displayName} l\xE0 b\u1EAFt bu\u1ED9c",
+    ko: "${displayName}\uC740(\uB294) \uD544\uC218\uC785\uB2C8\uB2E4",
+    zh: "${displayName}\u4E3A\u5FC5\u586B\u9879"
+  },
+  minLength: {
+    ja: "${displayName}\u306F${min}\u6587\u5B57\u4EE5\u4E0A\u3067\u5165\u529B\u3057\u3066\u304F\u3060\u3055\u3044",
+    en: "${displayName} must be at least ${min} characters",
+    vi: "${displayName} ph\u1EA3i c\xF3 \xEDt nh\u1EA5t ${min} k\xFD t\u1EF1",
+    ko: "${displayName}\uC740(\uB294) ${min}\uC790 \uC774\uC0C1\uC774\uC5B4\uC57C \uD569\uB2C8\uB2E4",
+    zh: "${displayName}\u81F3\u5C11\u9700\u8981${min}\u4E2A\u5B57\u7B26"
+  },
+  maxLength: {
+    ja: "${displayName}\u306F${max}\u6587\u5B57\u4EE5\u5185\u3067\u5165\u529B\u3057\u3066\u304F\u3060\u3055\u3044",
+    en: "${displayName} must be at most ${max} characters",
+    vi: "${displayName} t\u1ED1i \u0111a ${max} k\xFD t\u1EF1",
+    ko: "${displayName}\uC740(\uB294) ${max}\uC790 \uC774\uD558\uC5EC\uC57C \uD569\uB2C8\uB2E4",
+    zh: "${displayName}\u4E0D\u80FD\u8D85\u8FC7${max}\u4E2A\u5B57\u7B26"
+  },
+  min: {
+    ja: "${displayName}\u306F${min}\u4EE5\u4E0A\u306E\u5024\u3092\u5165\u529B\u3057\u3066\u304F\u3060\u3055\u3044",
+    en: "${displayName} must be at least ${min}",
+    vi: "${displayName} ph\u1EA3i l\u1EDBn h\u01A1n ho\u1EB7c b\u1EB1ng ${min}",
+    ko: "${displayName}\uC740(\uB294) ${min} \uC774\uC0C1\uC774\uC5B4\uC57C \uD569\uB2C8\uB2E4",
+    zh: "${displayName}\u4E0D\u80FD\u5C0F\u4E8E${min}"
+  },
+  max: {
+    ja: "${displayName}\u306F${max}\u4EE5\u4E0B\u306E\u5024\u3092\u5165\u529B\u3057\u3066\u304F\u3060\u3055\u3044",
+    en: "${displayName} must be at most ${max}",
+    vi: "${displayName} ph\u1EA3i nh\u1ECF h\u01A1n ho\u1EB7c b\u1EB1ng ${max}",
+    ko: "${displayName}\uC740(\uB294) ${max} \uC774\uD558\uC5EC\uC57C \uD569\uB2C8\uB2E4",
+    zh: "${displayName}\u4E0D\u80FD\u5927\u4E8E${max}"
+  },
+  email: {
+    ja: "${displayName}\u306E\u5F62\u5F0F\u304C\u6B63\u3057\u304F\u3042\u308A\u307E\u305B\u3093",
+    en: "${displayName} is not a valid email address",
+    vi: "${displayName} kh\xF4ng ph\u1EA3i l\xE0 \u0111\u1ECBa ch\u1EC9 email h\u1EE3p l\u1EC7",
+    ko: "${displayName} \uD615\uC2DD\uC774 \uC62C\uBC14\uB974\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4",
+    zh: "${displayName}\u4E0D\u662F\u6709\u6548\u7684\u90AE\u7BB1\u5730\u5740"
+  },
+  url: {
+    ja: "${displayName}\u306F\u6709\u52B9\u306AURL\u3067\u306F\u3042\u308A\u307E\u305B\u3093",
+    en: "${displayName} is not a valid URL",
+    vi: "${displayName} kh\xF4ng ph\u1EA3i l\xE0 URL h\u1EE3p l\u1EC7",
+    ko: "${displayName}\uC740(\uB294) \uC720\uD6A8\uD55C URL\uC774 \uC544\uB2D9\uB2C8\uB2E4",
+    zh: "${displayName}\u4E0D\u662F\u6709\u6548\u7684URL"
+  },
+  pattern: {
+    ja: "${displayName}\u306E\u5F62\u5F0F\u304C\u6B63\u3057\u304F\u3042\u308A\u307E\u305B\u3093",
+    en: "${displayName} format is invalid",
+    vi: "${displayName} kh\xF4ng \u0111\xFAng \u0111\u1ECBnh d\u1EA1ng",
+    ko: "${displayName} \uD615\uC2DD\uC774 \uC62C\uBC14\uB974\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4",
+    zh: "${displayName}\u683C\u5F0F\u4E0D\u6B63\u786E"
+  },
+  enum: {
+    ja: "${displayName}\u306E\u5024\u304C\u7121\u52B9\u3067\u3059",
+    en: "${displayName} has an invalid value",
+    vi: "${displayName} c\xF3 gi\xE1 tr\u1ECB kh\xF4ng h\u1EE3p l\u1EC7",
+    ko: "${displayName} \uAC12\uC774 \uC720\uD6A8\uD558\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4",
+    zh: "${displayName}\u7684\u503C\u65E0\u6548"
+  }
+};
+function mergeValidationTemplates(userTemplates) {
+  if (!userTemplates) {
+    return DEFAULT_VALIDATION_TEMPLATES;
+  }
+  const merged = {
+    required: { ...DEFAULT_VALIDATION_TEMPLATES.required },
+    minLength: { ...DEFAULT_VALIDATION_TEMPLATES.minLength },
+    maxLength: { ...DEFAULT_VALIDATION_TEMPLATES.maxLength },
+    min: { ...DEFAULT_VALIDATION_TEMPLATES.min },
+    max: { ...DEFAULT_VALIDATION_TEMPLATES.max },
+    email: { ...DEFAULT_VALIDATION_TEMPLATES.email },
+    url: { ...DEFAULT_VALIDATION_TEMPLATES.url },
+    pattern: { ...DEFAULT_VALIDATION_TEMPLATES.pattern },
+    enum: { ...DEFAULT_VALIDATION_TEMPLATES.enum }
+  };
+  for (const [key, value] of Object.entries(userTemplates)) {
+    if (value && key in merged) {
+      merged[key] = {
+        ...merged[key],
+        ...value
+      };
+    }
+  }
+  return merged;
+}
+function formatValidationMessage(template, vars) {
+  let result = template;
+  for (const [key, value] of Object.entries(vars)) {
+    result = result.replace(new RegExp(`\\$\\{${key}\\}`, "g"), String(value));
+  }
+  return result;
+}
+function getValidationMessages(templates, ruleType, locales, vars, fallbackLocale) {
+  const ruleTemplates = templates[ruleType];
+  const messages = {};
+  for (const locale of locales) {
+    const template = ruleTemplates[locale] ?? (fallbackLocale ? ruleTemplates[fallbackLocale] : void 0) ?? ruleTemplates["en"] ?? "";
+    messages[locale] = formatValidationMessage(template, vars);
+  }
+  return messages;
+}
+
+// src/rules-generator.ts
+function getMultiLocaleDisplayName(value, locales, fallbackLocale, defaultValue) {
+  if (!value) {
+    const result2 = {};
+    for (const locale of locales) {
+      result2[locale] = defaultValue;
+    }
+    return result2;
+  }
+  if (typeof value === "string") {
+    const result2 = {};
+    for (const locale of locales) {
+      result2[locale] = value;
+    }
+    return result2;
+  }
+  const result = {};
+  for (const locale of locales) {
+    result[locale] = value[locale] ?? value[fallbackLocale] ?? value["en"] ?? defaultValue;
+  }
+  return result;
+}
+function generatePropertyRules(propName, property, displayName, locales, fallbackLocale, templates) {
+  const rules = [];
+  const propDef = property;
+  if (!propDef.nullable) {
+    rules.push({
+      required: true,
+      message: getValidationMessages(templates, "required", locales, { displayName: "${displayName}" }, fallbackLocale)
+    });
+  }
+  if (property.type === "Email") {
+    rules.push({
+      type: "email",
+      message: getValidationMessages(templates, "email", locales, { displayName: "${displayName}" }, fallbackLocale)
+    });
+  }
+  if (property.type === "String" || property.type === "Text" || property.type === "LongText") {
+    if (propDef.minLength) {
+      rules.push({
+        min: propDef.minLength,
+        message: getValidationMessages(templates, "minLength", locales, { displayName: "${displayName}", min: propDef.minLength }, fallbackLocale)
+      });
+    }
+    if (propDef.maxLength || propDef.length) {
+      const max = propDef.maxLength ?? propDef.length;
+      rules.push({
+        max,
+        message: getValidationMessages(templates, "maxLength", locales, { displayName: "${displayName}", max }, fallbackLocale)
+      });
+    }
+  }
+  if (property.type === "Int" || property.type === "BigInt" || property.type === "Float") {
+    if (propDef.min !== void 0) {
+      rules.push({
+        type: property.type === "Float" ? "number" : "integer",
+        min: propDef.min,
+        message: getValidationMessages(templates, "min", locales, { displayName: "${displayName}", min: propDef.min }, fallbackLocale)
+      });
+    }
+    if (propDef.max !== void 0) {
+      rules.push({
+        type: property.type === "Float" ? "number" : "integer",
+        max: propDef.max,
+        message: getValidationMessages(templates, "max", locales, { displayName: "${displayName}", max: propDef.max }, fallbackLocale)
+      });
+    }
+  }
+  if (propDef.pattern) {
+    rules.push({
+      pattern: propDef.pattern,
+      message: getValidationMessages(templates, "pattern", locales, { displayName: "${displayName}" }, fallbackLocale)
+    });
+  }
+  for (const rule of rules) {
+    const newMessage = {};
+    for (const locale of locales) {
+      const msg = rule.message[locale];
+      if (msg) {
+        newMessage[locale] = msg.replace(/\$\{displayName\}/g, displayName[locale] ?? propName);
+      }
+    }
+    rule.message = newMessage;
+  }
+  return rules;
+}
+function generateModelRules(schema, locales, fallbackLocale, templates) {
+  const modelDisplayName = getMultiLocaleDisplayName(
+    schema.displayName,
+    locales,
+    fallbackLocale,
+    schema.name
+  );
+  const properties = {};
+  if (schema.properties) {
+    for (const [propName, property] of Object.entries(schema.properties)) {
+      const propDef = property;
+      const displayName = getMultiLocaleDisplayName(
+        propDef.displayName,
+        locales,
+        fallbackLocale,
+        propName
+      );
+      properties[propName] = {
+        displayName,
+        rules: generatePropertyRules(propName, property, displayName, locales, fallbackLocale, templates)
+      };
+    }
+  }
+  return {
+    displayName: modelDisplayName,
+    properties
+  };
+}
+function formatRulesFile(schemaName, rules) {
+  const parts = [];
+  parts.push(`/**
+ * Auto-generated validation rules and metadata for ${schemaName}.
+ * DO NOT EDIT - This file is automatically generated and will be overwritten.
+ */
+
+`);
+  parts.push(`export interface LocaleMap { [locale: string]: string; }
+
+`);
+  parts.push(`export interface ValidationRule {
+  required?: boolean;
+  type?: 'string' | 'number' | 'email' | 'url' | 'integer';
+  min?: number;
+  max?: number;
+  len?: number;
+  pattern?: RegExp;
+  message: LocaleMap;
+}
+
+`);
+  parts.push(`/** Display name for ${schemaName} */
+`);
+  parts.push(`export const ${schemaName}DisplayName: LocaleMap = ${JSON.stringify(rules.displayName, null, 2)};
+
+`);
+  parts.push(`/** Property display names for ${schemaName} */
+`);
+  parts.push(`export const ${schemaName}PropertyDisplayNames: Record<string, LocaleMap> = {
+`);
+  for (const [propName, propRules] of Object.entries(rules.properties)) {
+    parts.push(`  ${propName}: ${JSON.stringify(propRules.displayName)},
+`);
+  }
+  parts.push(`};
+
+`);
+  parts.push(`/** Validation rules for ${schemaName} (Ant Design compatible) */
+`);
+  parts.push(`export const ${schemaName}Rules: Record<string, ValidationRule[]> = {
+`);
+  for (const [propName, propRules] of Object.entries(rules.properties)) {
+    if (propRules.rules.length > 0) {
+      parts.push(`  ${propName}: [
+`);
+      for (const rule of propRules.rules) {
+        const ruleObj = {};
+        if (rule.required) ruleObj.required = true;
+        if (rule.type) ruleObj.type = `'${rule.type}'`;
+        if (rule.min !== void 0) ruleObj.min = rule.min;
+        if (rule.max !== void 0) ruleObj.max = rule.max;
+        if (rule.pattern) ruleObj.pattern = `/${rule.pattern}/`;
+        ruleObj.message = rule.message;
+        const ruleStr = Object.entries(ruleObj).map(([k, v]) => {
+          if (k === "type") return `${k}: ${v}`;
+          if (k === "pattern") return `${k}: ${v}`;
+          return `${k}: ${JSON.stringify(v)}`;
+        }).join(", ");
+        parts.push(`    { ${ruleStr} },
+`);
+      }
+      parts.push(`  ],
+`);
+    }
+  }
+  parts.push(`};
+
+`);
+  parts.push(`/** Get validation rules with messages for a specific locale */
+`);
+  parts.push(`export function get${schemaName}Rules(locale: string): Record<string, Array<{ required?: boolean; type?: string; min?: number; max?: number; pattern?: RegExp; message: string }>> {
+  const result: Record<string, Array<{ required?: boolean; type?: string; min?: number; max?: number; pattern?: RegExp; message: string }>> = {};
+  for (const [prop, rules] of Object.entries(${schemaName}Rules)) {
+    result[prop] = rules.map(rule => ({
+      ...rule,
+      message: rule.message[locale] ?? rule.message['en'] ?? '',
+    }));
+  }
+  return result;
+}
+
+`);
+  parts.push(`/** Get display name for a specific locale */
+`);
+  parts.push(`export function get${schemaName}DisplayName(locale: string): string {
+  return ${schemaName}DisplayName[locale] ?? ${schemaName}DisplayName['en'] ?? '${schemaName}';
+}
+
+`);
+  parts.push(`/** Get property display name for a specific locale */
+`);
+  parts.push(`export function get${schemaName}PropertyDisplayName(property: string, locale: string): string {
+  const names = ${schemaName}PropertyDisplayNames[property];
+  return names?.[locale] ?? names?.['en'] ?? property;
+}
+`);
+  return parts.join("");
+}
+function generateRulesFiles(schemas, options = {}) {
+  const files = [];
+  const localeConfig = options.localeConfig;
+  const locales = [...localeConfig?.locales ?? ["en"]];
+  const fallbackLocale = localeConfig?.fallbackLocale ?? "en";
+  const templates = mergeValidationTemplates(options.validationTemplates);
+  for (const schema of Object.values(schemas)) {
+    if (schema.kind === "enum") continue;
+    const rules = generateModelRules(schema, locales, fallbackLocale, templates);
+    const content = formatRulesFile(schema.name, rules);
+    files.push({
+      filePath: `rules/${schema.name}.rules.ts`,
+      content,
+      types: [`${schema.name}Rules`, `${schema.name}DisplayName`],
+      overwrite: true
+    });
+  }
+  return files;
+}
+
 // src/generator.ts
 var DEFAULT_OPTIONS = {
   readonly: true,
@@ -517,6 +939,13 @@ function generateBaseInterfaceFile(schemaName, schemas, options) {
     throw new Error(`Interface not found for schema: ${schemaName}`);
   }
   const parts = [generateBaseHeader()];
+  if (iface.dependencies && iface.dependencies.length > 0) {
+    for (const dep of iface.dependencies) {
+      parts.push(`import type { ${dep} } from './${dep}.js';
+`);
+    }
+    parts.push("\n");
+  }
   parts.push(formatInterface(iface));
   parts.push("\n");
   return {
@@ -633,11 +1062,11 @@ function generateIndexFile(schemas, enums, typeAliases) {
 function generateTypeScript(schemas, options = {}) {
   const opts = { ...DEFAULT_OPTIONS, ...options };
   const files = [];
-  const enums = generateEnums(schemas);
+  const enums = generateEnums(schemas, opts);
   for (const enumDef of enums) {
     files.push(generateEnumFile(enumDef));
   }
-  const typeAliases = extractInlineEnums(schemas);
+  const typeAliases = extractInlineEnums(schemas, opts);
   for (const alias of typeAliases) {
     files.push(generateTypeAliasFile(alias));
   }
@@ -649,6 +1078,10 @@ function generateTypeScript(schemas, options = {}) {
     if (schema.kind === "enum") continue;
     files.push(generateModelFile(schema.name));
   }
+  if (opts.generateRules) {
+    const rulesFiles = generateRulesFiles(schemas, opts);
+    files.push(...rulesFiles);
+  }
   files.push(generateIndexFile(schemas, enums, typeAliases));
   return files;
 }
@@ -670,6 +1103,12 @@ export {
   enumToUnionType,
   formatTypeAlias,
   extractInlineEnums,
+  DEFAULT_VALIDATION_TEMPLATES,
+  mergeValidationTemplates,
+  formatValidationMessage,
+  getValidationMessages,
+  generateModelRules,
+  generateRulesFiles,
   generateTypeScript
 };
-//# sourceMappingURL=chunk-4NNFIIZ4.js.map
+//# sourceMappingURL=chunk-HPORV62S.js.map