@famgia/omnify-core 0.0.14 → 0.0.16

package/dist/index.cjs

@@ -47,7 +47,7 @@ __export(index_exports, {
   createVersionStore: () => createVersionStore,
   duplicateSchemaError: () => duplicateSchemaError,
   ensureFileSchema: () => ensureFileSchema,
-  err: () => import_omnify_types.err,
+  err: () => import_omnify_types3.err,
   expandProperty: () => expandProperty,
   expandSchema: () => expandSchema,
   expandSchemaProperties: () => expandSchemaProperties,
@@ -88,7 +88,7 @@ __export(index_exports, {
   missingConfigFieldError: () => missingConfigFieldError,
   missingFieldError: () => missingFieldError,
   notImplementedError: () => notImplementedError,
-  ok: () => import_omnify_types.ok,
+  ok: () => import_omnify_types3.ok,
   outputWriteError: () => outputWriteError,
   parseJsonSchema: () => parseJsonSchema,
   parseYamlSchema: () => parseYamlSchema,
@@ -110,7 +110,7 @@ __export(index_exports, {
   yamlSyntaxError: () => yamlSyntaxError
 });
 module.exports = __toCommonJS(index_exports);
-var import_omnify_types = require("@famgia/omnify-types");
+var import_omnify_types3 = require("@famgia/omnify-types");
 
 // src/errors/omnify-error.ts
 var OmnifyError = class _OmnifyError extends Error {
@@ -553,6 +553,7 @@ function notImplementedError(feature) {
 var fs = __toESM(require("fs/promises"), 1);
 var path = __toESM(require("path"), 1);
 var import_js_yaml = __toESM(require("js-yaml"), 1);
+var import_omnify_types = require("@famgia/omnify-types");
 function fileNameToSchemaName(fileName) {
   const baseName = path.basename(fileName, path.extname(fileName));
   if (!baseName.includes("-") && !baseName.includes("_")) {
@@ -639,7 +640,7 @@ function buildSchemaDefinition(data) {
   if (data.kind !== void 0) {
     schema.kind = data.kind;
   }
-  if (data.displayName !== void 0 && typeof data.displayName === "string") {
+  if (data.displayName !== void 0 && (0, import_omnify_types.isLocalizedString)(data.displayName)) {
     schema.displayName = data.displayName;
   }
   if (data.titleIndex !== void 0 && typeof data.titleIndex === "string") {
@@ -787,7 +788,7 @@ function buildPropertyDefinition(data) {
   if (unknownFields.length > 0) {
     prop._unknownFields = unknownFields;
   }
-  if (data.displayName !== void 0 && typeof data.displayName === "string") {
+  if (data.displayName !== void 0 && (0, import_omnify_types.isLocalizedString)(data.displayName)) {
     prop.displayName = data.displayName;
   }
   if (data.nullable !== void 0 && typeof data.nullable === "boolean") {
@@ -799,7 +800,7 @@ function buildPropertyDefinition(data) {
   if (data.unique !== void 0 && typeof data.unique === "boolean") {
     prop.unique = data.unique;
   }
-  if (data.description !== void 0 && typeof data.description === "string") {
+  if (data.description !== void 0 && (0, import_omnify_types.isLocalizedString)(data.description)) {
     prop.description = data.description;
   }
   if (data.renamedFrom !== void 0 && typeof data.renamedFrom === "string") {
@@ -1076,6 +1077,9 @@ async function ensureFileSchema(schemas, schemasDir, autoCreate = false) {
   };
 }
 
+// src/validation/validator.ts
+var import_omnify_types2 = require("@famgia/omnify-types");
+
 // src/validation/types/base.ts
 var BASE_PROPERTY_FIELDS = [
   "type",
@@ -1169,6 +1173,30 @@ var TypeRegistry = class {
   getAllTypeNames() {
     return [...this.types.keys()];
   }
+  /**
+   * Get all valid fields across ALL types.
+   * Used to determine if a field is valid for any type.
+   */
+  getAllValidFields() {
+    const allFields = /* @__PURE__ */ new Set();
+    for (const type of this.types.values()) {
+      for (const field of type.validFields) {
+        allFields.add(field);
+      }
+    }
+    return allFields;
+  }
+  /**
+   * Check if a field is valid for any registered type.
+   */
+  isFieldValidForAnyType(field) {
+    for (const type of this.types.values()) {
+      if (type.validFields.includes(field)) {
+        return true;
+      }
+    }
+    return false;
+  }
   /**
    * Get count of registered types.
    */
@@ -2267,16 +2295,52 @@ function validateDbCompatibility(propertyName, property, filePath, databaseDrive
   }
   return { errors, warnings };
 }
-function validateUnknownFields(propertyName, property, filePath) {
+function validateUnknownFieldsDetailed(propertyName, property, filePath, customTypeDefinitions) {
   const errors = [];
-  const unknownFields = property._unknownFields;
-  if (!unknownFields || unknownFields.length === 0) {
-    return errors;
+  const warnings = [];
+  if (!property.type) {
+    return { errors, warnings };
   }
-  for (const field of unknownFields) {
-    let suggestion = `Valid property fields: type, displayName, nullable, default, unique, description, length, unsigned, precision, scale, enum, relation, target, onDelete, onUpdate, joinTable`;
-    if (field === "required") {
-      suggestion = `'required' is not a valid field. Properties are required by default.
+  let validFields;
+  const isBuiltIn = typeRegistry.has(property.type);
+  if (isBuiltIn) {
+    validFields = typeRegistry.getValidFields(property.type);
+  } else {
+    const customTypeDef = customTypeDefinitions?.get(property.type);
+    if (customTypeDef?.validFields) {
+      validFields = [...BASE_PROPERTY_FIELDS, ...customTypeDef.validFields];
+    } else {
+      validFields = [...BASE_PROPERTY_FIELDS];
+    }
+  }
+  const validFieldsSet = new Set(validFields);
+  for (const field of Object.keys(property)) {
+    if (field.startsWith("_")) continue;
+    if (validFieldsSet.has(field)) continue;
+    const isValidForOtherType = typeRegistry.isFieldValidForAnyType(field);
+    if (isValidForOtherType) {
+      errors.push(
+        validationError(
+          `Property '${propertyName}' of type '${property.type}' has invalid field '${field}'`,
+          buildLocation7(filePath),
+          `'${field}' is not valid for type '${property.type}'. Valid fields: ${validFields.join(", ")}`
+        )
+      );
+    } else {
+      warnings.push(
+        validationError(
+          `Property '${propertyName}' has unknown field '${field}'`,
+          buildLocation7(filePath),
+          getSuggestionForUnknownField(field)
+        )
+      );
+    }
+  }
+  return { errors, warnings };
+}
+function getSuggestionForUnknownField(field) {
+  if (field === "required") {
+    return `'required' is not a valid field. Properties are required by default.
 Use 'nullable: true' to make a field optional.
 Example:
   email:
@@ -2286,10 +2350,12 @@ Example:
   phone:
     type: String
     nullable: true  # optional field`;
-    } else if (field === "hidden") {
-      suggestion = `'hidden' is not a standard field. For Laravel, hidden fields are configured in the Model class.`;
-    } else if (field === "foreignKey") {
-      suggestion = `'foreignKey' is not needed. Omnify auto-generates foreign keys from Association properties.
+  }
+  if (field === "hidden") {
+    return `'hidden' is not a standard field. For Laravel, hidden fields are configured in the Model class.`;
+  }
+  if (field === "foreignKey") {
+    return `'foreignKey' is not needed. Omnify auto-generates foreign keys from Association properties.
 The foreign key name is derived from the property name + '_id'.
 Example:
   author:
@@ -2297,16 +2363,8 @@ Example:
     relation: ManyToOne
     target: User
     # Creates author_id column automatically`;
-    }
-    errors.push(
-      validationError(
-        `Property '${propertyName}' has unknown field '${field}'`,
-        buildLocation7(filePath),
-        suggestion
-      )
-    );
   }
-  return errors;
+  return `Valid property fields: type, displayName, nullable, default, unique, description, length, unsigned, precision, scale, enum, relation, target, onDelete, onUpdate, joinTable`;
 }
 function validatePropertyType(propertyName, property, filePath, customTypes = []) {
   const errors = [];
@@ -2562,6 +2620,62 @@ function validateEnumSchema(schema, filePath) {
   }
   return errors;
 }
+function validateLocalizedString(fieldName, value, filePath, localeConfig, context) {
+  const warnings = [];
+  if (value === void 0 || !(0, import_omnify_types2.isLocaleMap)(value)) {
+    return { warnings };
+  }
+  if (!localeConfig) {
+    return { warnings };
+  }
+  const configuredLocales = new Set(localeConfig.locales);
+  const usedLocales = Object.keys(value);
+  for (const locale of usedLocales) {
+    if (!configuredLocales.has(locale)) {
+      const contextStr = context ? ` (property '${context}')` : "";
+      warnings.push(
+        validationError(
+          `${fieldName}${contextStr} uses locale '${locale}' which is not in configured locales`,
+          buildLocation7(filePath),
+          `Configured locales: ${localeConfig.locales.join(", ")}. Add '${locale}' to your locale configuration or remove it from the schema.`
+        )
+      );
+    }
+  }
+  return { warnings };
+}
+function validateLocalizedStrings(schema, localeConfig) {
+  const warnings = [];
+  const schemaDisplayNameResult = validateLocalizedString(
+    "displayName",
+    schema.displayName,
+    schema.filePath,
+    localeConfig
+  );
+  warnings.push(...schemaDisplayNameResult.warnings);
+  if (schema.properties) {
+    for (const [propName, property] of Object.entries(schema.properties)) {
+      const propDisplayNameResult = validateLocalizedString(
+        "displayName",
+        property.displayName,
+        schema.filePath,
+        localeConfig,
+        propName
+      );
+      warnings.push(...propDisplayNameResult.warnings);
+      const propDescription = property.description;
+      const propDescriptionResult = validateLocalizedString(
+        "description",
+        propDescription,
+        schema.filePath,
+        localeConfig,
+        propName
+      );
+      warnings.push(...propDescriptionResult.warnings);
+    }
+  }
+  return warnings;
+}
 function validateSchema(schema, options = {}) {
   const errors = [];
   const warnings = [];
@@ -2593,13 +2707,21 @@ function validateSchema(schema, options = {}) {
   }
   if (schema.properties) {
     for (const [name, property] of Object.entries(schema.properties)) {
-      const unknownFieldErrors = validateUnknownFields(name, property, schema.filePath);
-      errors.push(...unknownFieldErrors);
+      const unknownFieldResult = validateUnknownFieldsDetailed(
+        name,
+        property,
+        schema.filePath,
+        options.customTypeDefinitions
+      );
+      errors.push(...unknownFieldResult.errors);
+      warnings.push(...unknownFieldResult.warnings);
       const dbCompat = validateDbCompatibility(name, property, schema.filePath, options.databaseDriver);
       errors.push(...dbCompat.errors);
       warnings.push(...dbCompat.warnings);
     }
   }
+  const localizedStringWarnings = validateLocalizedStrings(schema, options.localeConfig);
+  warnings.push(...localizedStringWarnings);
   return {
     schemaName: schema.name,
     valid: errors.length === 0,