@famgia/omnify-laravel 0.0.83 → 0.0.85

package/dist/index.cjs

@@ -2659,6 +2659,129 @@ var SKIP_FIELDS = /* @__PURE__ */ new Set([
   "remember_token",
   "email_verified_at"
 ]);
+function getExampleValue(fieldName, type) {
+  if (fieldName.endsWith("_lastname") && !fieldName.includes("kana")) {
+    return "\u7530\u4E2D";
+  }
+  if (fieldName.endsWith("_firstname") && !fieldName.includes("kana")) {
+    return "\u592A\u90CE";
+  }
+  if (fieldName.includes("kana_lastname") || fieldName.endsWith("_kana_lastname")) {
+    return "\u30BF\u30CA\u30AB";
+  }
+  if (fieldName.includes("kana_firstname") || fieldName.endsWith("_kana_firstname")) {
+    return "\u30BF\u30ED\u30A6";
+  }
+  if (fieldName.includes("email")) {
+    return "user@example.com";
+  }
+  if (fieldName.includes("password")) {
+    return "password123";
+  }
+  if (fieldName.includes("url") || fieldName.includes("website")) {
+    return "https://example.com";
+  }
+  if (fieldName.endsWith("_id")) {
+    return 1;
+  }
+  if (fieldName.endsWith("_at")) {
+    return "2024-01-01T00:00:00Z";
+  }
+  if (type === "boolean") {
+    return true;
+  }
+  if (type === "integer") {
+    return 1;
+  }
+  return void 0;
+}
+function mapValidationToOpenApiType(rules, fieldName) {
+  if (fieldName.includes("email")) {
+    return { type: "string", format: "email" };
+  }
+  if (fieldName.includes("password")) {
+    return { type: "string", format: "password" };
+  }
+  if (fieldName.includes("url") || fieldName.includes("website")) {
+    return { type: "string", format: "uri" };
+  }
+  for (const rule of rules) {
+    if (rule === "'integer'") {
+      return { type: "integer" };
+    }
+    if (rule === "'boolean'") {
+      return { type: "boolean" };
+    }
+    if (rule === "'numeric'") {
+      return { type: "number" };
+    }
+    if (rule === "'array'") {
+      return { type: "array" };
+    }
+    if (rule === "'email'") {
+      return { type: "string", format: "email" };
+    }
+    if (rule === "'url'") {
+      return { type: "string", format: "uri" };
+    }
+    if (rule === "'date'") {
+      if (fieldName.endsWith("_at")) {
+        return { type: "string", format: "date-time" };
+      }
+      return { type: "string", format: "date" };
+    }
+  }
+  return { type: "string" };
+}
+function extractConstraints(rules) {
+  const constraints = {};
+  for (const rule of rules) {
+    const maxMatch = rule.match(/'max:(\d+)'/);
+    if (maxMatch) {
+      constraints.maxLength = parseInt(maxMatch[1], 10);
+    }
+    const minMatch = rule.match(/'min:(\d+)'/);
+    if (minMatch) {
+      constraints.minLength = parseInt(minMatch[1], 10);
+    }
+    if (rule === "'nullable'") {
+      constraints.nullable = true;
+    }
+    const inMatch = rule.match(/Rule::in\(\[([^\]]+)\]\)/);
+    if (inMatch) {
+      const values = inMatch[1].split(",").map((v) => v.trim().replace(/^'|'$/g, ""));
+      constraints.enum = values;
+    }
+  }
+  return constraints;
+}
+function formatRequestOpenApiProperty(prop, indent) {
+  const parts = [`property: '${prop.property}'`, `type: '${prop.type}'`];
+  if (prop.format) {
+    parts.push(`format: '${prop.format}'`);
+  }
+  if (prop.maxLength) {
+    parts.push(`maxLength: ${prop.maxLength}`);
+  }
+  if (prop.minLength) {
+    parts.push(`minLength: ${prop.minLength}`);
+  }
+  if (prop.nullable) {
+    parts.push(`nullable: true`);
+  }
+  if (prop.enum) {
+    const enumStr = prop.enum.map((v) => `'${v}'`).join(", ");
+    parts.push(`enum: [${enumStr}]`);
+  }
+  if (prop.example !== void 0) {
+    if (typeof prop.example === "string") {
+      parts.push(`example: '${escapePhpString2(prop.example)}'`);
+    } else {
+      parts.push(`example: ${prop.example}`);
+    }
+  }
+  return `${indent}new OA\\Property(${parts.join(", ")})`;
+}
 function resolveOptions3(options) {
   return {
     baseRequestNamespace: options?.baseRequestNamespace ?? DEFAULT_OPTIONS2.baseRequestNamespace,
@@ -3192,12 +3315,82 @@ ${attributeLines.join("\n")}
     module: module2
   };
 }
-function generateStoreRequest(schema, options) {
+function generateRequestOpenApiProperties(schema, schemas, options, isStore) {
+  const properties = [];
+  const requiredFields = [];
+  const schemaProps = schema.properties ?? {};
+  for (const [propName, propDef] of Object.entries(schemaProps)) {
+    const snakeName = toSnakeCase(propName);
+    if (SKIP_FIELDS.has(snakeName)) continue;
+    if (propDef.type === "Association") {
+      const assoc = propDef;
+      if (assoc.relation !== "ManyToOne" && assoc.relation !== "OneToOne") {
+        continue;
+      }
+      const fkName = `${snakeName}_id`;
+      const rules2 = isStore ? generateStoreRules(propName, propDef, schema, schemas, options) : generateUpdateRules(propName, propDef, schema, schemas, options);
+      const openApiType2 = mapValidationToOpenApiType(rules2, fkName);
+      const constraints2 = extractConstraints(rules2);
+      const example2 = getExampleValue(fkName, openApiType2.type);
+      const prop2 = {
+        property: fkName,
+        ...openApiType2,
+        ...constraints2
+      };
+      if (example2 !== void 0) prop2.example = example2;
+      properties.push(prop2);
+      if (isStore && !propDef.nullable) {
+        requiredFields.push(fkName);
+      }
+      continue;
+    }
+    const expandedFields = expandCompoundTypeFields(propName, propDef, options);
+    if (expandedFields.length > 0) {
+      for (const field of expandedFields) {
+        const openApiType2 = mapValidationToOpenApiType(field.rules, field.fieldName);
+        const constraints2 = extractConstraints(field.rules);
+        const example2 = getExampleValue(field.fieldName, openApiType2.type);
+        const prop2 = {
+          property: field.fieldName,
+          ...openApiType2,
+          ...constraints2
+        };
+        if (example2 !== void 0) prop2.example = example2;
+        properties.push(prop2);
+        if (isStore && field.rules.includes("'required'")) {
+          requiredFields.push(field.fieldName);
+        }
+      }
+      continue;
+    }
+    const rules = isStore ? generateStoreRules(propName, propDef, schema, schemas, options) : generateUpdateRules(propName, propDef, schema, schemas, options);
+    const openApiType = mapValidationToOpenApiType(rules, snakeName);
+    const constraints = extractConstraints(rules);
+    const example = getExampleValue(snakeName, openApiType.type);
+    const prop = {
+      property: snakeName,
+      ...openApiType,
+      ...constraints
+    };
+    if (example !== void 0) prop.example = example;
+    properties.push(prop);
+    if (isStore && rules.includes("'required'")) {
+      requiredFields.push(snakeName);
+    }
+  }
+  return { properties, requiredFields };
+}
+function generateStoreRequest(schema, schemas, options) {
   const className = toPascalCase(schema.name);
   const module2 = getModuleName(schema);
   const namespaceModule = module2 ? `\\${module2}` : "";
   const namespace = `${options.requestNamespace}${namespaceModule}`;
   const baseNamespace = `${options.baseRequestNamespace}${namespaceModule}`;
+  const { properties, requiredFields } = generateRequestOpenApiProperties(schema, schemas, options, true);
+  const propsIndent = "        ";
+  const openApiPropsFormatted = properties.map((prop) => formatRequestOpenApiProperty(prop, propsIndent)).join(",\n");
+  const requiredArray = requiredFields.length > 0 ? `
+    required: [${requiredFields.map((f) => `'${f}'`).join(", ")}],` : "";
   const content = `<?php
 
 /**
@@ -3208,8 +3401,15 @@ function generateStoreRequest(schema, options) {
 
 namespace ${namespace};
 
+use OpenApi\\Attributes as OA;
 use ${baseNamespace}\\${className}StoreRequestBase;
 
+#[OA\\Schema(
+    schema: '${schema.name}StoreRequest',${requiredArray}
+    properties: [
+${openApiPropsFormatted},
+    ]
+)]
 class ${className}StoreRequest extends ${className}StoreRequestBase
 {
     /**
@@ -3267,12 +3467,15 @@ class ${className}StoreRequest extends ${className}StoreRequestBase
     module: module2
   };
 }
-function generateUpdateRequest(schema, options) {
+function generateUpdateRequest(schema, schemas, options) {
   const className = toPascalCase(schema.name);
   const module2 = getModuleName(schema);
   const namespaceModule = module2 ? `\\${module2}` : "";
   const namespace = `${options.requestNamespace}${namespaceModule}`;
   const baseNamespace = `${options.baseRequestNamespace}${namespaceModule}`;
+  const { properties } = generateRequestOpenApiProperties(schema, schemas, options, false);
+  const propsIndent = "        ";
+  const openApiPropsFormatted = properties.map((prop) => formatRequestOpenApiProperty(prop, propsIndent)).join(",\n");
   const content = `<?php
 
 /**
@@ -3283,8 +3486,15 @@ function generateUpdateRequest(schema, options) {
 
 namespace ${namespace};
 
+use OpenApi\\Attributes as OA;
 use ${baseNamespace}\\${className}UpdateRequestBase;
 
+#[OA\\Schema(
+    schema: '${schema.name}UpdateRequest',
+    properties: [
+${openApiPropsFormatted},
+    ]
+)]
 class ${className}UpdateRequest extends ${className}UpdateRequestBase
 {
     /**
@@ -3350,8 +3560,8 @@ function generateRequests(schemas, options) {
     if (schema.options?.hidden === true) continue;
     requests.push(generateStoreRequestBase(schema, schemas, resolved));
     requests.push(generateUpdateRequestBase(schema, schemas, resolved));
-    requests.push(generateStoreRequest(schema, resolved));
-    requests.push(generateUpdateRequest(schema, resolved));
+    requests.push(generateStoreRequest(schema, schemas, resolved));
+    requests.push(generateUpdateRequest(schema, schemas, resolved));
   }
   return requests;
 }
@@ -3373,6 +3583,155 @@ var SKIP_FIELDS2 = /* @__PURE__ */ new Set([
   "password",
   "remember_token"
 ]);
+function mapTsTypeToOpenApi(tsType, fieldName) {
+  if (fieldName.includes("email")) {
+    return { type: "string", format: "email" };
+  }
+  switch (tsType) {
+    case "string":
+      return { type: "string" };
+    case "number":
+      return { type: "number" };
+    case "boolean":
+      return { type: "boolean" };
+    default:
+      return { type: "string" };
+  }
+}
+function getOpenApiType(propDef, fieldName) {
+  if (fieldName.includes("email")) {
+    return { type: "string", format: "email" };
+  }
+  if (fieldName.includes("password")) {
+    return { type: "string", format: "password" };
+  }
+  switch (propDef.type) {
+    case "String":
+    case "Text":
+    case "LongText":
+      return { type: "string" };
+    case "Int":
+    case "BigInt":
+      return { type: "integer" };
+    case "Float":
+    case "Decimal":
+      return { type: "number" };
+    case "Boolean":
+      return { type: "boolean" };
+    case "Date":
+      return { type: "string", format: "date" };
+    case "DateTime":
+    case "Timestamp":
+      return { type: "string", format: "date-time" };
+    case "Email":
+      return { type: "string", format: "email" };
+    case "UUID":
+      return { type: "string", format: "uuid" };
+    case "JSON":
+      return { type: "object" };
+    default:
+      return { type: "string" };
+  }
+}
+function generateOpenApiProperties(schema, options) {
+  const properties = [];
+  const schemaProps = schema.properties ?? {};
+  if (schema.options?.id !== false) {
+    properties.push({
+      property: "id",
+      type: "integer",
+      example: 1
+    });
+  }
+  for (const [propName, propDef] of Object.entries(schemaProps)) {
+    const snakeName = toSnakeCase(propName);
+    if (SKIP_FIELDS2.has(snakeName)) continue;
+    if (propDef.hidden === true) continue;
+    if (propDef.type === "Association") continue;
+    const typeDef = options.customTypes.get(propDef.type);
+    if (typeDef?.compound && typeDef.expand) {
+      for (const field of typeDef.expand) {
+        const suffixSnake = toSnakeCase(field.suffix);
+        const fieldName = `${snakeName}_${suffixSnake}`;
+        const tsType = field.typescript?.type ?? "string";
+        const openApiType2 = mapTsTypeToOpenApi(tsType, fieldName);
+        const prop2 = {
+          property: fieldName,
+          ...openApiType2
+        };
+        const sqlDef = field.sql;
+        if (sqlDef?.length) {
+          prop2.maxLength = sqlDef.length;
+        }
+        properties.push(prop2);
+      }
+      if (typeDef.accessors) {
+        for (const accessor of typeDef.accessors) {
+          const accessorName = `${snakeName}_${toSnakeCase(accessor.name)}`;
+          properties.push({
+            property: accessorName,
+            type: "string"
+          });
+        }
+      }
+      continue;
+    }
+    const openApiType = getOpenApiType(propDef, snakeName);
+    const prop = {
+      property: snakeName,
+      ...openApiType
+    };
+    const length = propDef.length;
+    if (length) {
+      prop.maxLength = length;
+    }
+    if (propDef.nullable) {
+      prop.nullable = true;
+    }
+    properties.push(prop);
+  }
+  if (schema.options?.timestamps !== false) {
+    properties.push({
+      property: "created_at",
+      type: "string",
+      format: "date-time"
+    });
+    properties.push({
+      property: "updated_at",
+      type: "string",
+      format: "date-time"
+    });
+  }
+  if (schema.options?.softDelete) {
+    properties.push({
+      property: "deleted_at",
+      type: "string",
+      format: "date-time",
+      nullable: true
+    });
+  }
+  return properties;
+}
+function formatOpenApiProperty(prop, indent) {
+  const parts = [`property: '${prop.property}'`, `type: '${prop.type}'`];
+  if (prop.format) {
+    parts.push(`format: '${prop.format}'`);
+  }
+  if (prop.maxLength) {
+    parts.push(`maxLength: ${prop.maxLength}`);
+  }
+  if (prop.nullable) {
+    parts.push(`nullable: true`);
+  }
+  if (prop.example !== void 0) {
+    if (typeof prop.example === "string") {
+      parts.push(`example: '${prop.example}'`);
+    } else {
+      parts.push(`example: ${prop.example}`);
+    }
+  }
+  return `${indent}new OA\\Property(${parts.join(", ")})`;
+}
 function resolveOptions4(options) {
   return {
     baseResourceNamespace: options?.baseResourceNamespace ?? DEFAULT_OPTIONS3.baseResourceNamespace,
@@ -3383,6 +3742,9 @@ function resolveOptions4(options) {
     locale: options?.locale ?? DEFAULT_OPTIONS3.locale
   };
 }
+function escapePhpString3(str) {
+  return str.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+}
 function getModuleName2(schema) {
   if (schema.module) {
     return schema.module;
@@ -3530,6 +3892,10 @@ function generateResource(schema, options) {
   const namespaceModule = module2 ? `\\${module2}` : "";
   const namespace = `${options.resourceNamespace}${namespaceModule}`;
   const baseNamespace = `${options.baseResourceNamespace}${namespaceModule}`;
+  const openApiProps = generateOpenApiProperties(schema, options);
+  const propsIndent = "        ";
+  const openApiPropsFormatted = openApiProps.map((prop) => formatOpenApiProperty(prop, propsIndent)).join(",\n");
+  const description = schema.displayName ? typeof schema.displayName === "string" ? schema.displayName : schema.displayName["en"] ?? schema.name : `${schema.name} resource`;
   const content = `<?php
 
 /**
@@ -3541,8 +3907,16 @@ function generateResource(schema, options) {
 namespace ${namespace};
 
 use Illuminate\\Http\\Request;
+use OpenApi\\Attributes as OA;
 use ${baseNamespace}\\${className}ResourceBase;
 
+#[OA\\Schema(
+    schema: '${schema.name}',
+    description: '${escapePhpString3(description)}',
+    properties: [
+${openApiPropsFormatted},
+    ]
+)]
 class ${className}Resource extends ${className}ResourceBase
 {
     /**
@@ -3892,14 +4266,22 @@ function laravelPlugin(options) {
           existingContent = null;
         }
       } else if ((0, import_node_fs.existsSync)(configAppPath)) {
-        laravelVersion = "laravel10-";
         try {
-          existingContent = (0, import_node_fs.readFileSync)(configAppPath, "utf-8");
+          const configContent = (0, import_node_fs.readFileSync)(configAppPath, "utf-8");
+          if (/'providers'\s*=>\s*\[/.test(configContent)) {
+            laravelVersion = "laravel10-";
+            existingContent = configContent;
+          } else {
+            laravelVersion = "laravel11+";
+            existingContent = null;
+          }
         } catch {
+          laravelVersion = "laravel11+";
           existingContent = null;
         }
       } else {
         laravelVersion = "laravel11+";
+        existingContent = null;
       }
       const registration = generateProviderRegistration(existingContent, laravelVersion, laravelRoot);
       if (registration && !registration.alreadyRegistered) {