api-core-lib 12.12.102 → 12.12.104

package/dist/cli.cjs

@@ -74,7 +74,7 @@ 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 inquirer = __toESM(require("inquirer"), 1);
+var import_inquirer = __toESM(require("inquirer"), 1);
 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 }));
@@ -88,19 +88,93 @@ function findCommonPath(paths) {
   const first = sortedPaths[0].split("/");
   const last = sortedPaths[sortedPaths.length - 1].split("/");
   let i = 0;
-  while (i < first.length && first[i] === last[i]) {
-    i++;
-  }
+  while (i < first.length && first[i] === last[i]) i++;
   return first.slice(0, i).join("/") || "/";
 }
+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")})`;
+      }
+      break;
+    case "integer":
+    case "number":
+      zodChain = prop.type === "integer" ? `z.number().int(${getMsg("number.integer")})` : "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;
+}
+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;
+  }
+}
 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;
-      let generatedEnumName;
+      let itemSchema, generatedEnumName;
       if (propSchema.type === "array" && propSchema.items) {
         const itemTypeName = `${toPascalCase(name)}${toPascalCase(propName)}Item`;
         itemSchema = parseSchema(itemTypeName, propSchema.items, allEnums).properties[0];
@@ -113,55 +187,25 @@ function parseSchema(name, schema, allEnums) {
         }
         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}${toPascalCase(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
-      });
+      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}${toPascalCase(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();
-  const allSchemas = /* @__PURE__ */ new Map();
-  const allEnums = /* @__PURE__ */ new Map();
-  const modulePaths = /* @__PURE__ */ new Map();
+  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;
-      const itemBaseName = `${baseName}Item`;
-      if (itemSchema.properties || itemSchema.type === "object") {
-        return `${registerSchema(itemSchema, itemBaseName)}[]`;
-      }
-      const primitiveType = itemSchema.type === "integer" ? "number" : itemSchema.type || "any";
-      return `${primitiveType}[]`;
+      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>";
-      }
+      if (!schema.properties && !schema.allOf) return "Record<string, any>";
       const typeName = toPascalCase(baseName.replace(/_v\d+(Request|Response)$/, "$1"));
-      if (!allSchemas.has(typeName)) {
-        allSchemas.set(typeName, parseSchema(typeName, schema, allEnums));
-      }
+      if (!allSchemas.has(typeName)) allSchemas.set(typeName, parseSchema(typeName, schema, allEnums));
       return typeName;
     }
     return schema.type === "integer" ? "number" : schema.type || "any";
@@ -173,8 +217,7 @@ function parseSpecToModules(spec) {
       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 tagName = endpoint.tags[0];
-      const moduleName = sanitizeForModuleName(tagName);
+      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, []);
@@ -186,11 +229,8 @@ function parseSpecToModules(spec) {
       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";
-      }
+      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)) {
@@ -199,20 +239,7 @@ function parseSpecToModules(spec) {
           if (schemaDef) Object.keys(schemaDef.enums).forEach((propName) => currentModule.enums.add(`${toPascalCase(cleanType)}${toPascalCase(propName)}Enum`));
         }
       });
-      const actionName = getActionName(endpoint.operationId);
-      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
-      };
+      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) => {
@@ -227,12 +254,236 @@ 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)}`));
-  console.log(import_chalk.default.gray(`    \u2713 (Simulated) Generated files for ${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 = toCamelCase(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 runGeneratorV1(options) {
-  console.log(import_chalk.default.cyan.bold("\u{1F680} Starting API Development Platform Generator (Godfather Interactive Edition)..."));
+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}...`));
@@ -246,7 +497,7 @@ async function runGeneratorV1(options) {
     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 inquirer.prompt([{
+      const { action } = await prompt([{
         type: "list",
         name: "action",
         message: "What would you like to do?",
@@ -261,7 +512,7 @@ async function runGeneratorV1(options) {
         return;
       }
       if (action === "full") {
-        const { confirm } = await inquirer.prompt([{
+        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."),
@@ -287,7 +538,7 @@ async function runGeneratorV1(options) {
           console.log(import_chalk.default.yellow("No modules found in the spec to update. Exiting."));
           return;
         }
-        const { modulesToRegenerate } = await inquirer.prompt([{
+        const { modulesToRegenerate } = await prompt([{
           type: "checkbox",
           name: "modulesToRegenerate",
           message: "Select the modules to generate or update:",
@@ -296,7 +547,7 @@ async function runGeneratorV1(options) {
             ...existingModulesToUpdate.map((name) => ({ name, value: name, checked: false }))
           ]
         }]);
-        if (modulesToRegenerate.length === 0) {
+        if (!modulesToRegenerate || modulesToRegenerate.length === 0) {
           console.log(import_chalk.default.gray("No modules selected. Operation cancelled."));
           return;
         }
@@ -329,6 +580,6 @@ async function runGeneratorV1(options) {
 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);
-  runGeneratorV1({ ...options, output: absoluteOutputPath });
+  runGenerator({ ...options, output: absoluteOutputPath });
 });
 import_commander.program.parse(process.argv);

package/package.json

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