api-core-lib 12.0.84 → 12.0.86

package/dist/cli.cjs

@@ -75,72 +75,6 @@ var import_dotenv = __toESM(require("dotenv"), 1);
 var import_swagger_parser = __toESM(require("@apidevtools/swagger-parser"), 1);
 var import_openapi_types = __toESM(require_dist(), 1);
 
-// src/generator/core/_propToZod.ts
-function _propToZod(prop) {
-  let zodChain;
-  const getMsg = (key) => `{ "message": "validation.${key}" }`;
-  switch (prop.type) {
-    case "string":
-      if (prop.enumName) {
-        zodChain = `z.enum(${prop.enumName})`;
-      } else {
-        zodChain = "z.string()";
-        if (prop.isRequired) {
-          zodChain += `.min(1, ${getMsg("string.nonempty")})`;
-        }
-        if (prop.maxLength !== void 0) zodChain += `.max(${prop.maxLength}, ${getMsg("string.max")})`;
-        if (prop.pattern) zodChain += `.regex(/${prop.pattern}/, ${getMsg("string.regex")})`;
-        if (prop.format === "email") zodChain += `.email(${getMsg("string.email")})`;
-        if (prop.format === "url") zodChain += `.url(${getMsg("string.url")})`;
-        if (prop.format === "uuid") zodChain += `.uuid(${getMsg("string.uuid")})`;
-        if (prop.format === "datetime") zodChain += `.datetime(${getMsg("string.datetime")})`;
-      }
-      break;
-    case "integer":
-      zodChain = `z.number().int(${getMsg("number.integer")})`;
-      if (prop.minimum !== void 0) zodChain += `.min(${prop.minimum}, ${getMsg("number.min")})`;
-      if (prop.maximum !== void 0) zodChain += `.max(${prop.maximum}, ${getMsg("number.max")})`;
-      break;
-    case "number":
-      zodChain = `z.number()`;
-      if (prop.minimum !== void 0) zodChain += `.min(${prop.minimum}, ${getMsg("number.min")})`;
-      if (prop.maximum !== void 0) zodChain += `.max(${prop.maximum}, ${getMsg("number.max")})`;
-      break;
-    case "boolean":
-      zodChain = `z.boolean()`;
-      break;
-    case "array":
-      const itemSchema = prop.items ? _propToZod(prop.items) : "z.any()";
-      zodChain = `z.array(${itemSchema})`;
-      if (prop.minItems !== void 0) zodChain += `.min(${prop.minItems}, ${getMsg("array.min")})`;
-      if (prop.maxItems !== void 0) zodChain += `.max(${prop.maxItems}, ${getMsg("array.max")})`;
-      break;
-    case "object":
-      if (prop.properties && prop.properties.length > 0) {
-        const shape = prop.properties.map((p) => `  ${p.name}: ${_propToZod(p)}`).join(",\n");
-        zodChain = `z.object({
-${shape}
-})`;
-      } else {
-        zodChain = "z.record(z.unknown())";
-      }
-      break;
-    default:
-      zodChain = "z.any()";
-      break;
-  }
-  if (prop.description) {
-    zodChain += `.describe(${JSON.stringify(prop.description)})`;
-  }
-  if (!prop.isRequired) {
-    zodChain += ".optional()";
-  }
-  if (prop.isNullable) {
-    zodChain += ".nullable()";
-  }
-  return zodChain;
-}
-
 // src/generator/utils/index.ts
 var getActionName = (opId) => {
   const cleanOpId = opId.replace(/_v\d+$/, "");
@@ -294,7 +228,20 @@ function parseSpecToModules(spec) {
         }
       });
       const actionName = getActionName(endpoint.operationId);
-      currentModule.actions[actionName] = { name: actionName, method: method.toUpperCase(), path: apiPath, description: endpoint.summary || "", hasQuery: (endpoint.parameters || []).some((p) => p.in === "query"), autoFetch: method.toUpperCase() === "GET" && !apiPath.includes("{"), requiresAuth: !!endpoint.security && endpoint.security.length > 0, inputType, outputType };
+      const pathParams = (apiPath.match(/{(\w+)}/g) || []).map((p) => p.slice(1, -1));
+      currentModule.actions[actionName] = {
+        name: actionName,
+        method: method.toUpperCase(),
+        path: apiPath,
+        description: endpoint.summary || "",
+        hasQuery: (endpoint.parameters || []).some((p) => p.in === "query"),
+        autoFetch: method.toUpperCase() === "GET" && !apiPath.includes("{"),
+        requiresAuth: !!endpoint.security && endpoint.security.length > 0,
+        inputType,
+        outputType,
+        pathParams
+        // <-- حفظ البارامترات المستخرجة
+      };
     }
   }
   modules.forEach((mod, name) => {
@@ -309,177 +256,153 @@ async function generateModuleFiles(module2, allSchemas, allEnums, outputDir) {
   if (!import_fs.default.existsSync(moduleOutputPath)) import_fs.default.mkdirSync(moduleOutputPath, { recursive: true });
   console.log(import_chalk.default.cyan(`
   Generating module: ${import_chalk.default.bold(module2.moduleName)}`));
-  const BUILT_IN_TYPES = /* @__PURE__ */ new Set([
-    "string",
-    "number",
-    "boolean",
-    "void",
-    "undefined",
-    "unknown",
-    "any",
-    "Date",
-    "Promise",
-    "QueryOptions",
-    "Record<string, any>",
-    "Record<string, unknown>"
-  ]);
-  const allCustomSchemaNames = [...module2.schemas].sort();
-  const schemasToImport = allCustomSchemaNames.filter((name) => !BUILT_IN_TYPES.has(name));
+  const schemasToImport = [...module2.schemas].sort();
   const enumsToImport = [...module2.enums].sort();
-  const indexContent = [`// This file is auto-generated. Do not edit directly.
-
-export * from './config';`];
-  let configContent = `// This file is auto-generated. Do not edit directly.
-
-import type { ApiModuleConfig, ActionConfigModule } from 'api-core-lib';
-`;
+  const indexExports = ["config"];
   if (schemasToImport.length > 0) {
-    configContent += `import type { ${schemasToImport.join(", ")} } from './types';
-`;
+    if (enumsToImport.length > 0) indexExports.push("enums");
+    indexExports.push("types", "validation", "mocks");
   }
-  const actionsType = Object.values(module2.actions).map((a) => `  ${a.name}: ActionConfigModule<${a.inputType}, ${a.outputType}>;`).join("\n");
-  const actionsValue = Object.values(module2.actions).map((a) => {
-    const { inputType, outputType, name, ...c } = a;
-    return `    ${name}: ${JSON.stringify(c, null, 2).replace(/\n/g, "\n    ")}`;
-  }).join(",\n");
-  configContent += `
-export const ${module2.moduleName}Module: ApiModuleConfig<{
-${actionsType}
-}> = {
-  baseEndpoint: '${module2.baseEndpoint}',
-  actions: {
-${actionsValue}
-  },
-};
-`;
-  import_fs.default.writeFileSync(import_path.default.join(moduleOutputPath, "config.ts"), configContent.trim());
-  console.log(import_chalk.default.gray(`    \u2713 config.ts`));
-  if (allCustomSchemaNames.length > 0) {
-    if (enumsToImport.length > 0) {
-      let enumsContent = `// This file is auto-generated. Do not edit directly.
+  const initialIndexContent = `// This file is auto-generated. Do not edit directly.
 
-`;
-      for (const enumName of enumsToImport) {
-        const enumDef = allEnums.get(enumName);
-        if (enumDef) {
-          enumsContent += `export const ${enumName} = ${JSON.stringify(enumDef.values)} as const;
-`;
-          enumsContent += `export type ${enumName} = typeof ${enumName}[number];
+` + indexExports.map((e) => `export * from './${e}';`).join("\n");
+  const indexFilePath = import_path.default.join(moduleOutputPath, "index.ts");
+  import_fs.default.writeFileSync(indexFilePath, initialIndexContent);
+  console.log(import_chalk.default.gray(`    \u2713 index.ts (Initial)`));
+  const moduleBaseName = module2.moduleName.replace(/Api$/, "");
+  const camelCaseModuleName = toCamelCase(moduleBaseName);
+  const allPathParams = /* @__PURE__ */ new Set();
+  Object.values(module2.actions).forEach((action) => {
+    action.pathParams.forEach((param) => allPathParams.add(param));
+  });
+  const pathParamsType = allPathParams.size > 0 ? `{ ${[...allPathParams].map((p) => `${p}?: string | number`).join("; ")} }` : "Record<string, never>";
+  let endpointsContent = `// This file is auto-generated. Do not edit directly.
 
 `;
-        }
-      }
-      import_fs.default.writeFileSync(import_path.default.join(moduleOutputPath, "enums.ts"), enumsContent);
-      console.log(import_chalk.default.gray(`    \u2713 enums.ts`));
-      indexContent.push(`export * from './enums';`);
-    }
-    let typesContent = `// This file is auto-generated. Do not edit directly.
-
+  endpointsContent += `import type { QueryOptions } from 'api-core-lib';
 `;
-    if (enumsToImport.length > 0) typesContent += `import type { ${enumsToImport.join(", ")} } from './enums';
+  const endpointTypesToImport = /* @__PURE__ */ new Set();
+  Object.values(module2.actions).forEach((action) => {
+    if (action.inputType !== "undefined" && action.inputType !== "QueryOptions") {
+      endpointTypesToImport.add(action.inputType);
+    }
+  });
+  if (endpointTypesToImport.size > 0) {
+    endpointsContent += `import type { ${[...endpointTypesToImport].join(", ")} } from './types';
 
 `;
-    for (const typeName of schemasToImport) {
-      const parsedSchema = allSchemas.get(typeName);
-      if (parsedSchema) {
-        if (parsedSchema.description) typesContent += `/** ${parsedSchema.description} */
-`;
-        typesContent += `export interface ${typeName} {
+  }
+  endpointsContent += `export const ${camelCaseModuleName}Endpoints = {
 `;
-        for (const prop of parsedSchema.properties) {
-          if (prop.description) typesContent += `  /** ${prop.description} */
+  for (const action of Object.values(module2.actions)) {
+    const params = [];
+    if (action.pathParams.length > 0) {
+      params.push(`params: { ${action.pathParams.map((p) => `${p}: string | number`).join("; ")} }`);
+    }
+    if (action.inputType !== "undefined" && action.inputType !== "QueryOptions") {
+      params.push(`body: ${action.inputType}`);
+    }
+    if (action.hasQuery) {
+      params.push(`query?: QueryOptions`);
+    }
+    endpointsContent += `  /**
+   * ${action.method} ${module2.baseEndpoint}${action.path}
+   * ${action.description}
+   */
 `;
-          let propType = prop.enumName || (prop.items ? `${prop.items.type || "any"}[]` : prop.type);
-          if (propType === "integer") propType = "number";
-          if (propType === "object") propType = "Record<string, any>";
-          typesContent += `  ${prop.name}${prop.isRequired ? "" : "?"}: ${propType};
+    endpointsContent += `  ${action.name}: (${params.join(", ")}) => ({
 `;
-        }
-        typesContent += `}
-
+    endpointsContent += `    action: '${action.name}' as const,
 `;
-      }
-    }
-    import_fs.default.writeFileSync(import_path.default.join(moduleOutputPath, "types.ts"), typesContent);
-    console.log(import_chalk.default.gray(`    \u2713 types.ts`));
-    indexContent.push(`export * from './types';`);
-    let validationContent = `// This file is auto-generated. Do not edit directly.
-
-import { z } from 'zod';
+    if (action.pathParams.length > 0) endpointsContent += `    pathParams: params,
 `;
-    if (enumsToImport.length > 0) {
-      validationContent += `import { ${enumsToImport.join(", ")} } from './enums';
+    if (action.inputType !== "undefined" && action.inputType !== "QueryOptions") endpointsContent += `    input: body,
 `;
-    }
-    for (const typeName of schemasToImport) {
-      const parsedSchema = allSchemas.get(typeName);
-      if (parsedSchema) {
-        const zodShape = parsedSchema.properties.map((p) => `  ${p.name}: ${_propToZod(p)}`).join(",\n");
-        validationContent += `
-/** Zod schema for {@link ${typeName}}. */
+    if (action.hasQuery) endpointsContent += `    input: query,
 `;
-        validationContent += `export const ${typeName}Schema = z.object({
-${zodShape}
-});
+    endpointsContent += `  }),
 
 `;
-        validationContent += `export type ${typeName}Validated = z.infer<typeof ${typeName}Schema>;
+  }
+  endpointsContent += `};
 `;
-      }
-    }
-    import_fs.default.writeFileSync(import_path.default.join(moduleOutputPath, "validation.ts"), validationContent);
-    console.log(import_chalk.default.gray(`    \u2713 validation.ts`));
-    indexContent.push(`export * from './validation';`);
-    let mocksContent = `// This file is auto-generated. Do not edit directly.
-import type { ${schemasToImport.join(", ")} } from './types';
+  import_fs.default.writeFileSync(import_path.default.join(moduleOutputPath, `${camelCaseModuleName}.endpoints.ts`), endpointsContent);
+  console.log(import_chalk.default.gray(`    \u2713 ${camelCaseModuleName}.endpoints.ts (Type-Safe Endpoints)`));
+  const hookContent = `// This file is auto-generated. Do not edit directly.
+
+import { useApiModule, UseApiModuleOptions } from 'api-core-lib/client';
+import { apiClient } from '@/lib/api-core/clientApi'; // Assuming a fixed path
+import { ${module2.moduleName} as TModuleType } from './config';
+import { ${module2.moduleName} } from './config';
+
+type ModulePathParams = ${pathParamsType};
+
+// Options for the custom hook, extending the base options with typed path parameters.
+type ${moduleBaseName}ApiOptions = Omit<UseApiModuleOptions, 'pathParams'> & {
+  pathParams?: ModulePathParams;
+};
+
+/**
+ * Custom hook for interacting with the ${moduleBaseName} API module.
+ * Simplifies API calls by pre-configuring the API client and module.
+ */
+export const use${moduleBaseName}Api = (options: ${moduleBaseName}ApiOptions = {}) => {
+  return useApiModule<typeof TModuleType['actions']>(apiClient, ${module2.moduleName}, options);
+};
 `;
-    if (enumsToImport.length > 0) mocksContent += `import { ${enumsToImport.join(", ")} } from './enums';
+  import_fs.default.writeFileSync(import_path.default.join(moduleOutputPath, `use${moduleBaseName}.ts`), hookContent);
+  console.log(import_chalk.default.gray(`    \u2713 use${moduleBaseName}.ts (Custom Hook)`));
+  const providerContent = `// This file is auto-generated. Do not edit directly.
+'use client';
+
+import React from 'react';
+import { ApiModuleProvider } from 'api-core-lib/client';
+import { use${moduleBaseName}Api } from './use${moduleBaseName}';
+
+type Options = Parameters<typeof use${moduleBaseName}Api>[0];
+
+interface ${moduleBaseName}ProviderProps {
+  children: React.ReactNode;
+  options?: Options;
+}
 
+/**
+ * A dedicated React Provider that initializes and provides the ${moduleBaseName} API context.
+ */
+export function ${moduleBaseName}Provider({ children, options = {} }: ${moduleBaseName}ProviderProps) {
+  const api = use${moduleBaseName}Api(options);
+  return <ApiModuleProvider value={api}>{children}</ApiModuleProvider>;
+}
 `;
-    for (const typeName of schemasToImport) {
-      const parsedSchema = allSchemas.get(typeName);
-      if (parsedSchema) {
-        let mockObject = {};
-        parsedSchema.properties.forEach((p) => {
-          mockObject[p.name] = _propToMock(p);
-        });
-        mocksContent += `export const mock${typeName}: ${typeName} = ${JSON.stringify(mockObject, null, 2)};
+  const providerFileName = `${moduleBaseName}.provider.tsx`;
+  import_fs.default.writeFileSync(import_path.default.join(moduleOutputPath, providerFileName), providerContent);
+  console.log(import_chalk.default.gray(`    \u2713 ${providerFileName} (React Provider)`));
+  const serverContent = `// This file is auto-generated. For server-side use only.
+
+import { createServerApi } from 'api-core-lib/server';
+import { serverApiClient } from '@/lib/api-core/serverApi'; // Assuming a fixed path
+import { ${module2.moduleName} } from './config';
 
+/**
+ * Creates a server-side instance of the ${moduleBaseName} API for pre-fetching data in RSC.
+ */
+export const create${moduleBaseName}ServerApi = () => {
+  return createServerApi(serverApiClient, ${module2.moduleName});
+};
 `;
-      }
-    }
-    import_fs.default.writeFileSync(import_path.default.join(moduleOutputPath, "mocks.ts"), mocksContent);
-    console.log(import_chalk.default.gray(`    \u2713 mocks.ts`));
-    indexContent.push(`export * from './mocks';`);
-  }
-  import_fs.default.writeFileSync(import_path.default.join(moduleOutputPath, "index.ts"), indexContent.join("\n"));
-  console.log(import_chalk.default.gray(`    \u2713 index.ts`));
-}
-function _propToMock(prop) {
-  if (prop.example) return prop.example;
-  if (prop.name.match(/image|avatar|logo|url/i)) return "https://via.placeholder.com/150";
-  if (prop.enum) return prop.enum[0];
-  switch (prop.type) {
-    case "string":
-      if (prop.format === "email") return "test@example.com";
-      if (prop.format === "uuid") return "a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11";
-      return `Mock ${toPascalCase(prop.name)}`;
-    case "integer":
-    case "number":
-      return 1;
-    case "boolean":
-      return true;
-    case "array":
-      return prop.items ? [_propToMock(prop.items)] : [];
-    case "object":
-      const mock = {};
-      if (prop.properties) prop.properties.forEach((p) => {
-        mock[p.name] = _propToMock(p);
-      });
-      return mock;
-    default:
-      return null;
-  }
+  import_fs.default.writeFileSync(import_path.default.join(moduleOutputPath, `${camelCaseModuleName}.server.ts`), serverContent);
+  console.log(import_chalk.default.gray(`    \u2713 ${camelCaseModuleName}.server.ts (Server-Side Helper)`));
+  const newExports = [
+    `
+// Generated API helpers`,
+    `export * from './${camelCaseModuleName}.endpoints';`,
+    `export * from './use${moduleBaseName}';`,
+    `export * from './${moduleBaseName}.provider';`,
+    // <-- Note: no .tsx in export
+    `export * from './${camelCaseModuleName}.server';`
+  ].join("\n");
+  import_fs.default.appendFileSync(indexFilePath, newExports);
+  console.log(import_chalk.default.gray(`    \u2713 index.ts (Updated with helpers)`));
 }
 async function runGenerator(options) {
   console.log(import_chalk.default.cyan.bold("\u{1F680} Starting API Development Platform Generator (Sapphire Edition)..."));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "api-core-lib",
-  "version": "12.0.84",
+  "version": "12.0.86",
   "description": "A flexible and powerful API client library for modern web applications.",
   "type": "module",
   "exports": {