@famgia/omnify-core 0.0.7 → 0.0.8

package/dist/index.cjs

@@ -641,8 +641,11 @@ function buildSchemaOptions(data) {
   if (data.tableName !== void 0 && typeof data.tableName === "string") {
     options.tableName = data.tableName;
   }
-  if (data.primaryKeyType !== void 0) {
-    options.primaryKeyType = data.primaryKeyType;
+  if (data.id !== void 0 && typeof data.id === "boolean") {
+    options.id = data.id;
+  }
+  if (data.idType !== void 0) {
+    options.idType = data.idType;
   }
   if (data.authenticatable !== void 0 && typeof data.authenticatable === "boolean") {
     options.authenticatable = data.authenticatable;
@@ -1352,7 +1355,18 @@ var VALID_RELATIONS = [
   "OneToOne",
   "OneToMany",
   "ManyToOne",
-  "ManyToMany"
+  "ManyToMany",
+  // Polymorphic relations
+  "MorphTo",
+  "MorphOne",
+  "MorphMany",
+  "MorphToMany",
+  "MorphedByMany"
+];
+var MORPH_TO_RELATIONS = ["MorphTo"];
+var MORPH_INVERSE_RELATIONS = [
+  "MorphOne",
+  "MorphMany"
 ];
 var VALID_REFERENTIAL_ACTIONS = [
   "CASCADE",
@@ -1364,6 +1378,10 @@ var VALID_REFERENTIAL_ACTIONS = [
 var ASSOCIATION_FIELDS = [
   "relation",
   "target",
+  "targets",
+  // For MorphTo: array of target schema names
+  "morphName",
+  // For MorphOne/MorphMany/MorphedByMany: polymorphic name
   "inversedBy",
   "mappedBy",
   "onDelete",
@@ -1375,13 +1393,15 @@ var AssociationType = {
   name: "Association",
   category: "relation",
   validFields: createValidFields(ASSOCIATION_FIELDS),
-  requiredFields: ["relation", "target"],
+  requiredFields: ["relation"],
   dbCompatibility: fullDbCompatibility(),
   validate(propertyName, property, filePath) {
     const errors = [];
     const {
       relation,
       target,
+      targets,
+      morphName,
       onDelete,
       onUpdate
     } = property;
@@ -1390,17 +1410,21 @@ var AssociationType = {
         validationError(
           `Property '${propertyName}' of type 'Association' requires 'relation' field`,
           buildLocation5(filePath),
-          "Add relation: OneToOne, OneToMany, ManyToOne, or ManyToMany"
+          "Add relation: OneToOne, OneToMany, ManyToOne, ManyToMany, MorphTo, MorphOne, MorphMany, MorphToMany, or MorphedByMany"
         )
       );
-    } else if (typeof relation !== "string") {
+      return errors;
+    }
+    if (typeof relation !== "string") {
       errors.push(
         validationError(
           `Property '${propertyName}' relation field must be a string`,
           buildLocation5(filePath)
         )
       );
-    } else if (!VALID_RELATIONS.includes(relation)) {
+      return errors;
+    }
+    if (!VALID_RELATIONS.includes(relation)) {
       errors.push(
         validationError(
           `Property '${propertyName}' has invalid relation '${relation}'`,
@@ -1408,22 +1432,147 @@ var AssociationType = {
           `Use one of: ${VALID_RELATIONS.join(", ")}`
         )
       );
+      return errors;
     }
-    if (target === void 0) {
-      errors.push(
-        validationError(
-          `Property '${propertyName}' of type 'Association' requires 'target' field`,
-          buildLocation5(filePath),
-          "Add target schema name: target: User"
-        )
-      );
-    } else if (typeof target !== "string") {
-      errors.push(
-        validationError(
-          `Property '${propertyName}' target field must be a string`,
-          buildLocation5(filePath)
-        )
-      );
+    const relationTyped = relation;
+    if (MORPH_TO_RELATIONS.includes(relationTyped)) {
+      if (targets === void 0) {
+        errors.push(
+          validationError(
+            `Property '${propertyName}' with relation 'MorphTo' requires 'targets' field`,
+            buildLocation5(filePath),
+            "Add targets: [Post, Video, Image]"
+          )
+        );
+      } else if (!Array.isArray(targets)) {
+        errors.push(
+          validationError(
+            `Property '${propertyName}' targets field must be an array of schema names`,
+            buildLocation5(filePath),
+            "Example: targets: [Post, Video, Image]"
+          )
+        );
+      } else if (targets.length === 0) {
+        errors.push(
+          validationError(
+            `Property '${propertyName}' targets array cannot be empty`,
+            buildLocation5(filePath),
+            "Add at least one target schema"
+          )
+        );
+      } else {
+        for (const t of targets) {
+          if (typeof t !== "string") {
+            errors.push(
+              validationError(
+                `Property '${propertyName}' targets array contains non-string value`,
+                buildLocation5(filePath)
+              )
+            );
+          }
+        }
+      }
+      if (target !== void 0) {
+        errors.push(
+          validationError(
+            `Property '${propertyName}' with relation 'MorphTo' should use 'targets' (plural) not 'target'`,
+            buildLocation5(filePath),
+            "Change target to targets array"
+          )
+        );
+      }
+    } else if (MORPH_INVERSE_RELATIONS.includes(relationTyped)) {
+      if (target === void 0) {
+        errors.push(
+          validationError(
+            `Property '${propertyName}' with relation '${relation}' requires 'target' field`,
+            buildLocation5(filePath),
+            "Add target schema name: target: Comment"
+          )
+        );
+      } else if (typeof target !== "string") {
+        errors.push(
+          validationError(
+            `Property '${propertyName}' target field must be a string`,
+            buildLocation5(filePath)
+          )
+        );
+      }
+      if (morphName === void 0) {
+        errors.push(
+          validationError(
+            `Property '${propertyName}' with relation '${relation}' requires 'morphName' field`,
+            buildLocation5(filePath),
+            "Add morphName to match the MorphTo property name (e.g., morphName: commentable)"
+          )
+        );
+      } else if (typeof morphName !== "string") {
+        errors.push(
+          validationError(
+            `Property '${propertyName}' morphName field must be a string`,
+            buildLocation5(filePath)
+          )
+        );
+      }
+    } else if (relationTyped === "MorphToMany") {
+      if (target === void 0) {
+        errors.push(
+          validationError(
+            `Property '${propertyName}' with relation 'MorphToMany' requires 'target' field`,
+            buildLocation5(filePath),
+            "Add target schema name: target: Tag"
+          )
+        );
+      } else if (typeof target !== "string") {
+        errors.push(
+          validationError(
+            `Property '${propertyName}' target field must be a string`,
+            buildLocation5(filePath)
+          )
+        );
+      }
+    } else if (relationTyped === "MorphedByMany") {
+      if (target === void 0) {
+        errors.push(
+          validationError(
+            `Property '${propertyName}' with relation 'MorphedByMany' requires 'target' field`,
+            buildLocation5(filePath),
+            "Add target schema name: target: Post"
+          )
+        );
+      } else if (typeof target !== "string") {
+        errors.push(
+          validationError(
+            `Property '${propertyName}' target field must be a string`,
+            buildLocation5(filePath)
+          )
+        );
+      }
+      if (morphName !== void 0 && typeof morphName !== "string") {
+        errors.push(
+          validationError(
+            `Property '${propertyName}' morphName field must be a string`,
+            buildLocation5(filePath)
+          )
+        );
+      }
+    } else {
+      if (target === void 0) {
+        errors.push(
+          validationError(
+            `Property '${propertyName}' of type 'Association' requires 'target' field`,
+            buildLocation5(filePath),
+            "Add target schema name: target: User"
+          )
+        );
+      } else if (typeof target !== "string") {
+        errors.push(
+          validationError(
+            `Property '${propertyName}' target field must be a string`,
+            buildLocation5(filePath)
+          )
+        );
+      }
     }
     if (onDelete !== void 0 && typeof onDelete === "string") {
       if (!VALID_REFERENTIAL_ACTIONS.includes(onDelete)) {
@@ -1450,37 +1599,8 @@ var AssociationType = {
     return errors;
   }
 };
-var PolymorphicType = {
-  name: "Polymorphic",
-  category: "relation",
-  validFields: createValidFields(ASSOCIATION_FIELDS),
-  dbCompatibility: fullDbCompatibility(),
-  validate(propertyName, property, filePath) {
-    const errors = [];
-    const { relation, target } = property;
-    if (relation === void 0) {
-      errors.push(
-        validationError(
-          `Property '${propertyName}' of type 'Polymorphic' requires 'relation' field`,
-          buildLocation5(filePath),
-          "Add relation type"
-        )
-      );
-    }
-    if (target !== void 0 && typeof target !== "string") {
-      errors.push(
-        validationError(
-          `Property '${propertyName}' target field must be a string`,
-          buildLocation5(filePath)
-        )
-      );
-    }
-    return errors;
-  }
-};
 var relationTypes = [
-  AssociationType,
-  PolymorphicType
+  AssociationType
 ];
 
 // src/validation/types/index.ts
@@ -1503,7 +1623,7 @@ function registerBuiltInTypes() {
 registerBuiltInTypes();
 
 // src/validation/validator.ts
-var VALID_PRIMARY_KEY_TYPES = ["Int", "BigInt", "Uuid", "String"];
+var VALID_ID_TYPES = ["Int", "BigInt", "Uuid", "String"];
 function buildLocation6(file, line, column) {
   const loc = { file };
   if (line !== void 0) {
@@ -1599,6 +1719,8 @@ function validateProperties(schema, filePath, customTypes = []) {
   }
   return errors;
 }
+var MORPH_TO_RELATIONS2 = ["MorphTo"];
+var MORPH_INVERSE_RELATIONS2 = ["MorphOne", "MorphMany"];
 function validateAssociations(schema, allSchemas) {
   const errors = [];
   if (!schema.properties) {
@@ -1619,7 +1741,22 @@ function validateAssociations(schema, allSchemas) {
         )
       );
     }
-    if (assocProp.target && !availableSchemas.includes(assocProp.target)) {
+    const relation = assocProp.relation;
+    if (relation && MORPH_TO_RELATIONS2.includes(relation)) {
+      if (assocProp.targets) {
+        for (const target of assocProp.targets) {
+          if (!availableSchemas.includes(target)) {
+            errors.push(
+              invalidAssociationTargetError(
+                target,
+                buildLocation6(schema.filePath),
+                availableSchemas
+              )
+            );
+          }
+        }
+      }
+    } else if (assocProp.target && !availableSchemas.includes(assocProp.target)) {
       errors.push(
         invalidAssociationTargetError(
           assocProp.target,
@@ -1628,6 +1765,34 @@ function validateAssociations(schema, allSchemas) {
         )
       );
     }
+    if (relation && MORPH_INVERSE_RELATIONS2.includes(relation)) {
+      if (assocProp.morphName && assocProp.target) {
+        const targetSchema = allSchemas[assocProp.target];
+        if (targetSchema?.properties) {
+          const morphProperty = targetSchema.properties[assocProp.morphName];
+          if (!morphProperty) {
+            errors.push(
+              validationError(
+                `Property '${name}' references non-existent morphName '${assocProp.morphName}' on '${assocProp.target}'`,
+                buildLocation6(schema.filePath),
+                `Add a MorphTo property '${assocProp.morphName}' to ${assocProp.target} schema`
+              )
+            );
+          } else if (morphProperty.type === "Association") {
+            const morphAssoc = morphProperty;
+            if (morphAssoc.relation !== "MorphTo") {
+              errors.push(
+                validationError(
+                  `Property '${name}' morphName '${assocProp.morphName}' on '${assocProp.target}' must be a MorphTo relation`,
+                  buildLocation6(schema.filePath),
+                  `Change ${assocProp.target}.${assocProp.morphName} relation to MorphTo`
+                )
+              );
+            }
+          }
+        }
+      }
+    }
     if (assocProp.inversedBy && assocProp.target) {
       const targetSchema = allSchemas[assocProp.target];
       if (targetSchema?.properties) {
@@ -1670,13 +1835,13 @@ function validateOptions(schema, filePath) {
   if (!options) {
     return errors;
   }
-  if (options.primaryKeyType !== void 0) {
-    if (!VALID_PRIMARY_KEY_TYPES.includes(options.primaryKeyType)) {
+  if (options.idType !== void 0) {
+    if (!VALID_ID_TYPES.includes(options.idType)) {
       errors.push(
         validationError(
-          `Invalid primaryKeyType '${options.primaryKeyType}'`,
+          `Invalid idType '${options.idType}'`,
           buildLocation6(filePath),
-          `Use one of: ${VALID_PRIMARY_KEY_TYPES.join(", ")}`
+          `Use one of: ${VALID_ID_TYPES.join(", ")}`
         )
       );
     }
@@ -2422,7 +2587,7 @@ function getSchemaMetadata(schema) {
     associationNames,
     hasTimestamps: schema.options?.timestamps ?? false,
     hasSoftDelete: schema.options?.softDelete ?? false,
-    primaryKeyType: schema.options?.primaryKeyType ?? "Int"
+    idType: schema.options?.idType ?? "BigInt"
   };
   if (schema.displayName !== void 0) {
     result.displayName = schema.displayName;
@@ -2464,9 +2629,17 @@ function getPropertyMetadata(name, property, registry) {
 function getAssociationMetadata(name, association) {
   const result = {
     name,
-    relation: association.relation,
-    target: association.target
+    relation: association.relation
   };
+  if (association.target !== void 0) {
+    result.target = association.target;
+  }
+  if (association.targets !== void 0) {
+    result.targets = association.targets;
+  }
+  if (association.morphName !== void 0) {
+    result.morphName = association.morphName;
+  }
   if (association.inversedBy !== void 0) {
     result.inversedBy = association.inversedBy;
   }
@@ -2571,7 +2744,13 @@ function getRelationshipGraph(schemas) {
     const targets = [];
     const associations = getSchemaAssociations(schema);
     for (const association of associations) {
-      if (!targets.includes(association.target)) {
+      if (association.targets) {
+        for (const target of association.targets) {
+          if (!targets.includes(target)) {
+            targets.push(target);
+          }
+        }
+      } else if (association.target && !targets.includes(association.target)) {
         targets.push(association.target);
       }
     }
@@ -2616,7 +2795,7 @@ function getTopologicalOrder(schemas) {
   for (const schemaName of graph.keys()) {
     visit(schemaName);
   }
-  return result.reverse();
+  return result;
 }
 
 // src/api/omnify.ts