@famgia/omnify-core 0.0.13 → 0.0.14

package/dist/index.cjs

@@ -665,10 +665,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 +720,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",
@@ -2206,6 +2222,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 = [];
@@ -2535,6 +2570,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);
@@ -2652,8 +2689,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 +2720,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 +3077,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.