api-core-lib 16.1.0 → 16.12.133

package/dist/cli.cjs

@@ -0,0 +1,619 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// node_modules/openapi-types/dist/index.js
+var require_dist = __commonJS({
+  "node_modules/openapi-types/dist/index.js"(exports2) {
+    "use strict";
+    exports2.__esModule = true;
+    exports2.OpenAPIV2 = exports2.OpenAPIV3 = void 0;
+    var OpenAPIV32;
+    (function(OpenAPIV33) {
+      var HttpMethods;
+      (function(HttpMethods2) {
+        HttpMethods2["GET"] = "get";
+        HttpMethods2["PUT"] = "put";
+        HttpMethods2["POST"] = "post";
+        HttpMethods2["DELETE"] = "delete";
+        HttpMethods2["OPTIONS"] = "options";
+        HttpMethods2["HEAD"] = "head";
+        HttpMethods2["PATCH"] = "patch";
+        HttpMethods2["TRACE"] = "trace";
+      })(HttpMethods = OpenAPIV33.HttpMethods || (OpenAPIV33.HttpMethods = {}));
+    })(OpenAPIV32 = exports2.OpenAPIV3 || (exports2.OpenAPIV3 = {}));
+    var OpenAPIV2;
+    (function(OpenAPIV22) {
+      var HttpMethods;
+      (function(HttpMethods2) {
+        HttpMethods2["GET"] = "get";
+        HttpMethods2["PUT"] = "put";
+        HttpMethods2["POST"] = "post";
+        HttpMethods2["DELETE"] = "delete";
+        HttpMethods2["OPTIONS"] = "options";
+        HttpMethods2["HEAD"] = "head";
+        HttpMethods2["PATCH"] = "patch";
+      })(HttpMethods = OpenAPIV22.HttpMethods || (OpenAPIV22.HttpMethods = {}));
+    })(OpenAPIV2 = exports2.OpenAPIV2 || (exports2.OpenAPIV2 = {}));
+  }
+});
+
+// src/cli.ts
+var import_commander = require("commander");
+var import_path2 = __toESM(require("path"), 1);
+
+// src/generator/v1.ts
+var import_fs = __toESM(require("fs"), 1);
+var import_path = __toESM(require("path"), 1);
+var import_util = __toESM(require("util"), 1);
+var import_chalk = __toESM(require("chalk"), 1);
+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);
+var import_inquirer = __toESM(require("inquirer"), 1);
+
+// src/generator/utils/index.ts
+var getActionName = (opId) => {
+  const cleanOpId = opId.replace(/_v\d+$/, "");
+  const parts = cleanOpId.split("_");
+  if (parts.length > 1) {
+    const actionPart = parts.slice(1).join("_");
+    return toCamelCase(actionPart);
+  }
+  return toCamelCase(cleanOpId);
+};
+var toCamelCase = (str) => {
+  const s = toPascalCase(str);
+  return s.charAt(0).toLowerCase() + s.slice(1);
+};
+var toPascalCase = (str) => str.replace(/[^a-zA-Z0-9_]/g, " ").replace(/(?:^\w|[A-Z]|\b\w)/g, (w) => w.toUpperCase()).replace(/\s+/g, "");
+
+// 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/core/_propToMock.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;
+  }
+}
+
+// src/generator/v1.ts
+var DEBUG_MODE = process.env.DEBUG === "true";
+var debugLog = (title, data) => DEBUG_MODE && console.log(import_chalk.default.yellow(`
+[DEBUG: ${title}]`), import_util.default.inspect(data, { depth: 5, colors: true }));
+var toCamelCase2 = (str) => str.replace(/[-_\s]+(.)?/g, (_, c) => c ? c.toUpperCase() : "").replace(/^(.)/, (c) => c.toLowerCase());
+var toPascalCase2 = (str) => str.replace(/(?:^|[-_\s])(\w)/g, (_, c) => c.toUpperCase());
+var sanitizeForModuleName = (name) => toPascalCase2(name.replace(/api/gi, "").replace(/[^a-zA-Z0-9\s-]/g, ""));
+function findCommonPath(paths) {
+  if (!paths || paths.length === 0) return "/";
+  const sortedPaths = paths.sort();
+  const first = sortedPaths[0].split("/");
+  const last = sortedPaths[sortedPaths.length - 1].split("/");
+  let i = 0;
+  while (i < first.length && first[i] === last[i]) i++;
+  return first.slice(0, i).join("/") || "/";
+}
+function parseSchema(name, schema, allEnums) {
+  const properties = [];
+  const enums = {};
+  if (schema.properties) {
+    for (const propName in schema.properties) {
+      const propSchema = schema.properties[propName];
+      let itemSchema, generatedEnumName;
+      if (propSchema.type === "array" && propSchema.items) {
+        const itemTypeName = `${toPascalCase2(name)}${toPascalCase2(propName)}Item`;
+        itemSchema = parseSchema(itemTypeName, propSchema.items, allEnums).properties[0];
+      }
+      if (propSchema.enum) {
+        const enumName = `${toPascalCase2(name)}${toPascalCase2(propName)}Enum`;
+        enums[propName] = propSchema.enum;
+        if (!allEnums.has(enumName)) {
+          allEnums.set(enumName, { name: enumName, values: propSchema.enum });
+        }
+        generatedEnumName = enumName;
+      }
+      properties.push({ name: propName, type: propSchema.type || "object", isRequired: (schema.required || []).includes(propName), isNullable: propSchema.nullable || false, description: propSchema.description, example: propSchema.example, enum: propSchema.enum, enumName: generatedEnumName, format: propSchema.format, items: itemSchema, properties: propSchema.properties ? parseSchema(`${name}${toPascalCase2(propName)}`, propSchema, allEnums).properties : void 0, minLength: propSchema.minLength, maxLength: propSchema.maxLength, pattern: propSchema.pattern, minimum: propSchema.minimum, maximum: propSchema.maximum, minItems: propSchema.minItems, maxItems: propSchema.maxItems });
+    }
+  }
+  return { name, description: schema.description, properties, enums };
+}
+function parseSpecToModules(spec) {
+  const modules = /* @__PURE__ */ new Map(), allSchemas = /* @__PURE__ */ new Map(), allEnums = /* @__PURE__ */ new Map(), modulePaths = /* @__PURE__ */ new Map();
+  const BUILT_IN_TYPES = /* @__PURE__ */ new Set(["string", "number", "boolean", "void", "undefined", "unknown", "any", "Date", "Promise", "QueryOptions", "Record<string, any>", "Record<string, unknown>"]);
+  const registerSchema = (schema, baseName) => {
+    if (!schema) return "Record<string, any>";
+    if (schema.type === "array" && schema.items) {
+      const itemSchema = schema.items, itemBaseName = `${baseName}Item`;
+      if (itemSchema.properties || itemSchema.type === "object") return `${registerSchema(itemSchema, itemBaseName)}[]`;
+      return `${itemSchema.type === "integer" ? "number" : itemSchema.type || "any"}[]`;
+    }
+    if (schema.type === "object" || schema.properties || schema.allOf || !schema.type) {
+      if (!schema.properties && !schema.allOf) return "Record<string, any>";
+      const typeName = toPascalCase2(baseName.replace(/_v\d+(Request|Response)$/, "$1"));
+      if (!allSchemas.has(typeName)) allSchemas.set(typeName, parseSchema(typeName, schema, allEnums));
+      return typeName;
+    }
+    return schema.type === "integer" ? "number" : schema.type || "any";
+  };
+  for (const apiPath in spec.paths) {
+    const pathItem = spec.paths[apiPath];
+    if (!pathItem) continue;
+    for (const method in pathItem) {
+      if (!Object.values(import_openapi_types.OpenAPIV3.HttpMethods).includes(method)) continue;
+      const endpoint = pathItem[method];
+      if (!endpoint.tags || endpoint.tags.length === 0 || !endpoint.operationId) continue;
+      const moduleName = sanitizeForModuleName(endpoint.tags[0]);
+      if (!modules.has(moduleName)) {
+        modules.set(moduleName, { moduleName, baseEndpoint: "", actions: {}, schemas: /* @__PURE__ */ new Set(), enums: /* @__PURE__ */ new Set() });
+        modulePaths.set(moduleName, []);
+      }
+      const currentModule = modules.get(moduleName);
+      modulePaths.get(moduleName).push(apiPath);
+      const successKey = Object.keys(endpoint.responses).find((c) => c.startsWith("2"));
+      const successRes = successKey ? endpoint.responses[successKey] : void 0;
+      const outputType = successKey === "204" ? "void" : registerSchema(successRes?.content?.["application/json"]?.schema, `${endpoint.operationId}Response`);
+      const reqBody = endpoint.requestBody;
+      let inputType = "undefined";
+      if (reqBody?.content?.["application/json"]?.schema) inputType = registerSchema(reqBody.content["application/json"].schema, `${endpoint.operationId}Request`);
+      else if ((endpoint.parameters || []).some((p) => p.in === "query")) inputType = "QueryOptions";
+      [inputType, outputType].forEach((t) => {
+        const cleanType = t.replace("[]", "");
+        if (cleanType && !BUILT_IN_TYPES.has(cleanType)) {
+          currentModule.schemas.add(cleanType);
+          const schemaDef = allSchemas.get(cleanType);
+          if (schemaDef) Object.keys(schemaDef.enums).forEach((propName) => currentModule.enums.add(`${toPascalCase2(cleanType)}${toPascalCase2(propName)}Enum`));
+        }
+      });
+      currentModule.actions[getActionName(endpoint.operationId)] = { name: getActionName(endpoint.operationId), 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: (apiPath.match(/{(\w+)}/g) || []).map((p) => p.slice(1, -1)) };
+    }
+  }
+  modules.forEach((mod, name) => {
+    mod.baseEndpoint = findCommonPath(modulePaths.get(name));
+    Object.values(mod.actions).forEach((action) => action.path = action.path.replace(mod.baseEndpoint, "").replace(/^\//, "") || "/");
+  });
+  debugLog("Final Parsed Modules", Object.fromEntries(modules));
+  return { modules, allSchemas, allEnums };
+}
+async function generateModuleFiles(module2, allSchemas, allEnums, outputDir) {
+  const moduleOutputPath = import_path.default.join(outputDir, module2.moduleName);
+  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 schemasToImport = [...module2.schemas].filter((name) => !BUILT_IN_TYPES.has(name)).sort();
+  const enumsToImport = [...module2.enums].sort();
+  const createdFileExports = ["config"];
+  let configContent = `// Auto-generated file. Do not edit.
+
+import type { ApiModuleConfig, ActionConfigModule, QueryOptions } from 'api-core-lib';
+`;
+  if (schemasToImport.length > 0) configContent += `import type { ${schemasToImport.join(", ")} } from './types';
+`;
+  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}: 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 (schemasToImport.length > 0) {
+    if (enumsToImport.length > 0) {
+      let enumsContent = `// Auto-generated file. Do not edit.
+
+`;
+      enumsToImport.forEach((enumName) => {
+        const enumDef = allEnums.get(enumName);
+        if (enumDef) {
+          enumsContent += `export const ${enumName} = ${JSON.stringify(enumDef.values)} as const;
+`;
+          enumsContent += `export type ${enumName} = typeof ${enumName}[number];
+
+`;
+        }
+      });
+      import_fs.default.writeFileSync(import_path.default.join(moduleOutputPath, "enums.ts"), enumsContent.trim());
+      console.log(import_chalk.default.gray(`    \u2713 enums.ts`));
+      createdFileExports.push("enums");
+    }
+    let typesContent = `// Auto-generated file. Do not edit.
+
+`;
+    if (enumsToImport.length > 0) typesContent += `import type { ${enumsToImport.join(", ")} } from './enums';
+
+`;
+    schemasToImport.forEach((typeName) => {
+      const parsedSchema = allSchemas.get(typeName);
+      if (parsedSchema) {
+        if (parsedSchema.description) typesContent += `/** ${parsedSchema.description} */
+`;
+        typesContent += `export interface ${typeName} {
+`;
+        parsedSchema.properties.forEach((prop) => {
+          if (prop.description) typesContent += `  /** ${prop.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};
+`;
+        });
+        typesContent += `}
+
+`;
+      }
+    });
+    import_fs.default.writeFileSync(import_path.default.join(moduleOutputPath, "types.ts"), typesContent.trim());
+    console.log(import_chalk.default.gray(`    \u2713 types.ts`));
+    createdFileExports.push("types");
+    let validationContent = `// Auto-generated file. Do not edit.
+
+import { z } from 'zod';
+`;
+    if (enumsToImport.length > 0) validationContent += `import { ${enumsToImport.join(", ")} } from './enums';
+`;
+    schemasToImport.forEach((typeName) => {
+      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}}. */
+`;
+        validationContent += `export const ${typeName}Schema = z.object({
+${zodShape}
+});
+
+`;
+        validationContent += `export type ${typeName}Validated = z.infer<typeof ${typeName}Schema>;
+`;
+      }
+    });
+    import_fs.default.writeFileSync(import_path.default.join(moduleOutputPath, "validation.ts"), validationContent.trim());
+    console.log(import_chalk.default.gray(`    \u2713 validation.ts`));
+    createdFileExports.push("validation");
+    let mocksContent = `// Auto-generated file. Do not edit.
+import type { ${schemasToImport.join(", ")} } from './types';
+`;
+    if (enumsToImport.length > 0) mocksContent += `import { ${enumsToImport.join(", ")} } from './enums';
+
+`;
+    schemasToImport.forEach((typeName) => {
+      const parsedSchema = allSchemas.get(typeName);
+      if (parsedSchema) {
+        const mockObject = {};
+        parsedSchema.properties.forEach((p) => {
+          mockObject[p.name] = _propToMock(p);
+        });
+        mocksContent += `export const mock${typeName}: ${typeName} = ${JSON.stringify(mockObject, null, 2)};
+
+`;
+      }
+    });
+    import_fs.default.writeFileSync(import_path.default.join(moduleOutputPath, "mocks.ts"), mocksContent.trim());
+    console.log(import_chalk.default.gray(`    \u2713 mocks.ts`));
+    createdFileExports.push("mocks");
+  }
+  const indexFilePath = import_path.default.join(moduleOutputPath, "index.ts");
+  const initialIndexContent = `// Auto-generated file. Do not edit.
+` + createdFileExports.map((e) => `export * from './${e}';`).join("\n");
+  import_fs.default.writeFileSync(indexFilePath, initialIndexContent);
+  console.log(import_chalk.default.gray(`    \u2713 index.ts (Initial Entry Point)`));
+  const moduleBaseName = module2.moduleName.replace(/Api$/, "");
+  const camelCaseModuleName = toCamelCase2(moduleBaseName);
+  let endpointsContent = `// Auto-generated file. Do not edit.
+
+`;
+  endpointsContent += `import type { QueryOptions } from 'api-core-lib';
+`;
+  const endpointTypesToImport = /* @__PURE__ */ new Set();
+  Object.values(module2.actions).forEach((action) => {
+    if (action.inputType !== "undefined" && action.inputType !== "QueryOptions" && !BUILT_IN_TYPES.has(action.inputType)) {
+      endpointTypesToImport.add(action.inputType);
+    }
+  });
+  if (endpointTypesToImport.size > 0) {
+    endpointsContent += `import type { ${[...endpointTypesToImport].join(", ")} } from './types';
+
+`;
+  }
+  endpointsContent += `export const ${camelCaseModuleName}Endpoints = {
+`;
+  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}
+   */
+`;
+    endpointsContent += `  ${action.name}: (${params.join(", ")}) => ({
+`;
+    endpointsContent += `    action: '${action.name}' as const,
+`;
+    if (action.pathParams.length > 0) endpointsContent += `    pathParams: params,
+`;
+    if (action.inputType !== "undefined" && action.inputType !== "QueryOptions") endpointsContent += `    input: body,
+`;
+    else if (action.hasQuery) endpointsContent += `    input: query,
+`;
+    endpointsContent += `  }),
+
+`;
+  }
+  endpointsContent += `};
+`;
+  import_fs.default.writeFileSync(import_path.default.join(moduleOutputPath, `${camelCaseModuleName}.endpoints.ts`), endpointsContent.trim());
+  console.log(import_chalk.default.gray(`    \u2713 ${camelCaseModuleName}.endpoints.ts`));
+  const contextFileContent = `// Auto-generated file. Do not edit.
+'use client';
+
+import React from 'react';
+import { createApiModuleContext, useApiModule } from 'api-core-lib/client';
+import { apiClient } from '@/lib/api-core/clientApi';
+import { ${module2.moduleName}, ${module2.moduleName} as TModuleType } from './config';
+
+const { Provider, useContext: use${moduleBaseName}Context } = createApiModuleContext<typeof TModuleType['actions']>();
+
+export { use${moduleBaseName}Context };
+
+type Options = Parameters<typeof useApiModule>[2];
+
+interface ${moduleBaseName}ProviderProps {
+  children: React.ReactNode;
+  options?: Options;
+}
+
+export function ${moduleBaseName}Provider({ children, options = {} }: ${moduleBaseName}ProviderProps) {
+  const api = useApiModule(apiClient, ${module2.moduleName}, options);
+  return <Provider value={api}>{children}</Provider>;
+}`;
+  const contextFileName = `${camelCaseModuleName}.context.tsx`;
+  import_fs.default.writeFileSync(import_path.default.join(moduleOutputPath, contextFileName), contextFileContent.trim());
+  console.log(import_chalk.default.gray(`    \u2713 ${contextFileName}`));
+  const serverHelperContent = `// Auto-generated file. For server-side use only.
+
+import { createServerApi } from 'api-core-lib/server';
+import { serverApiClient } from '@/lib/api-core/serverApi';
+import { ${module2.moduleName} } from './config';
+
+export const create${moduleBaseName}ServerApi = () => {
+  return createServerApi(serverApiClient, ${module2.moduleName});
+};`;
+  import_fs.default.writeFileSync(import_path.default.join(moduleOutputPath, `${camelCaseModuleName}.server.ts`), serverHelperContent.trim());
+  console.log(import_chalk.default.gray(`    \u2713 ${camelCaseModuleName}.server.ts`));
+  const clientExports = `
+export * from './${camelCaseModuleName}.endpoints';
+export * from './${camelCaseModuleName}.context';`;
+  import_fs.default.appendFileSync(indexFilePath, clientExports);
+  console.log(import_chalk.default.gray(`    \u2713 index.ts (Updated)`));
+  const serverEntryPointContent = `// Auto-generated file. For server-side use only.
+
+export * from './${camelCaseModuleName}.server';
+export * from './${camelCaseModuleName}.endpoints';`;
+  import_fs.default.writeFileSync(import_path.default.join(moduleOutputPath, "server.ts"), serverEntryPointContent);
+  console.log(import_chalk.default.gray(`    \u2713 server.ts (Server Entry Point)`));
+}
+async function runGenerator(options) {
+  console.log(import_chalk.default.cyan.bold("\u{1F680} Starting API Development Platform Generator..."));
+  import_dotenv.default.config({ path: options.envPath });
+  const specUrl = process.env.OPENAPI_SPEC_URL || "./swagger.json";
+  const prompt = import_inquirer.default.default?.prompt || import_inquirer.default.prompt;
+  try {
+    console.log(import_chalk.default.blue(`
+\u23F3 Step 1: Dereferencing spec from ${specUrl}...`));
+    const spec = await import_swagger_parser.default.dereference(specUrl);
+    console.log(import_chalk.default.green("\u2713 Spec fully dereferenced."));
+    console.log(import_chalk.default.blue("\n\u23F3 Step 2: Parsing spec with intelligent grouping..."));
+    const { modules, allSchemas, allEnums } = parseSpecToModules(spec);
+    const newModuleNames = Array.from(modules.keys());
+    console.log(import_chalk.default.green(`\u2713 Found and grouped ${modules.size} logical modules from the spec.`));
+    const outputDir = options.output;
+    if (import_fs.default.existsSync(outputDir)) {
+      console.log(import_chalk.default.yellow.bold(`
+\u26A0\uFE0F  An existing generation has been found at: ${outputDir}`));
+      const { action } = await prompt([{
+        type: "list",
+        name: "action",
+        message: "What would you like to do?",
+        choices: [
+          { name: "Perform a Selective Update (Recommended)", value: "selective" },
+          { name: "Full Refresh (Deletes everything and regenerates)", value: "full" },
+          { name: "Cancel", value: "cancel" }
+        ]
+      }]);
+      if (action === "cancel") {
+        console.log(import_chalk.default.gray("Operation cancelled."));
+        return;
+      }
+      if (action === "full") {
+        const { confirm } = await prompt([{
+          type: "confirm",
+          name: "confirm",
+          message: import_chalk.default.red.bold("Are you sure? This will permanently delete all files in the output directory."),
+          default: false
+        }]);
+        if (!confirm) {
+          console.log(import_chalk.default.gray("Full refresh cancelled."));
+          return;
+        }
+        console.log(import_chalk.default.yellow(`\u{1F525} Deleting existing directory...`));
+        import_fs.default.rmSync(outputDir, { recursive: true, force: true });
+      } else if (action === "selective") {
+        const existingModuleDirs = import_fs.default.readdirSync(outputDir, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
+        const newModules = newModuleNames.filter((name) => !existingModuleDirs.includes(name));
+        const existingModulesToUpdate = newModuleNames.filter((name) => existingModuleDirs.includes(name));
+        const obsoleteModules = existingModuleDirs.filter((name) => !newModuleNames.includes(name));
+        console.log(import_chalk.default.blue("\n--- Analysis Complete ---"));
+        if (newModules.length > 0) console.log(import_chalk.default.green(`  + Found ${newModules.length} new module(s): ${newModules.join(", ")}`));
+        if (obsoleteModules.length > 0) console.log(import_chalk.default.yellow(`  - Found ${obsoleteModules.length} obsolete module(s) (will not be touched): ${obsoleteModules.join(", ")}`));
+        console.log(import_chalk.default.cyan(`  ~ Found ${existingModulesToUpdate.length} existing module(s) available for update.`));
+        console.log("-------------------------\n");
+        if (newModuleNames.length === 0) {
+          console.log(import_chalk.default.yellow("No modules found in the spec to update. Exiting."));
+          return;
+        }
+        const { modulesToRegenerate } = await prompt([{
+          type: "checkbox",
+          name: "modulesToRegenerate",
+          message: "Select the modules to generate or update:",
+          choices: [
+            ...newModules.map((name) => ({ name: `${name} (New)`, value: name, checked: true })),
+            ...existingModulesToUpdate.map((name) => ({ name, value: name, checked: false }))
+          ]
+        }]);
+        if (!modulesToRegenerate || modulesToRegenerate.length === 0) {
+          console.log(import_chalk.default.gray("No modules selected. Operation cancelled."));
+          return;
+        }
+        console.log(import_chalk.default.blue("\n\u23F3 Step 3: Generating selected module files..."));
+        for (const moduleName of modulesToRegenerate) {
+          const moduleData = modules.get(moduleName);
+          if (moduleData) await generateModuleFiles(moduleData, allSchemas, allEnums, outputDir);
+        }
+        console.log(import_chalk.default.green("\n\u2713 Selective update complete."));
+        console.log(import_chalk.default.bold.green("\n\u{1F389} Your development platform is synchronized!"));
+        return;
+      }
+    }
+    console.log(import_chalk.default.blue("\n\u23F3 Step 3: Performing a full generation..."));
+    for (const module2 of modules.values()) {
+      await generateModuleFiles(module2, allSchemas, allEnums, options.output);
+    }
+    console.log(import_chalk.default.green("\n\u2713 All module files generated successfully."));
+    console.log(import_chalk.default.bold.green("\n\u{1F389} API generation complete! Your development platform is ready."));
+    console.log(import_chalk.default.bold.cyan(`   Output directory: ${options.output}`));
+  } catch (error) {
+    console.error(import_chalk.default.red.bold("\n\u274C An error occurred during generation:"));
+    console.error(import_chalk.default.red(`Error Message: ${error.message}`));
+    if (error.stack && DEBUG_MODE) console.error(import_chalk.default.gray(error.stack));
+    process.exit(1);
+  }
+}
+
+// src/cli.ts
+console.log("API Core Lib - Code Generator");
+import_commander.program.option("-o, --output <path>", "Output directory for generated files", "src/lib/api-generated").option("--env-path <path>", ".env file path", import_path2.default.resolve(process.cwd(), ".env")).action((options) => {
+  const absoluteOutputPath = import_path2.default.resolve(process.cwd(), options.output);
+  runGenerator({ ...options, output: absoluteOutputPath });
+});
+import_commander.program.parse(process.argv);