@ic-reactor/codegen 0.2.0 → 0.3.0

package/dist/index.cjs

@@ -31,22 +31,11 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   declarationsExist: () => declarationsExist,
-  extractMethods: () => extractMethods,
-  formatMethodForDisplay: () => formatMethodForDisplay,
+  generateClientFile: () => generateClientFile,
   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);
@@ -59,21 +48,6 @@ function toPascalCase(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`;
 }
@@ -81,52 +55,13 @@ 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_parser = require("@ic-reactor/parser");
 var import_node_path = __toESM(require("path"), 1);
-var import_node_fs2 = __toESM(require("fs"), 1);
+var import_node_fs = __toESM(require("fs"), 1);
 async function generateDeclarations(options) {
   const { didFile, outDir } = options;
-  if (!import_node_fs2.default.existsSync(didFile)) {
+  if (!import_node_fs.default.existsSync(didFile)) {
     return {
       success: false,
       declarationsDir: "",
@@ -134,27 +69,25 @@ async function generateDeclarations(options) {
     };
   }
   const declarationsDir = import_node_path.default.join(outDir, "declarations");
+  const didFileName = import_node_path.default.basename(didFile);
   try {
-    if (!import_node_fs2.default.existsSync(outDir)) {
-      import_node_fs2.default.mkdirSync(outDir, { recursive: true });
+    const didContent = import_node_fs.default.readFileSync(didFile, "utf-8");
+    if (!import_node_fs.default.existsSync(outDir)) {
+      import_node_fs.default.mkdirSync(outDir, { recursive: true });
     }
-    if (import_node_fs2.default.existsSync(declarationsDir)) {
-      import_node_fs2.default.rmSync(declarationsDir, { recursive: true, force: true });
+    if (import_node_fs.default.existsSync(declarationsDir)) {
+      import_node_fs.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
-      }
-    });
+    import_node_fs.default.mkdirSync(declarationsDir, { recursive: true });
+    const jsContent = (0, import_parser.didToJs)(didContent);
+    const tsContent = (0, import_parser.didToTs)(didContent);
+    const baseName = didFileName.replace(/\.did$/, "");
+    const jsPath = import_node_path.default.join(declarationsDir, baseName + ".js");
+    const dtsPath = import_node_path.default.join(declarationsDir, baseName + ".d.ts");
+    const didPath = import_node_path.default.join(declarationsDir, didFileName);
+    import_node_fs.default.writeFileSync(jsPath, jsContent);
+    import_node_fs.default.writeFileSync(dtsPath, tsContent);
+    import_node_fs.default.writeFileSync(didPath, didContent);
     return {
       success: true,
       declarationsDir
@@ -169,77 +102,58 @@ async function generateDeclarations(options) {
 }
 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;
+  const didTsPath = import_node_path.default.join(declarationsDir, `${canisterName}.d.ts`);
+  return import_node_fs.default.existsSync(didTsPath);
 }
 
 // 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 pascalName = toPascalCase(options.canisterName);
+  const reactorName = getReactorName(options.canisterName);
+  const serviceName = getServiceTypeName(options.canisterName);
+  const reactorType = "DisplayReactor";
+  const didFileName = import_node_path2.default.basename(options.didFile);
+  const baseName = didFileName.replace(/\.did$/, "");
+  const declarationsPath = `./declarations/${baseName}`;
+  const clientManagerPath = options.clientManagerPath ?? "../../clients";
   const vars = {
-    canisterName,
+    canisterName: options.canisterName,
     pascalName,
     reactorName,
     serviceName,
     reactorType,
     clientManagerPath,
-    declarationsPath,
-    useDisplayReactor: canisterConfig.useDisplayReactor !== false
+    declarationsPath
   };
-  if (!hasDeclarations) {
-    return generateFallbackReactorFile(vars);
-  }
-  if (advanced && didContent) {
-    return generateAdvancedReactorFile(vars, didContent);
-  }
-  return generateSimpleReactorFile(vars);
+  return generateStandardReactorFile(vars);
 }
-function reactorInstance(vars) {
+function generateStandardReactorFile(vars) {
   const {
     pascalName,
     reactorName,
     serviceName,
     reactorType,
-    canisterName,
-    useDisplayReactor
+    clientManagerPath,
+    declarationsPath,
+    canisterName
   } = vars;
-  return `/**
- * ${pascalName} Reactor \u2014 ${useDisplayReactor ? "Display" : "Candid"} mode.
- * ${useDisplayReactor ? "Automatically converts bigint \u2192 string, Principal \u2192 string, etc." : "Uses raw Candid types."}
+  return `import { ${reactorType}, createActorHooks } from "@ic-reactor/react"
+import { clientManager } from "${clientManagerPath}"
+import { idlFactory, type _SERVICE } from "${declarationsPath}"
+
+export type ${serviceName} = _SERVICE
+
+/**
+ * ${pascalName} Display Reactor
  */
 export const ${reactorName} = new ${reactorType}<${serviceName}>({
   clientManager,
   idlFactory,
   name: "${canisterName}",
-})`;
-}
-function actorHooks(vars) {
-  const { pascalName, reactorName } = vars;
-  return `const {
+})
+
+export const {
   useActorQuery: use${pascalName}Query,
   useActorSuspenseQuery: use${pascalName}SuspenseQuery,
   useActorInfiniteQuery: use${pascalName}InfiniteQuery,
@@ -247,297 +161,35 @@ function actorHooks(vars) {
   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)}
+// src/templates/client.ts
+function generateClientFile(options = {}) {
+  const { queryClientPath } = options;
+  return `import { ClientManager } from "@ic-reactor/react"
+${queryClientPath ? `import { queryClient } from "${queryClientPath}"` : `import { QueryClient } from "@tanstack/react-query"
 
-${actorHooks(vars)}
+export const queryClient = new QueryClient()`}
 
-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}
- *
+/**
+ * IC Reactor Client Manager
+ * 
  * 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}",
+export const clientManager = new ClientManager({
+  queryClient,
+  withCanisterEnv: true,
 })
-`;
-  }
-  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,
+  generateClientFile,
   generateDeclarations,
-  generateInfiniteQueryHook,
-  generateMutationHook,
-  generateQueryHook,
   generateReactorFile,
-  getHookExportName,
-  getHookFileName,
-  getMethodsByType,
-  getReactHookName,
   getReactorName,
   getServiceTypeName,
-  parseDIDFile,
-  saveCandidFile,
-  toCamelCase,
   toPascalCase
 });