@ic-reactor/codegen 0.1.0

package/dist/index.cjs

@@ -0,0 +1,543 @@
+"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 __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  declarationsExist: () => declarationsExist,
+  extractMethods: () => extractMethods,
+  formatMethodForDisplay: () => formatMethodForDisplay,
+  generateDeclarations: () => generateDeclarations,
+  generateInfiniteQueryHook: () => generateInfiniteQueryHook,
+  generateMutationHook: () => generateMutationHook,
+  generateQueryHook: () => generateQueryHook,
+  generateReactorFile: () => generateReactorFile,
+  getHookExportName: () => getHookExportName,
+  getHookFileName: () => getHookFileName,
+  getMethodsByType: () => getMethodsByType,
+  getReactHookName: () => getReactHookName,
+  getReactorName: () => getReactorName,
+  getServiceTypeName: () => getServiceTypeName,
+  parseDIDFile: () => parseDIDFile,
+  saveCandidFile: () => saveCandidFile,
+  toCamelCase: () => toCamelCase,
+  toPascalCase: () => toPascalCase
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/naming.ts
+var import_change_case = require("change-case");
+function toPascalCase(str) {
+  return (0, import_change_case.pascalCase)(str);
+}
+function toCamelCase(str) {
+  return (0, import_change_case.camelCase)(str);
+}
+function getHookFileName(methodName, hookType) {
+  const camelMethod = toCamelCase(methodName);
+  const pascalType = toPascalCase(hookType);
+  return `${camelMethod}${pascalType}.ts`;
+}
+function getHookExportName(methodName, hookType) {
+  const camelMethod = toCamelCase(methodName);
+  const pascalType = toPascalCase(hookType);
+  return `${camelMethod}${pascalType}`;
+}
+function getReactHookName(methodName, hookType) {
+  const pascalMethod = toPascalCase(methodName);
+  const pascalType = toPascalCase(hookType);
+  return `use${pascalMethod}${pascalType}`;
+}
+function getReactorName(canisterName) {
+  return `${toCamelCase(canisterName)}Reactor`;
+}
+function getServiceTypeName(canisterName) {
+  return `${toPascalCase(canisterName)}Service`;
+}
+
+// src/did.ts
+var import_node_fs = __toESM(require("fs"), 1);
+function parseDIDFile(didFilePath) {
+  if (!import_node_fs.default.existsSync(didFilePath)) {
+    throw new Error(`DID file not found: ${didFilePath}`);
+  }
+  const content = import_node_fs.default.readFileSync(didFilePath, "utf-8");
+  return extractMethods(content);
+}
+function extractMethods(didContent) {
+  const methods = [];
+  const cleanContent = didContent.replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "");
+  const methodRegex = /([a-zA-Z_][a-zA-Z0-9_]*)\s*:\s*(?:func\s*)?\(([^)]*)\)\s*->\s*\(([^)]*)\)\s*(query|composite_query)?/g;
+  let match;
+  while ((match = methodRegex.exec(cleanContent)) !== null) {
+    const name = match[1];
+    const args = match[2].trim();
+    const returnType = match[3].trim();
+    const queryAnnotation = match[4];
+    const isQuery = queryAnnotation === "query" || queryAnnotation === "composite_query";
+    methods.push({
+      name,
+      type: isQuery ? "query" : "mutation",
+      hasArgs: args.length > 0 && args !== "",
+      argsDescription: args || void 0,
+      returnDescription: returnType || void 0
+    });
+  }
+  return methods;
+}
+function getMethodsByType(methods, type) {
+  return methods.filter((m) => m.type === type);
+}
+function formatMethodForDisplay(method) {
+  const typeLabel = method.type === "query" ? "query" : "update";
+  const argsLabel = method.hasArgs ? "with args" : "no args";
+  return `${method.name} (${typeLabel}, ${argsLabel})`;
+}
+
+// src/bindgen.ts
+var import_core = require("@icp-sdk/bindgen/core");
+var import_node_path = __toESM(require("path"), 1);
+var import_node_fs2 = __toESM(require("fs"), 1);
+async function generateDeclarations(options) {
+  const { didFile, outDir } = options;
+  if (!import_node_fs2.default.existsSync(didFile)) {
+    return {
+      success: false,
+      declarationsDir: "",
+      error: `DID file not found: ${didFile}`
+    };
+  }
+  const declarationsDir = import_node_path.default.join(outDir, "declarations");
+  try {
+    if (!import_node_fs2.default.existsSync(outDir)) {
+      import_node_fs2.default.mkdirSync(outDir, { recursive: true });
+    }
+    if (import_node_fs2.default.existsSync(declarationsDir)) {
+      import_node_fs2.default.rmSync(declarationsDir, { recursive: true, force: true });
+    }
+    import_node_fs2.default.mkdirSync(declarationsDir, { recursive: true });
+    await (0, import_core.generate)({
+      didFile,
+      outDir,
+      // Pass the parent directory; bindgen appends "declarations"
+      output: {
+        actor: {
+          disabled: true
+          // We don't need actor creation, we use Reactor
+        },
+        force: true
+        // Overwrite existing files
+      }
+    });
+    return {
+      success: true,
+      declarationsDir
+    };
+  } catch (error) {
+    return {
+      success: false,
+      declarationsDir,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+function declarationsExist(outDir, canisterName) {
+  const declarationsDir = import_node_path.default.join(outDir, "declarations");
+  const didTsPath = import_node_path.default.join(declarationsDir, `${canisterName}.did.ts`);
+  return import_node_fs2.default.existsSync(didTsPath);
+}
+function saveCandidFile(candidSource, outDir, canisterName) {
+  const candidDir = import_node_path.default.join(outDir, "candid");
+  if (!import_node_fs2.default.existsSync(candidDir)) {
+    import_node_fs2.default.mkdirSync(candidDir, { recursive: true });
+  }
+  const candidPath = import_node_path.default.join(candidDir, `${canisterName}.did`);
+  import_node_fs2.default.writeFileSync(candidPath, candidSource);
+  return candidPath;
+}
+
+// src/templates/reactor.ts
+var import_node_path2 = __toESM(require("path"), 1);
+function generateReactorFile(options) {
+  const {
+    canisterName,
+    canisterConfig,
+    globalClientManagerPath,
+    hasDeclarations = true,
+    advanced = false,
+    didContent
+  } = options;
+  const pascalName = toPascalCase(canisterName);
+  const reactorName = getReactorName(canisterName);
+  const serviceName = getServiceTypeName(canisterName);
+  const reactorType = canisterConfig.useDisplayReactor !== false ? "DisplayReactor" : "Reactor";
+  const clientManagerPath = canisterConfig.clientManagerPath ?? globalClientManagerPath ?? "../../lib/client";
+  const didFileName = import_node_path2.default.basename(canisterConfig.didFile);
+  const declarationsPath = `./declarations/${didFileName}`;
+  const vars = {
+    canisterName,
+    pascalName,
+    reactorName,
+    serviceName,
+    reactorType,
+    clientManagerPath,
+    declarationsPath,
+    useDisplayReactor: canisterConfig.useDisplayReactor !== false
+  };
+  if (!hasDeclarations) {
+    return generateFallbackReactorFile(vars);
+  }
+  if (advanced && didContent) {
+    return generateAdvancedReactorFile(vars, didContent);
+  }
+  return generateSimpleReactorFile(vars);
+}
+function reactorInstance(vars) {
+  const {
+    pascalName,
+    reactorName,
+    serviceName,
+    reactorType,
+    canisterName,
+    useDisplayReactor
+  } = vars;
+  return `/**
+ * ${pascalName} Reactor \u2014 ${useDisplayReactor ? "Display" : "Candid"} mode.
+ * ${useDisplayReactor ? "Automatically converts bigint \u2192 string, Principal \u2192 string, etc." : "Uses raw Candid types."}
+ */
+export const ${reactorName} = new ${reactorType}<${serviceName}>({
+  clientManager,
+  idlFactory,
+  name: "${canisterName}",
+})`;
+}
+function actorHooks(vars) {
+  const { pascalName, reactorName } = vars;
+  return `const {
+  useActorQuery: use${pascalName}Query,
+  useActorSuspenseQuery: use${pascalName}SuspenseQuery,
+  useActorInfiniteQuery: use${pascalName}InfiniteQuery,
+  useActorSuspenseInfiniteQuery: use${pascalName}SuspenseInfiniteQuery,
+  useActorMutation: use${pascalName}Mutation,
+  useActorMethod: use${pascalName}Method,
+} = createActorHooks(${reactorName})
+
+export {
+  use${pascalName}Query,
+  use${pascalName}SuspenseQuery,
+  use${pascalName}InfiniteQuery,
+  use${pascalName}SuspenseInfiniteQuery,
+  use${pascalName}Mutation,
+  use${pascalName}Method,
+}`;
+}
+function generateSimpleReactorFile(vars) {
+  const {
+    pascalName,
+    reactorType,
+    clientManagerPath,
+    declarationsPath,
+    serviceName
+  } = vars;
+  return `/**
+ * ${pascalName} Reactor
+ *
+ * Auto-generated by @ic-reactor/codegen
+ */
+
+import { ${reactorType}, createActorHooks } from "@ic-reactor/react"
+import { clientManager } from "${clientManagerPath}"
+import { idlFactory, type _SERVICE } from "${declarationsPath}"
+
+export type ${serviceName} = _SERVICE
+
+${reactorInstance(vars)}
+
+${actorHooks(vars)}
+
+export { idlFactory }
+`;
+}
+function generateAdvancedReactorFile(vars, didContent) {
+  const {
+    pascalName,
+    reactorName,
+    serviceName,
+    reactorType,
+    clientManagerPath,
+    declarationsPath
+  } = vars;
+  const methods = extractMethods(didContent);
+  const hasQueryWithoutArgs = methods.some(
+    (m) => m.type === "query" && !m.hasArgs
+  );
+  const hasMutationWithoutArgs = methods.some(
+    (m) => m.type === "mutation" && !m.hasArgs
+  );
+  const extraImports = [];
+  if (hasQueryWithoutArgs) extraImports.push("createQuery");
+  if (hasMutationWithoutArgs) extraImports.push("createMutation");
+  const perMethodHooks = methods.map(({ name, type, hasArgs }) => {
+    const camelMethod = toCamelCase(name);
+    if (type === "query") {
+      if (!hasArgs) {
+        return `
+export const ${camelMethod}Query = createQuery(${reactorName}, {
+  functionName: "${name}",
+})`;
+      }
+      return "";
+    } else {
+      if (!hasArgs) {
+        return `
+export const ${camelMethod}Mutation = createMutation(${reactorName}, {
+  functionName: "${name}",
+})`;
+      }
+      return "";
+    }
+  }).filter(Boolean);
+  return `/**
+ * ${pascalName} Reactor (Advanced)
+ *
+ * Auto-generated by @ic-reactor/codegen
+ * Includes reactor instance, actor hooks, and per-method static hooks.
+ */
+
+import {
+  ${reactorType},
+  createActorHooks,${extraImports.length > 0 ? "\n  " + extraImports.join(",\n  ") + "," : ""}
+} from "@ic-reactor/react"
+import { clientManager } from "${clientManagerPath}"
+import { idlFactory, type _SERVICE } from "${declarationsPath}"
+
+type ${serviceName} = _SERVICE
+
+${reactorInstance(vars)}
+
+${actorHooks(vars)}
+${perMethodHooks.length > 0 ? `
+// Per-method static hooks (no-args methods only)
+${perMethodHooks.join("\n")}
+` : ""}
+export { idlFactory }
+export type { ${serviceName} }
+`;
+}
+function generateFallbackReactorFile(vars) {
+  const {
+    canisterName,
+    pascalName,
+    serviceName,
+    reactorType,
+    clientManagerPath,
+    declarationsPath
+  } = vars;
+  return `/**
+ * ${pascalName} Reactor
+ *
+ * Auto-generated by @ic-reactor/codegen
+ *
+ * \u26A0\uFE0F Declarations were not generated. Run:
+ *   npx @icp-sdk/bindgen --input <path-to-did> --output ./${canisterName}/declarations
+ * Then uncomment the import below and remove the fallback type.
+ */
+
+import { ${reactorType}, createActorHooks } from "@ic-reactor/react"
+import { clientManager } from "${clientManagerPath}"
+
+// TODO: Uncomment after generating declarations:
+// import { idlFactory, type _SERVICE as ${serviceName} } from "${declarationsPath}"
+
+// Fallback \u2014 replace with generated types
+type ${serviceName} = Record<string, (...args: unknown[]) => Promise<unknown>>
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const idlFactory = ({ IDL }: { IDL: any }) => IDL.Service({})
+
+${reactorInstance(vars)}
+
+${actorHooks(vars)}
+
+export { idlFactory }
+export type { ${serviceName} }
+`;
+}
+
+// src/templates/query.ts
+function generateQueryHook(options) {
+  const { canisterName, method, type = "query" } = options;
+  const reactorName = getReactorName(canisterName);
+  const hookExportName = getHookExportName(method.name, type);
+  const isSuspense = type === "suspenseQuery";
+  const creatorFn = isSuspense ? "createSuspenseQuery" : "createQuery";
+  const factoryFn = isSuspense ? "createSuspenseQueryFactory" : "createQueryFactory";
+  const hookName = isSuspense ? "useSuspenseQuery" : "useQuery";
+  if (method.hasArgs) {
+    return `/**
+ * Query Factory: ${method.name}
+ *
+ * Auto-generated by @ic-reactor/codegen
+ *
+ * @example
+ * const { data } = ${hookExportName}([arg1, arg2]).${hookName}()
+ * const data = await ${hookExportName}([arg1, arg2]).fetch()
+ * ${hookExportName}([arg1, arg2]).invalidate()
+ */
+
+import { ${factoryFn} } from "@ic-reactor/react"
+import { ${reactorName} } from "../reactor"
+
+export const ${hookExportName} = ${factoryFn}(${reactorName}, {
+  functionName: "${method.name}",
+})
+`;
+  }
+  return `/**
+ * Query: ${method.name}
+ *
+ * Auto-generated by @ic-reactor/codegen
+ *
+ * @example
+ * const { data } = ${hookExportName}.${hookName}()
+ * const data = await ${hookExportName}.fetch()
+ * ${hookExportName}.invalidate()
+ */
+
+import { ${creatorFn} } from "@ic-reactor/react"
+import { ${reactorName} } from "../reactor"
+
+export const ${hookExportName} = ${creatorFn}(${reactorName}, {
+  functionName: "${method.name}",
+})
+`;
+}
+
+// src/templates/mutation.ts
+function generateMutationHook(options) {
+  const { canisterName, method } = options;
+  const pascalMethod = toPascalCase(method.name);
+  const reactorName = getReactorName(canisterName);
+  const hookExportName = getHookExportName(method.name, "mutation");
+  return `/**
+ * Mutation: ${method.name}
+ *
+ * Auto-generated by @ic-reactor/codegen
+ *
+ * @example
+ * const { mutate, isPending } = ${hookExportName}.useMutation()
+ * mutate(${method.hasArgs ? "[arg1, arg2]" : "[]"})
+ *
+ * // Direct execution (outside React)
+ * const result = await ${hookExportName}.execute(${method.hasArgs ? "[arg1, arg2]" : "[]"})
+ */
+
+import { createMutation } from "@ic-reactor/react"
+import { ${reactorName} } from "../reactor"
+
+export const ${hookExportName} = createMutation(${reactorName}, {
+  functionName: "${method.name}",
+})
+
+/** React hook for ${method.name} */
+export const use${pascalMethod}Mutation = ${hookExportName}.useMutation
+
+/** Execute ${method.name} directly (outside React) */
+export const execute${pascalMethod} = ${hookExportName}.execute
+`;
+}
+
+// src/templates/infiniteQuery.ts
+function generateInfiniteQueryHook(options) {
+  const { canisterName, method, type = "infiniteQuery" } = options;
+  const reactorName = getReactorName(canisterName);
+  const serviceName = getServiceTypeName(canisterName);
+  const hookExportName = getHookExportName(method.name, type);
+  const reactHookName = getReactHookName(method.name, type);
+  return `/**
+ * Infinite Query: ${method.name}
+ *
+ * Auto-generated by @ic-reactor/codegen
+ *
+ * \u26A0\uFE0F CUSTOMIZATION REQUIRED: Configure getArgs and getNextPageParam below.
+ *
+ * @example
+ * const { data, fetchNextPage, hasNextPage } = ${hookExportName}.useInfiniteQuery()
+ * const allItems = data?.pages.flatMap(page => page.items) ?? []
+ */
+
+import { createInfiniteQuery } from "@ic-reactor/react"
+import { ${reactorName}, type ${serviceName} } from "../reactor"
+
+/** Define your pagination cursor type */
+type PageCursor = number
+
+export const ${hookExportName} = createInfiniteQuery(${reactorName}, {
+  functionName: "${method.name}",
+
+  initialPageParam: 0 as PageCursor,
+
+  /** Convert page param to method arguments \u2014 customize for your API */
+  getArgs: (pageParam: PageCursor) => {
+    return [{ offset: pageParam, limit: 10 }] as Parameters<${serviceName}["${method.name}"]>
+  },
+
+  /** Extract next page param \u2014 return undefined when no more pages */
+  getNextPageParam: (lastPage, allPages, lastPageParam) => {
+    // Example: offset-based
+    // if (lastPage.items.length < 10) return undefined
+    // return lastPageParam + 10
+    return undefined
+  },
+})
+
+/** React hook for paginated ${method.name} */
+export const ${reactHookName} = ${hookExportName}.useInfiniteQuery
+`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  declarationsExist,
+  extractMethods,
+  formatMethodForDisplay,
+  generateDeclarations,
+  generateInfiniteQueryHook,
+  generateMutationHook,
+  generateQueryHook,
+  generateReactorFile,
+  getHookExportName,
+  getHookFileName,
+  getMethodsByType,
+  getReactHookName,
+  getReactorName,
+  getServiceTypeName,
+  parseDIDFile,
+  saveCandidFile,
+  toCamelCase,
+  toPascalCase
+});