@famgia/omnify-core 0.0.113 → 0.0.115

package/dist/index.cjs

@@ -605,6 +605,8 @@ function parseJsonSchema(content, filePath) {
 }
 var VALID_SCHEMA_FIELDS = /* @__PURE__ */ new Set([
   "kind",
+  "target",
+  // For partial schemas
   "displayName",
   "titleIndex",
   "group",
@@ -641,6 +643,9 @@ function buildSchemaDefinition(data) {
   if (data.kind !== void 0) {
     schema.kind = data.kind;
   }
+  if (data.target !== void 0 && typeof data.target === "string") {
+    schema.target = data.target;
+  }
   if (data.displayName !== void 0 && (0, import_omnify_types.isLocalizedString)(data.displayName)) {
     schema.displayName = data.displayName;
   }
@@ -966,9 +971,14 @@ async function loadSchemas(directoryPath, options = {}) {
   }
   const schemaFiles = await findSchemaFiles(absoluteDir, extensions, recursive);
   const schemas = {};
+  const partialSchemas = [];
   const schemaLocations = {};
   for (const filePath of schemaFiles) {
     const schema = await loadSchema(filePath, { baseDir: absoluteDir });
+    if (schema.kind === "partial") {
+      partialSchemas.push(schema);
+      continue;
+    }
     const existingLocation = schemaLocations[schema.name];
     if (existingLocation !== void 0) {
       throw duplicateSchemaError(
@@ -980,6 +990,26 @@ async function loadSchemas(directoryPath, options = {}) {
     schemas[schema.name] = schema;
     schemaLocations[schema.name] = filePath;
   }
+  for (const partial of partialSchemas) {
+    const targetName = partial.target;
+    if (!targetName) {
+      console.warn(`Partial schema '${partial.name}' has no target, skipping`);
+      continue;
+    }
+    const target = schemas[targetName];
+    if (!target) {
+      console.warn(`Partial schema '${partial.name}' targets unknown schema '${targetName}', skipping`);
+      continue;
+    }
+    const mergedProperties = {
+      ...partial.properties ?? {},
+      ...target.properties ?? {}
+    };
+    schemas[targetName] = {
+      ...target,
+      properties: mergedProperties
+    };
+  }
   return schemas;
 }
 var FILE_SCHEMA_NAME = "File";
@@ -2831,6 +2861,62 @@ function validateEnumSchema(schema, filePath) {
   }
   return errors;
 }
+function validatePartialSchema(schema, filePath) {
+  const errors = [];
+  if (schema.kind !== "partial") {
+    return errors;
+  }
+  if (!schema.target) {
+    errors.push(
+      validationError(
+        "Partial schema requires a target schema name",
+        buildLocation7(filePath),
+        "Add target: SchemaName to specify which schema to extend"
+      )
+    );
+  } else if (typeof schema.target !== "string") {
+    errors.push(
+      validationError(
+        "Partial schema target must be a string",
+        buildLocation7(filePath),
+        "Example: target: User"
+      )
+    );
+  }
+  if (!schema.properties || Object.keys(schema.properties).length === 0) {
+    errors.push(
+      validationError(
+        "Partial schema requires at least one property to extend the target",
+        buildLocation7(filePath),
+        "Add properties to extend the target schema"
+      )
+    );
+  }
+  if (schema.values && schema.values.length > 0) {
+    errors.push(
+      validationError(
+        "Partial schema cannot have values (values are for enum schemas)",
+        buildLocation7(filePath),
+        "Remove values or change kind to enum"
+      )
+    );
+  }
+  if (schema.options) {
+    const invalidOptions = ["id", "timestamps", "softDelete", "tableName"];
+    for (const opt of invalidOptions) {
+      if (schema.options[opt] !== void 0) {
+        errors.push(
+          validationError(
+            `Partial schema cannot have option '${opt}' (table options belong to the target schema)`,
+            buildLocation7(filePath),
+            `Remove options.${opt} - table-level options should be in the target schema`
+          )
+        );
+      }
+    }
+  }
+  return errors;
+}
 function validateLocalizedString(fieldName, value, filePath, localeConfig, context) {
   const warnings = [];
   if (value === void 0 || !(0, import_omnify_types2.isLocaleMap)(value)) {
@@ -2905,6 +2991,10 @@ function validateSchema(schema, options = {}) {
     const enumErrors = validateEnumSchema(schema, schema.filePath);
     errors.push(...enumErrors);
   }
+  if (schema.kind === "partial") {
+    const partialErrors = validatePartialSchema(schema, schema.filePath);
+    errors.push(...partialErrors);
+  }
   if (schema.titleIndex && schema.properties) {
     if (!schema.properties[schema.titleIndex]) {
       errors.push(
@@ -2981,6 +3071,29 @@ function validateSchemas(schemas, options = {}) {
       }
     }
   }
+  for (const schema of Object.values(schemas)) {
+    if (schema.kind === "partial" && schema.target) {
+      const targetExists = schemas[schema.target] !== void 0;
+      if (!targetExists) {
+        const error = validationError(
+          `Partial schema '${schema.name}' targets non-existent schema '${schema.target}'`,
+          buildLocation7(schema.filePath),
+          `Available schemas: ${Object.keys(schemas).filter((n) => n !== schema.name).join(", ")}`
+        );
+        allErrors.push(error);
+        const existingResult = schemaResults.find((r) => r.schemaName === schema.name);
+        if (existingResult) {
+          const updatedResult = {
+            ...existingResult,
+            valid: false,
+            errors: [...existingResult.errors, error]
+          };
+          const index = schemaResults.indexOf(existingResult);
+          schemaResults[index] = updatedResult;
+        }
+      }
+    }
+  }
   return {
     valid: allErrors.length === 0,
     errorCount: allErrors.length,