@famgia/omnify-laravel 0.0.8 → 0.0.10

package/dist/plugin.cjs

@@ -31,6 +31,7 @@ var TYPE_METHOD_MAP = {
   Int: "integer",
   BigInt: "bigInteger",
   Float: "double",
+  Decimal: "decimal",
   Boolean: "boolean",
   Text: "text",
   LongText: "longText",
@@ -52,6 +53,12 @@ var PK_METHOD_MAP = {
   Uuid: "uuid",
   String: "string"
 };
+function getIdType(schema) {
+  return schema.options?.idType ?? "BigInt";
+}
+function hasAutoId(schema) {
+  return schema.options?.id !== false;
+}
 function toColumnName(propertyName) {
   return propertyName.replace(/([A-Z])/g, "_$1").toLowerCase().replace(/^_/, "");
 }
@@ -77,6 +84,12 @@ function propertyToColumnMethod(propertyName, property) {
   if (method === "string" && propWithLength.length) {
     args.push(propWithLength.length);
   }
+  if (property.type === "Decimal") {
+    const decimalProp = property;
+    const precision = decimalProp.precision ?? 8;
+    const scale = decimalProp.scale ?? 2;
+    args.push(precision, scale);
+  }
   if (property.type === "Enum") {
     const enumProp = property;
     if (enumProp.enum && enumProp.enum.length > 0) {
@@ -153,6 +166,54 @@ function generateSoftDeleteColumn() {
     modifiers: [{ method: "nullable" }]
   };
 }
+function generatePolymorphicColumns(propertyName, property, allSchemas) {
+  if (property.type !== "Association") {
+    return null;
+  }
+  const assocProp = property;
+  if (assocProp.relation !== "MorphTo") {
+    return null;
+  }
+  const targets = assocProp.targets;
+  if (!targets || targets.length === 0) {
+    return null;
+  }
+  const columnBaseName = toColumnName(propertyName);
+  const typeColumnName = `${columnBaseName}_type`;
+  const idColumnName = `${columnBaseName}_id`;
+  const typeColumn = {
+    name: typeColumnName,
+    method: "enum",
+    args: [typeColumnName, targets],
+    modifiers: [{ method: "nullable" }]
+  };
+  let idMethod = "unsignedBigInteger";
+  for (const targetName of targets) {
+    const targetSchema = allSchemas[targetName];
+    if (targetSchema) {
+      const targetIdType = targetSchema.options?.idType ?? "BigInt";
+      if (targetIdType === "Uuid") {
+        idMethod = "uuid";
+        break;
+      } else if (targetIdType === "String") {
+        idMethod = "string";
+      }
+    }
+  }
+  const idColumn = {
+    name: idColumnName,
+    method: idMethod,
+    args: idMethod === "string" ? [idColumnName, 255] : [idColumnName],
+    modifiers: [{ method: "nullable" }]
+  };
+  const indexes = [
+    {
+      columns: [typeColumnName, idColumnName],
+      unique: false
+    }
+  ];
+  return { typeColumn, idColumn, indexes };
+}
 function generateForeignKey(propertyName, property, allSchemas) {
   if (property.type !== "Association") {
     return null;
@@ -167,7 +228,7 @@ function generateForeignKey(propertyName, property, allSchemas) {
   const columnName = toColumnName(propertyName) + "_id";
   const targetSchema = assocProp.target ? allSchemas[assocProp.target] : void 0;
   const targetTable = assocProp.target ? toTableName(assocProp.target) : "unknown";
-  const targetPkType = targetSchema?.options?.primaryKeyType ?? "BigInt";
+  const targetPkType = targetSchema ? getIdType(targetSchema) : "BigInt";
   let method = "unsignedBigInteger";
   if (targetPkType === "Int") {
     method = "unsignedInteger";
@@ -200,8 +261,10 @@ function schemaToBlueprint(schema, allSchemas) {
   const columns = [];
   const foreignKeys = [];
   const indexes = [];
-  const pkType = schema.options?.primaryKeyType ?? "BigInt";
-  columns.push(generatePrimaryKeyColumn(pkType));
+  if (hasAutoId(schema)) {
+    const pkType = getIdType(schema);
+    columns.push(generatePrimaryKeyColumn(pkType));
+  }
   if (schema.properties) {
     for (const [propName, property] of Object.entries(schema.properties)) {
       const columnMethod = propertyToColumnMethod(propName, property);
@@ -214,6 +277,12 @@ function schemaToBlueprint(schema, allSchemas) {
         foreignKeys.push(fkResult.foreignKey);
         indexes.push(fkResult.index);
       }
+      const polyResult = generatePolymorphicColumns(propName, property, allSchemas);
+      if (polyResult) {
+        columns.push(polyResult.typeColumn);
+        columns.push(polyResult.idColumn);
+        indexes.push(...polyResult.indexes);
+      }
     }
   }
   if (schema.options?.timestamps !== false) {
@@ -307,7 +376,7 @@ function extractManyToManyRelations(schema, allSchemas) {
     return pivotTables;
   }
   const sourceTable = toTableName(schema.name);
-  const sourcePkType = schema.options?.primaryKeyType ?? "BigInt";
+  const sourcePkType = getIdType(schema);
   for (const [, property] of Object.entries(schema.properties)) {
     if (property.type !== "Association") {
       continue;
@@ -322,7 +391,7 @@ function extractManyToManyRelations(schema, allSchemas) {
     }
     const targetSchema = allSchemas[targetName];
     const targetTable = toTableName(targetName);
-    const targetPkType = targetSchema?.options?.primaryKeyType ?? "BigInt";
+    const targetPkType = targetSchema ? getIdType(targetSchema) : "BigInt";
     const isOwningSide = assocProp.owning ?? schema.name < targetName;
     if (!isOwningSide) {
       continue;
@@ -653,12 +722,25 @@ function getPropertyType(property, _allSchemas) {
     const assocProp = property;
     const targetName = assocProp.target ?? "unknown";
     switch (assocProp.relation) {
+      // Standard relations
       case "OneToOne":
       case "ManyToOne":
         return targetName;
       case "OneToMany":
       case "ManyToMany":
         return `${targetName}[]`;
+      // Polymorphic relations
+      case "MorphTo":
+        if (assocProp.targets && assocProp.targets.length > 0) {
+          return assocProp.targets.join(" | ");
+        }
+        return "unknown";
+      case "MorphOne":
+        return targetName;
+      case "MorphMany":
+      case "MorphToMany":
+      case "MorphedByMany":
+        return `${targetName}[]`;
       default:
         return "unknown";
     }
@@ -680,30 +762,65 @@ function getPropertyType(property, _allSchemas) {
   }
   return TYPE_MAP[property.type] ?? "unknown";
 }
-function propertyToTSProperty(propertyName, property, allSchemas, options = {}) {
-  const type = getPropertyType(property, allSchemas);
+function propertyToTSProperties(propertyName, property, allSchemas, options = {}) {
   const baseProp = property;
-  return {
+  const isReadonly = options.readonly ?? true;
+  if (property.type === "Association") {
+    const assocProp = property;
+    if (assocProp.relation === "MorphTo" && assocProp.targets && assocProp.targets.length > 0) {
+      const propBaseName = toPropertyName(propertyName);
+      const targetUnion = assocProp.targets.map((t) => `'${t}'`).join(" | ");
+      const relationUnion = assocProp.targets.join(" | ");
+      return [
+        {
+          name: `${propBaseName}Type`,
+          type: targetUnion,
+          optional: true,
+          // Polymorphic columns are nullable
+          readonly: isReadonly,
+          comment: `Polymorphic type for ${propertyName}`
+        },
+        {
+          name: `${propBaseName}Id`,
+          type: "number",
+          optional: true,
+          readonly: isReadonly,
+          comment: `Polymorphic ID for ${propertyName}`
+        },
+        {
+          name: propBaseName,
+          type: `${relationUnion} | null`,
+          optional: true,
+          readonly: isReadonly,
+          comment: baseProp.displayName ?? `Polymorphic relation to ${assocProp.targets.join(", ")}`
+        }
+      ];
+    }
+  }
+  const type = getPropertyType(property, allSchemas);
+  return [{
     name: toPropertyName(propertyName),
     type,
     optional: baseProp.nullable ?? false,
-    readonly: options.readonly ?? true,
+    readonly: isReadonly,
     comment: baseProp.displayName
-  };
+  }];
 }
 function schemaToInterface(schema, allSchemas, options = {}) {
   const properties = [];
-  const pkType = schema.options?.primaryKeyType ?? "BigInt";
-  properties.push({
-    name: "id",
-    type: PK_TYPE_MAP[pkType] ?? "number",
-    optional: false,
-    readonly: options.readonly ?? true,
-    comment: "Primary key"
-  });
+  if (schema.options?.id !== false) {
+    const pkType = schema.options?.idType ?? "BigInt";
+    properties.push({
+      name: "id",
+      type: PK_TYPE_MAP[pkType] ?? "number",
+      optional: false,
+      readonly: options.readonly ?? true,
+      comment: "Primary key"
+    });
+  }
   if (schema.properties) {
     for (const [propName, property] of Object.entries(schema.properties)) {
-      properties.push(propertyToTSProperty(propName, property, allSchemas, options));
+      properties.push(...propertyToTSProperties(propName, property, allSchemas, options));
     }
   }
   if (schema.options?.timestamps !== false) {