@igniter-js/cli 0.4.92 → 0.4.95

package/dist/index.mjs

@@ -7,7 +7,7 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
 });
 
 // src/index.ts
-import { Command as Command9 } from "commander";
+import { Command as Command10 } from "commander";
 
 // src/commands/init/index.ts
 import { Command } from "commander";
@@ -123,11 +123,11 @@ function registerHandlebarsHelpers() {
   handlebars.registerHelper("capitalizeSlug", function(slug) {
     return slug.replace(/-/g, " ").replace(/\b\w/g, (char) => char.toUpperCase());
   });
-  handlebars.registerHelper("get", function(obj, path24) {
-    if (!path24 || typeof path24 !== "string") {
+  handlebars.registerHelper("get", function(obj, path25) {
+    if (!path25 || typeof path25 !== "string") {
       return void 0;
     }
-    const pathArray = path24.split(".");
+    const pathArray = path25.split(".");
     let current = obj;
     for (let i = 0; i < pathArray.length; i++) {
       if (current === null || current === void 0) {
@@ -148,7 +148,7 @@ function registerHandlebarsHelpers() {
   });
   handlebars.registerHelper("filterPlugins", function(plugins = []) {
     if (!Array.isArray(plugins)) return [];
-    return plugins.filter((p13) => p13 !== "next-cookies");
+    return plugins.filter((p14) => p14 !== "next-cookies");
   });
   handlebars.registerHelper(
     "generatePluginImports",
@@ -162,7 +162,7 @@ function registerHandlebarsHelpers() {
         if (str === "open-api") return "openAPI";
         return str.replace(/-([a-z])/g, (g) => g[1].toUpperCase());
       };
-      const regularPlugins = plugins.filter((p13) => p13 !== "next-cookies").map(camelCase);
+      const regularPlugins = plugins.filter((p14) => p14 !== "next-cookies").map(camelCase);
       const hasNextCookies = plugins.includes("next-cookies");
       const importStatements = [];
       if (regularPlugins.length > 0) {
@@ -334,9 +334,9 @@ var BaseStarter = class {
         }
         const outputPath = join2(projectDir, template.outputPath);
         const outputDir = join2(outputPath, "..");
-        await import("fs").then((fs8) => {
-          if (!fs8.existsSync(outputDir)) {
-            fs8.mkdirSync(outputDir, { recursive: true });
+        await import("fs").then((fs9) => {
+          if (!fs9.existsSync(outputDir)) {
+            fs9.mkdirSync(outputDir, { recursive: true });
           }
         });
         await writeFile(outputPath, renderedContent);
@@ -971,9 +971,9 @@ var BaseAddOn = class {
         }
         const outputPath = join3(projectDir, template.outputPath);
         const outputDir = join3(outputPath, "..");
-        await import("fs").then((fs8) => {
-          if (!fs8.existsSync(outputDir)) {
-            fs8.mkdirSync(outputDir, { recursive: true });
+        await import("fs").then((fs9) => {
+          if (!fs9.existsSync(outputDir)) {
+            fs9.mkdirSync(outputDir, { recursive: true });
           }
         });
         await writeFile2(outputPath, renderedContent);
@@ -1838,9 +1838,9 @@ var addOnRegistry = AddOnRegistry.create().register(new RedisStoreAddOn()).regis
 
 // src/core/file-system.ts
 import * as fs2 from "fs/promises";
-async function isPathEmpty(path24) {
+async function isPathEmpty(path25) {
   try {
-    const files = await fs2.readdir(path24);
+    const files = await fs2.readdir(path25);
     return files.length === 0;
   } catch (error) {
     if (error.code === "ENOENT") {
@@ -2173,14 +2173,14 @@ var ProjectGenerator = class {
       dockerSetup.message(
         `Checking and stopping currently running containers...`
       );
-      const fs8 = await import("fs/promises");
-      const path24 = await import("path");
-      const yaml = await import("js-yaml");
-      const composeFilePath = path24.join(this.targetDir, "docker-compose.yml");
+      const fs9 = await import("fs/promises");
+      const path25 = await import("path");
+      const yaml2 = await import("js-yaml");
+      const composeFilePath = path25.join(this.targetDir, "docker-compose.yml");
       let ports = [];
       try {
-        const composeContent = await fs8.readFile(composeFilePath, "utf8");
-        const doc = yaml.load(composeContent);
+        const composeContent = await fs9.readFile(composeFilePath, "utf8");
+        const doc = yaml2.load(composeContent);
         const services = doc?.services || {};
         for (const svcKey of Object.keys(services)) {
           const service = services[svcKey];
@@ -2287,7 +2287,7 @@ var initCommand = new Command().command("init").description("Create a new Ignite
 ).option("--no-git", "Skip git repository initialization").option("--no-install", "Skip automatic dependency installation").option("--no-docker", "Skip Docker Compose setup").action(handleInitAction);
 
 // src/commands/generate/index.ts
-import { Command as Command7 } from "commander";
+import { Command as Command8 } from "commander";
 
 // src/commands/generate/feature/index.ts
 import { Command as Command2 } from "commander";
@@ -2900,8 +2900,8 @@ async function handleGenerateFeatureAction(name, options) {
     p7.outro("Nothing to do.");
     process.exit(1);
   }
-  const spinner7 = p7.spinner();
-  spinner7.start(`Scaffolding feature '${featureSlug}'...`);
+  const spinner8 = p7.spinner();
+  spinner8.start(`Scaffolding feature '${featureSlug}'...`);
   try {
     if (provider && selection) {
       await FeatureWorkspace.ensureStructure(featureDir);
@@ -2914,13 +2914,13 @@ async function handleGenerateFeatureAction(name, options) {
       await FeatureWorkspace.ensureStructure(featureDir);
       await generateEmptyFeature(featureSlug, featureDir, templateEngine);
     }
-    spinner7.stop(`Feature '${featureSlug}' created successfully!`);
+    spinner8.stop(`Feature '${featureSlug}' created successfully!`);
     p7.log.success(
       `Scaffolded feature '${featureSlug}'. Remember to register the controller in your router.`
     );
     p7.outro("Feature generation complete!");
   } catch (error) {
-    spinner7.stop("Failed to scaffold the feature.");
+    spinner8.stop("Failed to scaffold the feature.");
     const message = error instanceof Error ? error.message : String(error);
     p7.log.error(`Feature generation failed: ${message}`);
     process.exit(1);
@@ -2929,7 +2929,7 @@ async function handleGenerateFeatureAction(name, options) {
 async function resolveSchemaProvider({
   registry,
   options,
-  cancel: cancel4
+  cancel: cancel5
 }) {
   if (options.schema) {
     const provider2 = registry.findBySchemaOption(options.schema);
@@ -2962,7 +2962,7 @@ async function resolveSchemaProvider({
     initialValue: "none"
   });
   if (p7.isCancel(choice)) {
-    cancel4("Feature generation cancelled.");
+    cancel5("Feature generation cancelled.");
   }
   if (choice === "none") {
     return { provider: null, selection: null };
@@ -3063,13 +3063,13 @@ var OpenAPIGenerator = class _OpenAPIGenerator {
     for (const [controllerKey, controller] of Object.entries(router.controllers)) {
       for (const [actionKey, action] of Object.entries(controller.actions)) {
         const actionName = action.name || actionKey;
-        let path24 = `/${controller.path}/${action.path}`;
-        path24 = path24.replace(/\/{2,}/g, "/");
-        if (path24.length > 1 && path24.endsWith("/")) {
-          path24 = path24.slice(0, -1);
+        let path25 = `/${controller.path}/${action.path}`;
+        path25 = path25.replace(/\/{2,}/g, "/");
+        if (path25.length > 1 && path25.endsWith("/")) {
+          path25 = path25.slice(0, -1);
         }
-        if (!paths[path24]) {
-          paths[path24] = {};
+        if (!paths[path25]) {
+          paths[path25] = {};
         }
         const operation = {
           summary: action.description || actionName,
@@ -3131,7 +3131,7 @@ var OpenAPIGenerator = class _OpenAPIGenerator {
         if (action.isStream) {
           operation.description = (operation.description ? operation.description + "\n\n" : "") + "This endpoint supports Server-Sent Events (SSE) for real-time updates. It functions as a standard GET request initially, then maintains an open connection for streaming data.";
         }
-        paths[path24][action.method.toLowerCase()] = operation;
+        paths[path25][action.method.toLowerCase()] = operation;
       }
     }
     return paths;
@@ -3307,10 +3307,10 @@ async function generateDocsWatchMode(routerPath, outputDir) {
 async function handleGenerateDocsAction(options) {
   try {
     p9.intro("Generate OpenAPI documentation");
-    const spinner7 = p9.spinner();
-    spinner7.start("Generating OpenAPI documentation...");
+    const spinner8 = p9.spinner();
+    spinner8.start("Generating OpenAPI documentation...");
     const result = await generateDocsWatchMode(options.router, options.output);
-    spinner7.stop("OpenAPI documentation generated successfully.");
+    spinner8.stop("OpenAPI documentation generated successfully.");
     p9.log.success(
       `Docs generated in ${(result.durationMs / 1e3).toFixed(2)}s (${result.sizeKb.toFixed(1)} KB)`
     );
@@ -3354,10 +3354,10 @@ async function generateSchemaWatchMode(routerPath, outputPath) {
 async function handleGenerateSchemaAction({ router: routerPath, output: outputPath }) {
   try {
     p10.intro("Generate Igniter.js Client Schema");
-    const spinner7 = p10.spinner();
-    spinner7.start("Generating schema...");
+    const spinner8 = p10.spinner();
+    spinner8.start("Generating schema...");
     const result = await generateSchemaWatchMode(routerPath, outputPath);
-    spinner7.stop("Schema generated successfully.");
+    spinner8.stop("Schema generated successfully.");
     p10.log.success(
       `Schema generated in ${(result.durationMs / 1e3).toFixed(2)}s (${result.controllers} controllers, ${result.actions} actions).`
     );
@@ -3432,8 +3432,8 @@ async function handleGenerateControllerAction(name, options) {
     "feature",
     "empty.controller.hbs"
   );
-  const spinner7 = p11.spinner();
-  spinner7.start(
+  const spinner8 = p11.spinner();
+  spinner8.start(
     `Creating controller '${controllerSlug}' inside feature '${featureSlug}'...`
   );
   try {
@@ -3446,13 +3446,13 @@ async function handleGenerateControllerAction(name, options) {
       },
       controllerPath
     );
-    spinner7.stop("Controller created successfully!");
+    spinner8.stop("Controller created successfully!");
     p11.log.success(
       `Created controller '${controllerSlug}' in feature '${featureSlug}'.`
     );
     p11.outro("Controller generation complete!");
   } catch (error) {
-    spinner7.stop("Failed to create the controller.");
+    spinner8.stop("Failed to create the controller.");
     const message = error instanceof Error ? error.message : String(error);
     p11.log.error(`Controller generation failed: ${message}`);
     process.exit(1);
@@ -3510,8 +3510,8 @@ async function handleGenerateProcedureAction(name, options) {
     "feature",
     "procedure.hbs"
   );
-  const spinner7 = p12.spinner();
-  spinner7.start(
+  const spinner8 = p12.spinner();
+  spinner8.start(
     `Creating procedure '${procedureSlug}' inside feature '${featureSlug}'...`
   );
   if (await FeatureWorkspace.fileExists(path22.join(featureDir, "procedures", ".gitkeep"))) {
@@ -3527,13 +3527,13 @@ async function handleGenerateProcedureAction(name, options) {
       },
       procedurePath
     );
-    spinner7.stop("Procedure created successfully!");
+    spinner8.stop("Procedure created successfully!");
     p12.log.success(
       `Created procedure '${procedureSlug}' in feature '${featureSlug}'.`
     );
     p12.outro("Procedure generation complete!");
   } catch (error) {
-    spinner7.stop("Failed to create the procedure.");
+    spinner8.stop("Failed to create the procedure.");
     const message = error instanceof Error ? error.message : String(error);
     p12.log.error(`Procedure generation failed: ${message}`);
     process.exit(1);
@@ -3543,15 +3543,699 @@ async function handleGenerateProcedureAction(name, options) {
 // src/commands/generate/procedure/index.ts
 var procedureCommand = new Command6().command("procedure").description("Scaffold a new procedure within a feature").argument("[name]", "Name of the procedure (e.g., 'profile')").option("-f, --feature <feature>", "Target feature name").action(handleGenerateProcedureAction);
 
+// src/commands/generate/caller/index.ts
+import { Command as Command7 } from "commander";
+
+// src/commands/generate/caller/action.ts
+import { promises as fs7 } from "fs";
+import path23 from "path";
+import * as p13 from "@clack/prompts";
+import yaml from "js-yaml";
+import SwaggerParser from "@apidevtools/swagger-parser";
+var SUPPORTED_METHODS = ["get", "post", "put", "patch", "delete", "head"];
+async function handleGenerateCallerAction(options) {
+  p13.intro("Generate Igniter Caller");
+  try {
+    const callerName = await resolveCallerName(options.name);
+    const source = await resolveSource(options);
+    const spinner8 = p13.spinner();
+    spinner8.start("Loading OpenAPI spec...");
+    const parsedDoc = await loadOpenApiDocument(source);
+    const host = deriveHostname(source, parsedDoc) || "api";
+    const outputDir = path23.resolve(
+      process.cwd(),
+      options.output ?? path23.join("src", "callers", host)
+    );
+    const prefix = Casing.toPascalCase(callerName);
+    const converter = new SchemaConverter(prefix, parsedDoc.components);
+    const componentsCode = converter.renderComponentSchemas();
+    const schemaConstName = `${Casing.toCamelCase(callerName)}CallerSchemas`;
+    const schemaTypeName = `${prefix}CallerSchemas`;
+    const { builderCode, typeAliases } = buildSchemaBuilder(
+      parsedDoc,
+      converter,
+      schemaConstName
+    );
+    const schemaFileContents = [
+      "/* eslint-disable */",
+      "/* prettier-ignore */",
+      "/**",
+      " * @generated by @igniter-js/cli",
+      " * This file was automatically created from your OpenAPI spec.",
+      " * Do not edit manually; regenerate via `igniter generate caller`.",
+      " */",
+      'import { z } from "zod";',
+      'import { IgniterCallerSchema } from "@igniter-js/caller";',
+      componentsCode,
+      builderCode,
+      `export type ${schemaTypeName} = typeof ${schemaConstName};`,
+      typeAliases,
+      ""
+    ].filter(Boolean).join("\n");
+    const baseUrl = inferBaseUrl(source, parsedDoc);
+    const callerVar = `${Casing.toCamelCase(callerName)}Caller`;
+    const callerFileContents = [
+      "/**",
+      ` * Preconfigured IgniterCaller for ${prefix}.`,
+      " * Regenerate via `igniter generate caller` when the OpenAPI spec changes.",
+      " */",
+      'import { IgniterCaller } from "@igniter-js/caller";',
+      `import { ${schemaConstName} } from "./schema";`,
+      "",
+      "export const " + callerVar + " = IgniterCaller.create()",
+      baseUrl ? `  .withBaseUrl("${baseUrl}")` : "",
+      "  .withSchemas(" + schemaConstName + ', { mode: "strict" })',
+      "  .build();",
+      ""
+    ].filter(Boolean).join("\n");
+    await fs7.mkdir(outputDir, { recursive: true });
+    await fs7.writeFile(path23.join(outputDir, "schema.ts"), schemaFileContents, "utf8");
+    await fs7.writeFile(path23.join(outputDir, "index.ts"), callerFileContents, "utf8");
+    spinner8.stop("Caller generated successfully.");
+    p13.log.success(
+      `Schemas and caller created at ${path23.relative(process.cwd(), outputDir)}`
+    );
+    p13.log.info(`Exported caller: ${callerVar} (schemas: ${schemaConstName})`);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    p13.log.error(message);
+    process.exit(1);
+  }
+}
+async function resolveCallerName(name) {
+  if (name) {
+    return name.trim();
+  }
+  const answer = await p13.text({
+    message: "Caller name (e.g., facebook, billing)",
+    validate: (value) => value && value.trim().length > 0 ? void 0 : "Name is required"
+  });
+  if (p13.isCancel(answer)) {
+    p13.cancel("Caller generation cancelled.");
+    process.exit(0);
+  }
+  return String(answer);
+}
+async function resolveSource(options) {
+  if (options.url && options.path) {
+    throw new Error("Use either --url or --path, not both.");
+  }
+  if (options.url) {
+    return { type: "url", url: options.url };
+  }
+  if (options.path) {
+    return { type: "path", path: options.path };
+  }
+  const sourceChoice = await p13.select({
+    message: "Where is your OpenAPI spec?",
+    options: [
+      { label: "Remote URL", value: "url" },
+      { label: "Local file path", value: "path" }
+    ],
+    initialValue: "url"
+  });
+  if (p13.isCancel(sourceChoice)) {
+    p13.cancel("Caller generation cancelled.");
+    process.exit(0);
+  }
+  if (sourceChoice === "url") {
+    const url = await p13.text({
+      message: "OpenAPI URL",
+      placeholder: "https://api.example.com/openapi.json",
+      validate: (value) => !value ? "URL is required" : void 0
+    });
+    if (p13.isCancel(url)) {
+      p13.cancel("Caller generation cancelled.");
+      process.exit(0);
+    }
+    return { type: "url", url: String(url) };
+  }
+  const filePath = await p13.text({
+    message: "Path to OpenAPI file",
+    placeholder: "./openapi.json",
+    validate: (value) => !value ? "Path is required" : void 0
+  });
+  if (p13.isCancel(filePath)) {
+    p13.cancel("Caller generation cancelled.");
+    process.exit(0);
+  }
+  return { type: "path", path: String(filePath) };
+}
+async function loadOpenApiDocument(source) {
+  const raw = await loadRawContent(source);
+  const parsed = parseOpenApi(raw);
+  const version = parsed.openapi ?? "";
+  if (typeof version !== "string" || !version.startsWith("3.")) {
+    throw new Error("Only OpenAPI 3.x documents are supported.");
+  }
+  const bundled = await SwaggerParser.bundle(parsed);
+  return bundled;
+}
+async function loadRawContent(source) {
+  if (source.type === "url") {
+    const response = await fetch(source.url);
+    if (!response.ok) {
+      throw new Error(
+        `Failed to fetch OpenAPI document: ${response.status} ${response.statusText}`
+      );
+    }
+    return await response.text();
+  }
+  const filePath = path23.resolve(process.cwd(), source.path);
+  return await fs7.readFile(filePath, "utf8");
+}
+function parseOpenApi(content) {
+  try {
+    return JSON.parse(content);
+  } catch {
+    const parsed = yaml.load(content);
+    if (!parsed || typeof parsed !== "object") {
+      throw new Error("Could not parse OpenAPI document (JSON/YAML).");
+    }
+    return parsed;
+  }
+}
+function deriveHostname(source, doc) {
+  if (source.type === "url") {
+    try {
+      const url = new URL(source.url);
+      return url.hostname.replace(/[^a-zA-Z0-9.-]/g, "") || null;
+    } catch {
+      return null;
+    }
+  }
+  const serverUrl = doc.servers?.[0]?.url;
+  if (serverUrl) {
+    try {
+      const url = new URL(serverUrl);
+      return url.hostname.replace(/[^a-zA-Z0-9.-]/g, "") || null;
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+function inferBaseUrl(source, doc) {
+  if (source.type === "url") {
+    const serverUrl2 = doc.servers?.[0]?.url;
+    if (serverUrl2) {
+      return serverUrl2;
+    }
+    return new URL(source.url).origin;
+  }
+  const serverUrl = doc.servers?.[0]?.url;
+  return serverUrl ?? null;
+}
+var SchemaConverter = class {
+  constructor(prefix, components) {
+    this.generated = /* @__PURE__ */ new Map();
+    this.inProgress = /* @__PURE__ */ new Set();
+    this.prefix = prefix;
+    this.components = components;
+  }
+  renderComponentSchemas() {
+    const entries = [];
+    const names = this.listComponents();
+    for (const name of names) {
+      const identifier = this.componentIdentifier(name);
+      const expression = this.convertWithCache(name);
+      const registryKey = this.registryKey(name);
+      entries.push(
+        [
+          "/**",
+          ` * Schema: ${registryKey}`,
+          ` * Source: openapi#/components/schemas/${name}`,
+          " */",
+          `const ${identifier} = ${expression};`,
+          ""
+        ].join("\n")
+      );
+    }
+    return entries.length ? `${entries.join("\n")}
+` : "";
+  }
+  listComponents() {
+    return Object.keys(this.components?.schemas ?? {}).sort();
+  }
+  registryKey(name) {
+    return Casing.toPascalCase(name);
+  }
+  componentName(name) {
+    return this.componentIdentifier(name);
+  }
+  convert(schema) {
+    if ("$ref" in schema) {
+      const refName = this.refName(schema.$ref);
+      const identifier = this.componentIdentifier(refName);
+      this.convertWithCache(refName);
+      return this.wrapLazyIfNeeded(refName, identifier);
+    }
+    const schemaType = Array.isArray(schema.type) ? schema.type[0] : schema.type;
+    const nullable = isNullable(schema);
+    if (schema.oneOf?.length) {
+      const parts = schema.oneOf.map((item) => this.convert(item));
+      return wrapNullable(`z.union([${parts.join(", ")}])`, nullable);
+    }
+    if (schema.anyOf?.length) {
+      const parts = schema.anyOf.map((item) => this.convert(item));
+      return wrapNullable(`z.union([${parts.join(", ")}])`, nullable);
+    }
+    if (schema.allOf?.length) {
+      const [first, ...rest] = schema.allOf;
+      let expr = this.convert(first);
+      for (const part of rest) {
+        expr = `z.intersection(${expr}, ${this.convert(part)})`;
+      }
+      return wrapNullable(expr, nullable);
+    }
+    switch (schemaType) {
+      case "string":
+        if (schema.enum) {
+          const values = schema.enum.map((v) => JSON.stringify(String(v)));
+          return wrapNullable(`z.enum([${values.join(", ")}])`, nullable);
+        }
+        return wrapNullable("z.string()", nullable);
+      case "number":
+      case "integer": {
+        let expr = "z.number()";
+        if (schemaType === "integer") {
+          expr = `${expr}.int()`;
+        }
+        return wrapNullable(expr, nullable);
+      }
+      case "boolean":
+        return wrapNullable("z.boolean()", nullable);
+      case "array": {
+        const arraySchema = schema;
+        const items = arraySchema.items ? this.convert(arraySchema.items) : "z.unknown()";
+        return wrapNullable(`z.array(${items})`, nullable);
+      }
+      case "object": {
+        const properties = schema.properties ?? {};
+        const required = new Set(schema.required ?? []);
+        const entries = Object.entries(properties).map(([key, value]) => {
+          const valueExpr = this.convert(value);
+          return `${JSON.stringify(key)}: ${required.has(key) ? valueExpr : `${valueExpr}.optional()`}`;
+        });
+        let base = `z.object({${entries.length ? ` ${entries.join(", ")} ` : ""}})`;
+        if (schema.additionalProperties) {
+          const apValue = schema.additionalProperties === true ? "z.unknown()" : this.convert(schema.additionalProperties);
+          base = `${base}.catchall(${apValue})`;
+        }
+        return wrapNullable(base, nullable);
+      }
+      default:
+        return "z.unknown()";
+    }
+  }
+  convertWithCache(name) {
+    const identifier = this.componentIdentifier(name);
+    if (this.generated.has(name)) {
+      return this.generated.get(name);
+    }
+    if (this.inProgress.has(name)) {
+      return `z.lazy(() => ${identifier})`;
+    }
+    const schema = this.components?.schemas?.[name];
+    if (!schema) {
+      return "z.unknown()";
+    }
+    this.inProgress.add(name);
+    const expression = this.convert(schema);
+    this.inProgress.delete(name);
+    this.generated.set(name, expression);
+    return expression;
+  }
+  componentIdentifier(name) {
+    return `${this.prefix}${Casing.toPascalCase(name)}Schema`;
+  }
+  refName(ref) {
+    const [, component] = ref.split("#/components/schemas/");
+    if (!component) {
+      return "UnknownSchema";
+    }
+    return component;
+  }
+  wrapLazyIfNeeded(name, identifier) {
+    if (this.inProgress.has(name)) {
+      return `z.lazy(() => ${identifier})`;
+    }
+    return identifier;
+  }
+};
+function buildSchemaBuilder(doc, converter, schemaConstName) {
+  const usedNames = /* @__PURE__ */ new Map();
+  const operations = [];
+  const pathBlocks = [];
+  let needsVoid = false;
+  const sortedPaths = Object.keys(doc.paths || {}).sort();
+  for (const rawPath of sortedPaths) {
+    const pathItem = doc.paths?.[rawPath];
+    if (!pathItem) continue;
+    const methodBlocks = [];
+    for (const method of SUPPORTED_METHODS) {
+      const operation = pathItem[method];
+      if (!operation) continue;
+      const normalizedPath2 = normalizePath(rawPath);
+      const requestBody = buildRequestBody(
+        operation.requestBody,
+        converter,
+        doc
+      );
+      const responses = buildResponses(operation.responses, converter, doc);
+      const typeBaseName = ensureUniqueTypeName(
+        buildOperationTypeName(rawPath, method, operation.operationId),
+        usedNames
+      );
+      operations.push({
+        path: normalizedPath2,
+        method: method.toUpperCase(),
+        request: Boolean(requestBody),
+        responses: responses.entries,
+        typeName: typeBaseName
+      });
+      const docBlock = buildMethodDocBlock({
+        method: method.toUpperCase(),
+        path: normalizedPath2,
+        summary: operation.summary ?? operation.description,
+        tags: operation.tags,
+        operationId: operation.operationId,
+        requestLabel: requestBody?.label,
+        responses: responses.entries,
+        source: `openapi#/paths/${encodeJsonPointerPath(rawPath)}/${method}`
+      });
+      const methodCall = buildMethodCall(method, {
+        request: requestBody?.expression,
+        responses: responses.code,
+        doc: operation.summary ?? operation.description,
+        tags: operation.tags,
+        operationId: operation.operationId
+      });
+      methodBlocks.push(indent(`${docBlock}
+${methodCall}`, 3));
+      needsVoid = needsVoid || responses.usesVoid;
+    }
+    if (!methodBlocks.length) continue;
+    const normalizedPath = normalizePath(rawPath);
+    const pathLines = [
+      `  .path(${JSON.stringify(normalizedPath)}, (path) =>`,
+      "    path",
+      methodBlocks.join("\n"),
+      "  )"
+    ];
+    pathBlocks.push(pathLines.join("\n"));
+  }
+  const builderLines = [];
+  builderLines.push(`export const ${schemaConstName} = IgniterCallerSchema.create()`);
+  const componentNames = converter.listComponents();
+  for (const name of componentNames) {
+    const registryKey = converter.registryKey(name);
+    const identifier = converter.componentName(name);
+    builderLines.push(`  .schema(${JSON.stringify(registryKey)}, ${identifier})`);
+  }
+  if (needsVoid) {
+    builderLines.push(`  .schema("Void", z.void(), { internal: true })`);
+  }
+  if (pathBlocks.length) {
+    builderLines.push(pathBlocks.join("\n"));
+  }
+  builderLines.push("  .build()");
+  return {
+    builderCode: `${builderLines.join("\n")}
+`,
+    typeAliases: buildTypeAliases(operations, schemaConstName)
+  };
+}
+function buildMethodDocBlock(params) {
+  const lines = [];
+  lines.push("/**");
+  lines.push(` * ${params.method} ${params.path}`);
+  if (params.summary) {
+    lines.push(` * Summary: ${params.summary}`);
+  }
+  if (params.tags?.length) {
+    lines.push(` * Tags: ${params.tags.join(", ")}`);
+  }
+  if (params.operationId) {
+    lines.push(` * OperationId: ${params.operationId}`);
+  }
+  if (params.requestLabel) {
+    lines.push(` * Request: ${params.requestLabel}`);
+  }
+  if (params.responses.length) {
+    lines.push(" * Responses:");
+    for (const response of params.responses) {
+      lines.push(` *  - ${response.status}: ${response.label}`);
+    }
+  }
+  lines.push(` * Source: ${params.source}`);
+  lines.push(" */");
+  return lines.join("\n");
+}
+function buildMethodCall(method, params) {
+  const lines = [];
+  lines.push(`.${method}({`);
+  if (params.request) {
+    lines.push(`  request: ${params.request},`);
+  }
+  lines.push("  responses: {");
+  lines.push(params.responses);
+  lines.push("  },");
+  if (params.doc) {
+    lines.push(`  doc: ${JSON.stringify(params.doc)},`);
+  }
+  if (params.tags?.length) {
+    lines.push(`  tags: ${JSON.stringify(params.tags)},`);
+  }
+  if (params.operationId) {
+    lines.push(`  operationId: ${JSON.stringify(params.operationId)},`);
+  }
+  lines.push("})");
+  return lines.join("\n");
+}
+function buildResponses(responses, converter, doc) {
+  const builder = new CodeBuilder();
+  const entries = [];
+  let usesVoid = false;
+  if (!responses || !Object.keys(responses).length) {
+    const expression = `path.ref("Void").schema`;
+    builder.line(indent(`200: ${expression},`, 2));
+    entries.push({
+      status: "200",
+      statusLiteral: "200",
+      label: "Void"
+    });
+    return { code: builder.toString(), entries, usesVoid: true };
+  }
+  const sorted = Object.keys(responses).sort();
+  for (const status of sorted) {
+    const responseOrRef = responses[status];
+    if (!responseOrRef) continue;
+    const resolved = resolveResponse(responseOrRef, doc);
+    const schema = resolveSchemaFromResponse(resolved);
+    const resolvedSchema = resolveSchemaExpression(schema, converter);
+    builder.line(indent(`${formatStatusKey(status)}: ${resolvedSchema.expression},`, 2));
+    entries.push({
+      status: String(status),
+      statusLiteral: formatStatusType(status),
+      label: resolvedSchema.label
+    });
+    usesVoid = usesVoid || resolvedSchema.usesVoid;
+  }
+  return { code: builder.toString(), entries, usesVoid };
+}
+function buildRequestBody(requestBody, converter, doc) {
+  if (!requestBody) return null;
+  const resolved = "$ref" in requestBody ? resolveRequestBody(requestBody, doc) : requestBody;
+  if (!resolved?.content) return null;
+  const schema = selectJsonSchema(resolved.content);
+  if (!schema) return null;
+  return resolveSchemaExpression(schema, converter);
+}
+function resolveSchemaExpression(schema, converter) {
+  if (!schema) {
+    return {
+      expression: `path.ref("Void").schema`,
+      label: "Void",
+      usesVoid: true
+    };
+  }
+  const refName = extractSchemaRef(schema);
+  if (refName) {
+    const registryKey = converter.registryKey(refName);
+    const base = `path.ref(${JSON.stringify(registryKey)}).schema`;
+    return {
+      expression: wrapNullable(base, isNullable(schema)),
+      label: registryKey,
+      usesVoid: false
+    };
+  }
+  const arrayRefName = extractArraySchemaRef(schema);
+  if (arrayRefName) {
+    const registryKey = converter.registryKey(arrayRefName);
+    const base = `path.ref(${JSON.stringify(registryKey)}).array()`;
+    return {
+      expression: wrapNullable(base, isNullable(schema)),
+      label: `${registryKey}[]`,
+      usesVoid: false
+    };
+  }
+  return {
+    expression: converter.convert(schema),
+    label: "InlineSchema",
+    usesVoid: false
+  };
+}
+function buildTypeAliases(operations, schemaConstName) {
+  if (!operations.length) return "";
+  const lines = [];
+  lines.push("// Derived types");
+  for (const operation of operations) {
+    const pathLiteral = JSON.stringify(operation.path);
+    const methodLiteral = JSON.stringify(operation.method);
+    if (operation.request) {
+      lines.push(
+        `export type ${operation.typeName}Request = ReturnType<typeof ${schemaConstName}.$Infer.Request<${pathLiteral}, ${methodLiteral}>>;`
+      );
+    }
+    lines.push(
+      `export type ${operation.typeName}Responses = ReturnType<typeof ${schemaConstName}.$Infer.Responses<${pathLiteral}, ${methodLiteral}>>;`
+    );
+    for (const response of operation.responses) {
+      const suffix = formatStatusSuffix(response.status);
+      lines.push(
+        `export type ${operation.typeName}Response${suffix} = ReturnType<typeof ${schemaConstName}.$Infer.Response<${pathLiteral}, ${methodLiteral}, ${response.statusLiteral}>>;`
+      );
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function buildOperationTypeName(rawPath, method, operationId) {
+  if (operationId) {
+    return Casing.toPascalCase(operationId);
+  }
+  const normalizedPath = normalizePath(rawPath);
+  const segments = normalizedPath.split("/").filter(Boolean).map((segment) => segment.startsWith(":") ? `by-${segment.slice(1)}` : segment);
+  return Casing.toPascalCase([...segments, method].join("-"));
+}
+function ensureUniqueTypeName(baseName, used) {
+  const count = used.get(baseName) ?? 0;
+  if (count === 0) {
+    used.set(baseName, 1);
+    return baseName;
+  }
+  const next = `${baseName}${count + 1}`;
+  used.set(baseName, count + 1);
+  return next;
+}
+function encodeJsonPointerPath(pathname) {
+  return pathname.replace(/~/g, "~0").replace(/\//g, "~1");
+}
+function extractSchemaRef(schema) {
+  if (!schema || typeof schema !== "object") return null;
+  if (!("$ref" in schema)) return null;
+  return extractComponentSchemaName(schema.$ref);
+}
+function extractArraySchemaRef(schema) {
+  if (!schema || typeof schema !== "object") return null;
+  if (schema.type !== "array") return null;
+  const items = schema.items;
+  if (!items || typeof items !== "object") return null;
+  if (!("$ref" in items)) return null;
+  return extractComponentSchemaName(items.$ref);
+}
+function extractComponentSchemaName(ref) {
+  const match = ref.match(/^#\/components\/schemas\/(.+)$/);
+  return match ? match[1] : null;
+}
+function selectJsonSchema(content) {
+  if (content["application/json"]?.schema) {
+    return content["application/json"].schema;
+  }
+  const first = Object.values(content)[0];
+  return first?.schema;
+}
+function resolveSchemaFromResponse(response) {
+  if (!response?.content) {
+    return void 0;
+  }
+  return selectJsonSchema(response.content);
+}
+function normalizePath(pathname) {
+  return pathname.replace(/{(.*?)}/g, ":$1");
+}
+function indent(value, depth) {
+  const pad = "  ".repeat(depth);
+  return value.split("\n").map((line) => line ? pad + line : line).join("\n");
+}
+function isNullable(schema) {
+  if (!schema || typeof schema !== "object") return false;
+  return Boolean(schema.nullable);
+}
+function wrapNullable(expr, nullable) {
+  return nullable ? `${expr}.nullable()` : expr;
+}
+function formatStatusKey(status) {
+  const trimmed = String(status).trim();
+  const numeric = Number(trimmed);
+  if (!Number.isNaN(numeric) && `${numeric}` === trimmed) {
+    return trimmed;
+  }
+  return JSON.stringify(trimmed);
+}
+function formatStatusType(status) {
+  return formatStatusKey(status);
+}
+function formatStatusSuffix(status) {
+  const safe = String(status).replace(/[^a-zA-Z0-9]+/g, "-");
+  const pascal = Casing.toPascalCase(safe);
+  return pascal || "Unknown";
+}
+function resolveResponse(response, doc) {
+  if ("$ref" in response) {
+    return getComponent(doc, response.$ref, "responses");
+  }
+  return response;
+}
+function resolveRequestBody(requestBody, doc) {
+  return getComponent(doc, requestBody.$ref, "requestBodies");
+}
+function getComponent(doc, ref, type) {
+  const match = ref.match(/^#\/components\/([^/]+)\/(.+)$/);
+  if (!match) return void 0;
+  const [, category, name] = match;
+  if (category !== type) return void 0;
+  const component = doc.components?.[type]?.[name];
+  return component;
+}
+var CodeBuilder = class {
+  constructor() {
+    this.lines = [];
+  }
+  line(text4) {
+    this.lines.push(text4);
+  }
+  toString() {
+    return this.lines.join("\n");
+  }
+};
+
+// src/commands/generate/caller/index.ts
+var callerCommand = new Command7().command("caller").description("Generate Igniter Caller schemas from an OpenAPI spec").option("--name <name>", "Name used to prefix generated schemas and caller export").option("--url <url>", "URL to the OpenAPI document").option("--path <path>", "Local path to the OpenAPI document").option(
+  "--output <path>",
+  "Output directory (defaults to src/callers/<hostname>)"
+).action(handleGenerateCallerAction);
+
 // src/commands/generate/index.ts
-var generateCommand = new Command7().command("generate").description("Scaffold new features or generate client schema").addCommand(featureCommand).addCommand(controllerCommand).addCommand(procedureCommand).addCommand(docsCommand).addCommand(schemaCommand);
+var generateCommand = new Command8().command("generate").description("Scaffold new features or generate client schema").addCommand(featureCommand).addCommand(controllerCommand).addCommand(procedureCommand).addCommand(docsCommand).addCommand(schemaCommand).addCommand(callerCommand);
 
 // src/commands/dev/index.ts
-import { Command as Command8 } from "commander";
+import { Command as Command9 } from "commander";
 
 // src/commands/dev/action.ts
-import * as path23 from "path";
-import * as fs7 from "fs";
+import * as path24 from "path";
+import * as fs8 from "fs";
 import { spawn as spawn2 } from "child_process";
 import chokidar from "chokidar";
 import { render } from "ink";
@@ -3586,14 +4270,14 @@ function DevUI({ igniterLogs, appLogs, onExit }) {
   };
   const renderLogs = (logs, maxLines = 50) => {
     const visibleLogs = logs.slice(-maxLines);
-    return /* @__PURE__ */ React.createElement(Box, { flexDirection: "column" }, visibleLogs.length === 0 ? /* @__PURE__ */ React.createElement(Text, { dimColor: true }, "No logs yet...") : visibleLogs.map((log11, index) => {
+    return /* @__PURE__ */ React.createElement(Box, { flexDirection: "column" }, visibleLogs.length === 0 ? /* @__PURE__ */ React.createElement(Text, { dimColor: true }, "No logs yet...") : visibleLogs.map((log12, index) => {
       const color2 = {
         info: "cyan",
         success: "green",
         error: "red",
         warn: "yellow"
-      }[log11.type];
-      return /* @__PURE__ */ React.createElement(Text, { key: `${log11.timestamp.getTime()}-${index}`, color: color2 }, formatLogEntry(log11));
+      }[log12.type];
+      return /* @__PURE__ */ React.createElement(Text, { key: `${log12.timestamp.getTime()}-${index}`, color: color2 }, formatLogEntry(log12));
     }));
   };
   return /* @__PURE__ */ React.createElement(Box, { flexDirection: "column" }, /* @__PURE__ */ React.createElement(Box, { marginBottom: 1 }, /* @__PURE__ */ React.createElement(Text, { bold: true }, "Igniter.js Development Mode")), /* @__PURE__ */ React.createElement(Box, { flexDirection: "row" }, /* @__PURE__ */ React.createElement(
@@ -3655,19 +4339,19 @@ async function regenerateSchemaAndDocs(routerPath, outputPath, docsOutputDir, ad
 }
 async function handleDevAction(options) {
   const packageManager = detectPackageManager();
-  const routerPath = path23.resolve(process.cwd(), options.router || "src/igniter.router.ts");
+  const routerPath = path24.resolve(process.cwd(), options.router || "src/igniter.router.ts");
   const outputPath = options.output || "src/igniter.schema.ts";
   const docsOutputDir = options.docsOutput || "./src/docs";
   const devCommand2 = options.cmd || getDefaultDevCommand(packageManager);
-  if (!fs7.existsSync(routerPath)) {
+  if (!fs8.existsSync(routerPath)) {
     console.error(`Router file not found: ${routerPath}`);
     process.exit(1);
   }
   const igniterLogs = [];
   const appLogs = [];
   let rerenderFn = null;
-  const addIgniterLog = (log11) => {
-    igniterLogs.push(log11);
+  const addIgniterLog = (log12) => {
+    igniterLogs.push(log12);
     if (igniterLogs.length > 1e3) {
       igniterLogs.shift();
     }
@@ -3675,8 +4359,8 @@ async function handleDevAction(options) {
       rerenderFn();
     }
   };
-  const addAppLog = (log11) => {
-    appLogs.push(log11);
+  const addAppLog = (log12) => {
+    appLogs.push(log12);
     if (appLogs.length > 1e3) {
       appLogs.shift();
     }
@@ -3706,13 +4390,13 @@ async function handleDevAction(options) {
     });
     process.exit(1);
   }
-  const featuresDir = path23.join(process.cwd(), "src", "features");
+  const featuresDir = path24.join(process.cwd(), "src", "features");
   const watchPaths = [
     routerPath,
     // Watch router file directly
     featuresDir
     // Watch features directory recursively
-  ].filter((p13) => fs7.existsSync(p13));
+  ].filter((p14) => fs8.existsSync(p14));
   if (watchPaths.length === 0) {
     addIgniterLog({
       type: "warn",
@@ -3723,7 +4407,7 @@ async function handleDevAction(options) {
   }
   addIgniterLog({
     type: "info",
-    message: `Watching for changes in: ${watchPaths.map((p13) => path23.relative(process.cwd(), p13)).join(", ")}`,
+    message: `Watching for changes in: ${watchPaths.map((p14) => path24.relative(process.cwd(), p14)).join(", ")}`,
     timestamp: /* @__PURE__ */ new Date()
   });
   let regenerateTimeout = null;
@@ -3743,7 +4427,7 @@ async function handleDevAction(options) {
     ignoreInitial: true
   });
   watcher.on("change", (filePath) => {
-    const relativePath = path23.relative(process.cwd(), filePath);
+    const relativePath = path24.relative(process.cwd(), filePath);
     if (regenerateTimeout) {
       clearTimeout(regenerateTimeout);
     }
@@ -3867,10 +4551,10 @@ async function handleDevAction(options) {
 }
 
 // src/commands/dev/index.ts
-var devCommand = new Command8().command("dev").description("Start development mode with automatic schema and docs regeneration").option("--router <path>", "Path to the router file", "src/igniter.router.ts").option("--output <path>", "Output path for the schema file", "src/igniter.schema.ts").option("--docs-output <dir>", "Output directory for the OpenAPI spec", "./src/docs").option("--cmd <command>", "Custom command to start the development server").action(handleDevAction);
+var devCommand = new Command9().command("dev").description("Start development mode with automatic schema and docs regeneration").option("--router <path>", "Path to the router file", "src/igniter.router.ts").option("--output <path>", "Output path for the schema file", "src/igniter.schema.ts").option("--docs-output <dir>", "Output directory for the OpenAPI spec", "./src/docs").option("--cmd <command>", "Custom command to start the development server").action(handleDevAction);
 
 // src/index.ts
-var program = new Command9();
+var program = new Command10();
 program.name("igniter").description("The next-generation command-line interface for Igniter.js").version("0.0.1");
 program.addCommand(initCommand);
 program.addCommand(generateCommand);