@famgia/omnify-laravel 0.0.29 → 0.0.31

package/dist/index.cjs

@@ -47,8 +47,10 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/migration/schema-builder.ts
+var import_omnify_types = require("@famgia/omnify-types");
 var TYPE_METHOD_MAP = {
   String: "string",
+  TinyInt: "tinyInteger",
   Int: "integer",
   BigInt: "bigInteger",
   Float: "double",
@@ -63,7 +65,9 @@ var TYPE_METHOD_MAP = {
   Json: "json",
   Email: "string",
   Password: "string",
-  Enum: "enum"
+  Enum: "enum",
+  EnumRef: "string"
+  // EnumRef stores the enum value as string (lookup via schema)
   // Note: File type is now polymorphic - no column generated, uses files table
 };
 var PK_METHOD_MAP = {
@@ -91,7 +95,7 @@ function toTableName(schemaName) {
     return snakeCase + "s";
   }
 }
-function propertyToColumnMethod(propertyName, property) {
+function propertyToColumnMethod(propertyName, property, options = {}) {
   if (property.type === "Association") {
     return null;
   }
@@ -105,6 +109,8 @@ function propertyToColumnMethod(propertyName, property) {
   const propWithLength = property;
   if (method === "string" && propWithLength.length) {
     args.push(propWithLength.length);
+  } else if (property.type === "EnumRef") {
+    args.push(50);
   }
   if (property.type === "Decimal") {
     const decimalProp = property;
@@ -128,12 +134,15 @@ function propertyToColumnMethod(propertyName, property) {
   if (baseProp.default !== void 0 && baseProp.default !== null) {
     modifiers.push({ method: "default", args: [baseProp.default] });
   }
-  if (baseProp.unsigned && (method === "integer" || method === "bigInteger")) {
+  if (baseProp.unsigned && (method === "tinyInteger" || method === "integer" || method === "bigInteger")) {
     modifiers.push({ method: "unsigned" });
   }
-  const displayName = property.displayName;
-  if (displayName) {
-    modifiers.push({ method: "comment", args: [displayName] });
+  const rawDisplayName = property.displayName;
+  if (rawDisplayName) {
+    const displayName = (0, import_omnify_types.resolveLocalizedString)(rawDisplayName, options.locale);
+    if (displayName) {
+      modifiers.push({ method: "comment", args: [displayName] });
+    }
   }
   return {
     name: columnName,
@@ -239,7 +248,7 @@ function generatePolymorphicColumns(propertyName, property, allSchemas) {
   ];
   return { typeColumn, idColumn, indexes };
 }
-function generateForeignKey(propertyName, property, allSchemas) {
+function generateForeignKey(propertyName, property, allSchemas, options = {}) {
   if (property.type !== "Association") {
     return null;
   }
@@ -270,7 +279,10 @@ function generateForeignKey(propertyName, property, allSchemas) {
     modifiers.push({ method: "default", args: [assocProp.default] });
   }
   if (assocProp.displayName) {
-    modifiers.push({ method: "comment", args: [assocProp.displayName] });
+    const displayName = (0, import_omnify_types.resolveLocalizedString)(assocProp.displayName, options.locale);
+    if (displayName) {
+      modifiers.push({ method: "comment", args: [displayName] });
+    }
   }
   const column = {
     name: columnName,
@@ -291,7 +303,7 @@ function generateForeignKey(propertyName, property, allSchemas) {
   };
   return { column, foreignKey, index };
 }
-function expandCompoundType(propName, property, customTypes) {
+function expandCompoundType(propName, property, customTypes, options = {}) {
   const typeDef = customTypes.get(property.type);
   if (!typeDef || !typeDef.compound || !typeDef.expand) {
     return null;
@@ -305,13 +317,26 @@ function expandCompoundType(propName, property, customTypes) {
       type: "String"
       // Default type, will be overridden by sql definition
     };
-    if (field.sql) {
+    const fieldOverrides = baseProp.fields;
+    const fieldOverride = fieldOverrides?.[field.suffix];
+    const fieldWithEnumRef = field;
+    if (fieldWithEnumRef.enumRef) {
+      expandedProp.type = "EnumRef";
+      expandedProp.enum = fieldWithEnumRef.enumRef;
+      if (fieldOverride?.nullable !== void 0) {
+        expandedProp.nullable = fieldOverride.nullable;
+      } else if (baseProp.nullable !== void 0) {
+        expandedProp.nullable = baseProp.nullable;
+      }
+    } else if (field.sql) {
       const sqlType = field.sql.sqlType.toUpperCase();
       if (sqlType === "VARCHAR" || sqlType === "CHAR" || sqlType === "STRING") {
         expandedProp.type = "String";
         if (field.sql.length) {
           expandedProp.length = field.sql.length;
         }
+      } else if (sqlType === "TINYINT") {
+        expandedProp.type = "TinyInt";
       } else if (sqlType === "INT" || sqlType === "INTEGER") {
         expandedProp.type = "Int";
       } else if (sqlType === "BIGINT") {
@@ -329,17 +354,29 @@ function expandCompoundType(propName, property, customTypes) {
       } else if (sqlType === "TIMESTAMP" || sqlType === "DATETIME") {
         expandedProp.type = "Timestamp";
       }
+      if (field.sql.unsigned) {
+        expandedProp.unsigned = true;
+      }
+      if (field.sql.default !== void 0) {
+        expandedProp.default = field.sql.default;
+      }
       if (field.sql.nullable !== void 0) {
         expandedProp.nullable = field.sql.nullable;
       } else if (baseProp.nullable !== void 0) {
         expandedProp.nullable = baseProp.nullable;
       }
-      if (field.sql.default !== void 0) {
-        expandedProp.default = field.sql.default;
+      if (fieldOverride?.nullable !== void 0) {
+        expandedProp.nullable = fieldOverride.nullable;
       }
     }
     if (baseProp.displayName) {
-      expandedProp.displayName = `${baseProp.displayName} (${field.suffix})`;
+      const resolvedDisplayName = (0, import_omnify_types.resolveLocalizedString)(
+        baseProp.displayName,
+        options.locale
+      );
+      if (resolvedDisplayName) {
+        expandedProp.displayName = `${resolvedDisplayName} (${field.suffix})`;
+      }
     }
     expanded.push({
       name: columnName,
@@ -349,7 +386,8 @@ function expandCompoundType(propName, property, customTypes) {
   return expanded;
 }
 function schemaToBlueprint(schema, allSchemas, options = {}) {
-  const { customTypes = /* @__PURE__ */ new Map() } = options;
+  const { customTypes = /* @__PURE__ */ new Map(), locale } = options;
+  const columnOptions = { locale };
   const tableName = toTableName(schema.name);
   const columns = [];
   const foreignKeys = [];
@@ -360,21 +398,21 @@ function schemaToBlueprint(schema, allSchemas, options = {}) {
   }
   if (schema.properties) {
     for (const [propName, property] of Object.entries(schema.properties)) {
-      const expandedProps = expandCompoundType(propName, property, customTypes);
+      const expandedProps = expandCompoundType(propName, property, customTypes, columnOptions);
       if (expandedProps) {
         for (const { name: expandedName, property: expandedProp } of expandedProps) {
-          const columnMethod2 = propertyToColumnMethod(expandedName, expandedProp);
+          const columnMethod2 = propertyToColumnMethod(expandedName, expandedProp, columnOptions);
           if (columnMethod2) {
             columns.push(columnMethod2);
           }
         }
         continue;
       }
-      const columnMethod = propertyToColumnMethod(propName, property);
+      const columnMethod = propertyToColumnMethod(propName, property, columnOptions);
       if (columnMethod) {
         columns.push(columnMethod);
       }
-      const fkResult = generateForeignKey(propName, property, allSchemas);
+      const fkResult = generateForeignKey(propName, property, allSchemas, columnOptions);
       if (fkResult) {
         columns.push(fkResult.column);
         foreignKeys.push(fkResult.foreignKey);
@@ -817,7 +855,8 @@ function generateMigrations(schemas, options = {}) {
     const offsetTimestamp = incrementTimestamp(timestamp, timestampOffset);
     timestampOffset++;
     const blueprint = schemaToBlueprint(schema, schemas, {
-      customTypes: options.customTypes
+      customTypes: options.customTypes,
+      locale: options.locale
     });
     const migration = generateCreateMigration(blueprint, {
       ...options,
@@ -1167,7 +1206,7 @@ function generateMigrationsFromChanges(changes, options = {}) {
 }
 
 // src/model/generator.ts
-var import_omnify_types = require("@famgia/omnify-types");
+var import_omnify_types2 = require("@famgia/omnify-types");
 
 // src/utils.ts
 function toSnakeCase(str) {
@@ -1196,7 +1235,8 @@ var DEFAULT_OPTIONS = {
   modelNamespace: "App\\Models",
   baseModelClassName: "BaseModel",
   baseModelPath: "app/Models/OmnifyBase",
-  modelPath: "app/Models"
+  modelPath: "app/Models",
+  customTypes: /* @__PURE__ */ new Map()
 };
 function generateLocalizedDisplayNames(displayName, indent = "        ") {
   if (displayName === void 0) {
@@ -1205,7 +1245,7 @@ function generateLocalizedDisplayNames(displayName, indent = "        ") {
   if (typeof displayName === "string") {
     return `${indent}'en' => '${escapePhpString(displayName)}',`;
   }
-  if ((0, import_omnify_types.isLocaleMap)(displayName)) {
+  if ((0, import_omnify_types2.isLocaleMap)(displayName)) {
     const entries = Object.entries(displayName).map(([locale, value]) => `${indent}'${locale}' => '${escapePhpString(value)}',`).join("\n");
     return entries;
   }
@@ -1225,7 +1265,7 @@ function generatePropertyLocalizedDisplayNames(schema, indent = "        ") {
       entries.push(`${indent}'${snakeName}' => [
 ${innerIndent}'en' => '${escapePhpString(displayName)}',
 ${indent}],`);
-    } else if ((0, import_omnify_types.isLocaleMap)(displayName)) {
+    } else if ((0, import_omnify_types2.isLocaleMap)(displayName)) {
       const localeEntries = Object.entries(displayName).map(([locale, value]) => `${innerIndent}'${locale}' => '${escapePhpString(value)}',`).join("\n");
       entries.push(`${indent}'${snakeName}' => [
 ${localeEntries}
@@ -1243,7 +1283,8 @@ function resolveOptions(options) {
     modelNamespace: options?.modelNamespace ?? DEFAULT_OPTIONS.modelNamespace,
     baseModelClassName: options?.baseModelClassName ?? DEFAULT_OPTIONS.baseModelClassName,
     baseModelPath: options?.baseModelPath ?? DEFAULT_OPTIONS.baseModelPath,
-    modelPath: options?.modelPath ?? DEFAULT_OPTIONS.modelPath
+    modelPath: options?.modelPath ?? DEFAULT_OPTIONS.modelPath,
+    customTypes: options?.customTypes ?? /* @__PURE__ */ new Map()
   };
 }
 function getCastType(propDef) {
@@ -1374,7 +1415,10 @@ function generateEntityBaseModel(schema, schemas, options, stubContent, authStub
         }
       }
     } else if (propDef.type === "Password") {
-      fillable.push(`        '${snakeName}',`);
+      const propWithFillable = propDef;
+      if (propWithFillable.fillable !== false) {
+        fillable.push(`        '${snakeName}',`);
+      }
       hidden.push(`        '${snakeName}',`);
       const cast = getCastType(propDef);
       if (cast) {
@@ -1384,10 +1428,58 @@ function generateEntityBaseModel(schema, schemas, options, stubContent, authStub
       const relMethod = generateFileRelation(propName, propDef);
       relations.push(relMethod);
     } else {
-      fillable.push(`        '${snakeName}',`);
-      const cast = getCastType(propDef);
-      if (cast) {
-        casts.push(`            '${snakeName}' => '${cast}',`);
+      const propWithOptions = propDef;
+      const isFillable = propWithOptions.fillable !== false;
+      const isHidden = propWithOptions.hidden === true;
+      const typeDef = options.customTypes.get(propDef.type);
+      const isCompoundType = typeDef?.compound && typeDef.expand;
+      if (isCompoundType && typeDef.expand) {
+        const fieldOverrides = propWithOptions.fields ?? {};
+        for (const field of typeDef.expand) {
+          const suffixSnake = toSnakeCase(field.suffix);
+          const fieldName = `${snakeName}_${suffixSnake}`;
+          const override = fieldOverrides[field.suffix];
+          const fieldFillable = override?.fillable !== void 0 ? override.fillable : isFillable;
+          if (fieldFillable) {
+            fillable.push(`        '${fieldName}',`);
+          }
+          const fieldHidden = override?.hidden !== void 0 ? override.hidden : isHidden;
+          if (fieldHidden) {
+            hidden.push(`        '${fieldName}',`);
+          }
+        }
+      } else {
+        if (isFillable) {
+          fillable.push(`        '${snakeName}',`);
+        }
+        const cast = getCastType(propDef);
+        if (cast) {
+          casts.push(`            '${snakeName}' => '${cast}',`);
+        }
+        if (isHidden) {
+          hidden.push(`        '${snakeName}',`);
+        }
+      }
+      if (typeDef?.compound && typeDef.accessors) {
+        for (const accessor of typeDef.accessors) {
+          const accessorName = `${snakeName}_${toSnakeCase(accessor.name)}`;
+          appends.push(`        '${accessorName}',`);
+          const methodName = toPascalCase(accessorName);
+          const separator = accessor.separator ?? " ";
+          const fieldRefs = accessor.fields.map((field) => {
+            const fieldName = `${snakeName}_${toSnakeCase(field)}`;
+            return `$this->${fieldName}`;
+          });
+          const accessorMethod = `    /**
+     * Get the ${accessor.name.replace(/_/g, " ")} attribute.
+     */
+    public function get${methodName}Attribute(): ?string
+    {
+        $parts = array_filter([${fieldRefs.join(", ")}], fn($v) => $v !== null && $v !== '');
+        return count($parts) > 0 ? implode('${separator}', $parts) : null;
+    }`;
+          relations.push(accessorMethod);
+        }
       }
     }
   }
@@ -2598,7 +2690,8 @@ function laravelPlugin(options) {
         modelNamespace: resolved.modelNamespace,
         baseModelNamespace: resolved.baseModelNamespace,
         modelPath: resolved.modelsPath,
-        baseModelPath: resolved.baseModelsPath
+        baseModelPath: resolved.baseModelsPath,
+        customTypes: ctx.customTypes
       };
       const models = generateModels(ctx.schemas, modelOptions);
       const outputs = models.map((model) => ({