@famgia/omnify-core 0.0.13 → 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") {
@@ -665,10 +666,13 @@ function buildSchemaDefinition(data) {
     }
   }
   if (data.properties !== void 0 && typeof data.properties === "object") {
-    const properties = buildProperties(data.properties);
+    const { properties, invalidProperties } = buildProperties(data.properties);
     if (Object.keys(properties).length > 0) {
       schema.properties = properties;
     }
+    if (invalidProperties.length > 0) {
+      schema._invalidProperties = invalidProperties;
+    }
   }
   if (data.values !== void 0 && Array.isArray(data.values)) {
     schema.values = data.values;
@@ -717,12 +721,25 @@ function buildSchemaOptions(data) {
 }
 function buildProperties(data) {
   const properties = {};
+  const invalidProperties = [];
   for (const [name, value] of Object.entries(data)) {
-    if (value !== void 0 && typeof value === "object" && value !== null) {
+    if (value === void 0 || value === null) {
+      continue;
+    }
+    if (typeof value === "object") {
       properties[name] = buildPropertyDefinition(value);
+    } else {
+      invalidProperties.push({
+        propertyName: name,
+        value,
+        expectedFormat: `Property '${name}' must be an object with 'type' field. Example:
+  ${name}:
+    type: String
+    nullable: true`
+      });
     }
   }
-  return properties;
+  return { properties, invalidProperties };
 }
 var VALID_PROPERTY_FIELDS = /* @__PURE__ */ new Set([
   "type",
@@ -771,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") {
@@ -783,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") {
@@ -1060,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",
@@ -1153,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.
    */
@@ -2206,6 +2250,25 @@ function validateUnknownOptionsFields(schema, filePath) {
   }
   return errors;
 }
+function validatePropertyFormat(schema, filePath) {
+  const errors = [];
+  const invalidProperties = schema._invalidProperties;
+  if (!invalidProperties || invalidProperties.length === 0) {
+    return errors;
+  }
+  for (const invalid of invalidProperties) {
+    const valueType = typeof invalid.value;
+    const valuePreview = valueType === "string" ? `"${invalid.value}"` : String(invalid.value);
+    errors.push(
+      validationError(
+        `Property '${invalid.propertyName}' has invalid format: got ${valueType} (${valuePreview})`,
+        buildLocation7(filePath),
+        invalid.expectedFormat
+      )
+    );
+  }
+  return errors;
+}
 function validateDbCompatibility(propertyName, property, filePath, databaseDriver) {
   const errors = [];
   const warnings = [];
@@ -2232,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:
@@ -2251,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:
@@ -2262,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 = [];
@@ -2527,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 = [];
@@ -2535,6 +2684,8 @@ function validateSchema(schema, options = {}) {
   errors.push(...unknownSchemaFieldErrors);
   const unknownOptionsErrors = validateUnknownOptionsFields(schema, schema.filePath);
   errors.push(...unknownOptionsErrors);
+  const propertyFormatErrors = validatePropertyFormat(schema, schema.filePath);
+  errors.push(...propertyFormatErrors);
   const propErrors = validateProperties(schema, schema.filePath, customTypes);
   errors.push(...propErrors);
   const optErrors = validateOptions(schema, schema.filePath);
@@ -2556,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,
@@ -2652,8 +2811,10 @@ var GeneratorRunner = class {
   }
   /**
    * Run all generators in topological order.
+   * @param schemas - The schemas to generate from
+   * @param changes - Schema changes detected from lock file comparison
    */
-  async runAll(schemas) {
+  async runAll(schemas, changes) {
     const errors = [];
     const outputs = [];
     const outputsByGenerator = /* @__PURE__ */ new Map();
@@ -2681,10 +2842,12 @@ var GeneratorRunner = class {
         this.options.logger.debug(`Running generator: ${name}`);
         const ctx = {
           schemas,
+          changes,
           pluginConfig,
           cwd: this.options.cwd,
           logger: this.options.logger,
-          previousOutputs
+          previousOutputs,
+          customTypes: this.options.customTypes ?? /* @__PURE__ */ new Map()
         };
         const result = await definition.generate(ctx);
         const generatorOutputs = Array.isArray(result) ? result : [result];
@@ -3036,17 +3199,24 @@ var PluginManager = class {
   /**
    * Runs all registered generators in topological order.
    * @param schemas - The schemas to generate from
+   * @param changes - Schema changes detected from lock file comparison
    * @returns Result with all generated outputs
    */
-  async runGenerators(schemas) {
+  async runGenerators(schemas, changes) {
+    const customTypes = /* @__PURE__ */ new Map();
+    for (const [name, registeredType] of this._types) {
+      const { pluginName, pluginVersion, ...typeDefinition } = registeredType;
+      customTypes.set(name, typeDefinition);
+    }
     const runner = new GeneratorRunner({
       cwd: this._cwd,
-      logger: this._logger
+      logger: this._logger,
+      customTypes
     });
     for (const gen of this._generators.values()) {
       runner.register(gen);
     }
-    return runner.runAll(schemas);
+    return runner.runAll(schemas, changes);
   }
   /**
    * Clears all registered plugins, types, and generators.