@ic-reactor/codegen 0.2.0 → 0.3.1

package/dist/index.js

@@ -6,21 +6,6 @@ function toPascalCase(str) {
 function toCamelCase(str) {
   return 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`;
 }
@@ -28,52 +13,13 @@ function getServiceTypeName(canisterName) {
   return `${toPascalCase(canisterName)}Service`;
 }
 
-// src/did.ts
-import fs from "fs";
-function parseDIDFile(didFilePath) {
-  if (!fs.existsSync(didFilePath)) {
-    throw new Error(`DID file not found: ${didFilePath}`);
-  }
-  const content = fs.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
-import { generate } from "@icp-sdk/bindgen/core";
+import { didToJs, didToTs } from "@ic-reactor/parser";
 import path from "path";
-import fs2 from "fs";
+import fs from "fs";
 async function generateDeclarations(options) {
   const { didFile, outDir } = options;
-  if (!fs2.existsSync(didFile)) {
+  if (!fs.existsSync(didFile)) {
     return {
       success: false,
       declarationsDir: "",
@@ -81,27 +27,25 @@ async function generateDeclarations(options) {
     };
   }
   const declarationsDir = path.join(outDir, "declarations");
+  const didFileName = path.basename(didFile);
   try {
-    if (!fs2.existsSync(outDir)) {
-      fs2.mkdirSync(outDir, { recursive: true });
+    const didContent = fs.readFileSync(didFile, "utf-8");
+    if (!fs.existsSync(outDir)) {
+      fs.mkdirSync(outDir, { recursive: true });
     }
-    if (fs2.existsSync(declarationsDir)) {
-      fs2.rmSync(declarationsDir, { recursive: true, force: true });
+    if (fs.existsSync(declarationsDir)) {
+      fs.rmSync(declarationsDir, { recursive: true, force: true });
     }
-    fs2.mkdirSync(declarationsDir, { recursive: true });
-    await 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
-      }
-    });
+    fs.mkdirSync(declarationsDir, { recursive: true });
+    const jsContent = didToJs(didContent);
+    const tsContent = didToTs(didContent);
+    const baseName = didFileName.replace(/\.did$/, "");
+    const jsPath = path.join(declarationsDir, baseName + ".js");
+    const dtsPath = path.join(declarationsDir, baseName + ".d.ts");
+    const didPath = path.join(declarationsDir, didFileName);
+    fs.writeFileSync(jsPath, jsContent);
+    fs.writeFileSync(dtsPath, tsContent);
+    fs.writeFileSync(didPath, didContent);
     return {
       success: true,
       declarationsDir
@@ -116,77 +60,58 @@ async function generateDeclarations(options) {
 }
 function declarationsExist(outDir, canisterName) {
   const declarationsDir = path.join(outDir, "declarations");
-  const didTsPath = path.join(declarationsDir, `${canisterName}.did.ts`);
-  return fs2.existsSync(didTsPath);
-}
-function saveCandidFile(candidSource, outDir, canisterName) {
-  const candidDir = path.join(outDir, "candid");
-  if (!fs2.existsSync(candidDir)) {
-    fs2.mkdirSync(candidDir, { recursive: true });
-  }
-  const candidPath = path.join(candidDir, `${canisterName}.did`);
-  fs2.writeFileSync(candidPath, candidSource);
-  return candidPath;
+  const didTsPath = path.join(declarationsDir, `${canisterName}.d.ts`);
+  return fs.existsSync(didTsPath);
 }
 
 // src/templates/reactor.ts
 import path2 from "path";
 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 = path2.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 = path2.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,
@@ -194,296 +119,34 @@ 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
+// 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"
 
-${reactorInstance(vars)}
+export const queryClient = new QueryClient()`}
 
-${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
- *
+/**
+ * IC Reactor Client Manager
+ * 
  * 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}",
+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
 `;
 }
 export {
   declarationsExist,
-  extractMethods,
-  formatMethodForDisplay,
+  generateClientFile,
   generateDeclarations,
-  generateInfiniteQueryHook,
-  generateMutationHook,
-  generateQueryHook,
   generateReactorFile,
-  getHookExportName,
-  getHookFileName,
-  getMethodsByType,
-  getReactHookName,
   getReactorName,
   getServiceTypeName,
-  parseDIDFile,
-  saveCandidFile,
-  toCamelCase,
   toPascalCase
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ic-reactor/codegen",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "description": "Shared code generation utilities for IC Reactor",
   "type": "module",
   "main": "./dist/index.cjs",
@@ -33,19 +33,11 @@
     "directory": "packages/codegen"
   },
   "dependencies": {
-    "change-case": "^5.4.4"
-  },
-  "peerDependencies": {
-    "@icp-sdk/bindgen": "^0.2.0"
-  },
-  "peerDependenciesMeta": {
-    "@icp-sdk/bindgen": {
-      "optional": true
-    }
+    "change-case": "^5.4.4",
+    "@ic-reactor/parser": "0.4.6"
   },
   "devDependencies": {
-    "@icp-sdk/bindgen": "^0.2.1",
-    "@types/node": "^25.2.2",
+    "@types/node": "^25.2.3",
     "tsup": "^8.5.1",
     "typescript": "^5.9.3",
     "vitest": "^4.0.18"

package/src/__snapshots__/bindgen.test.ts.snap

@@ -0,0 +1,18 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`Bindgen > generateDeclarations creates correct files > js-declarations 1`] = `
+"export const idlFactory = ({ IDL }) => {
+  return IDL.Service({ 'greet' : IDL.Func([IDL.Text], [IDL.Text], ['query']) });
+};
+export const init = ({ IDL }) => { return []; };"
+`;
+
+exports[`Bindgen > generateDeclarations creates correct files > ts-declarations 1`] = `
+"import type { Principal } from '@icp-sdk/core/principal';
+import type { ActorMethod } from '@icp-sdk/core/agent';
+import type { IDL } from '@icp-sdk/core/candid';
+
+export interface _SERVICE { 'greet' : ActorMethod<[string], string> }
+export declare const idlFactory: IDL.InterfaceFactory;
+export declare const init: (args: { IDL: typeof IDL }) => IDL.Type[];"
+`;

package/src/bindgen.test.ts

@@ -0,0 +1,85 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest"
+import { generateDeclarations } from "./bindgen"
+import fs from "node:fs"
+import path from "node:path"
+
+describe("Bindgen", () => {
+  const mockDidFile = "mock/test.did"
+  const mockOutDir = "mock/output"
+  const mockCanisterName = "test_canister"
+  const validDidContent = `service : {
+    greet: (text) -> (text) query;
+}`
+
+  beforeEach(() => {
+    // Mock fs methods
+    vi.spyOn(fs, "existsSync").mockImplementation((p) => {
+      // Pretend the source DID file exists
+      if (p.toString() === mockDidFile) return true
+      return false
+    })
+
+    vi.spyOn(fs, "mkdirSync").mockImplementation(() => undefined as any)
+    vi.spyOn(fs, "rmSync").mockImplementation(() => undefined)
+    vi.spyOn(fs, "readFileSync").mockImplementation(() => validDidContent)
+    vi.spyOn(fs, "writeFileSync").mockImplementation(() => undefined)
+  })
+
+  afterEach(() => {
+    vi.restoreAllMocks()
+  })
+
+  it("generateDeclarations creates correct files", async () => {
+    const result = await generateDeclarations({
+      didFile: mockDidFile,
+      outDir: mockOutDir,
+      canisterName: mockCanisterName,
+    })
+
+    if (!result.success) {
+      console.error(result.error)
+    }
+
+    expect(result.success).toBe(true)
+    expect(result.declarationsDir).toBe(path.join(mockOutDir, "declarations"))
+
+    // Verify file writes
+    const declarationsDir = path.join(mockOutDir, "declarations")
+    const jsPath = path.join(declarationsDir, "test.js")
+    const dtsPath = path.join(declarationsDir, "test.d.ts")
+
+    // Should create directory
+    expect(fs.mkdirSync).toHaveBeenCalledWith(mockOutDir, { recursive: true })
+    expect(fs.mkdirSync).toHaveBeenCalledWith(declarationsDir, {
+      recursive: true,
+    })
+
+    // Validate exact content using snapshots
+    expect(fs.writeFileSync).toHaveBeenCalledWith(jsPath, expect.any(String))
+    expect(fs.writeFileSync).toHaveBeenCalledWith(dtsPath, expect.any(String))
+
+    // Get the arguments of the calls to check content
+    const jsCall = vi
+      .mocked(fs.writeFileSync)
+      .mock.calls.find((call) => call[0] === jsPath)
+    const dtsCall = vi
+      .mocked(fs.writeFileSync)
+      .mock.calls.find((call) => call[0] === dtsPath)
+
+    expect(jsCall?.[1]).toMatchSnapshot("js-declarations")
+    expect(dtsCall?.[1]).toMatchSnapshot("ts-declarations")
+  })
+
+  it("returns error if DID file missing", async () => {
+    vi.spyOn(fs, "existsSync").mockReturnValue(false)
+
+    const result = await generateDeclarations({
+      didFile: "missing.did",
+      outDir: mockOutDir,
+      canisterName: mockCanisterName,
+    })
+
+    expect(result.success).toBe(false)
+    expect(result.error).toContain("DID file not found")
+  })
+})