@ic-reactor/codegen 0.2.0 → 0.3.1

package/src/templates/reactor.ts

@@ -1,67 +1,46 @@
 /**
  * Reactor file template generator
  *
- * Generates the reactor instance file for a canister.
- * Supports simple mode (generic hooks) and advanced mode (per-method typed hooks).
+ * Generates the reactor instance file for a canister using DisplayReactor.
+ * Standardizes the output to include typed hooks and clean imports.
  */
 
 import path from "node:path"
-import type { ReactorGeneratorOptions } from "../types.js"
-import {
-  toPascalCase,
-  toCamelCase,
-  getReactorName,
-  getServiceTypeName,
-} from "../naming.js"
-import { extractMethods } from "../did.js"
+import { toPascalCase, getReactorName, getServiceTypeName } from "../naming.js"
+
+export type ReactorGeneratorOptions = {
+  canisterName: string
+  didFile: string
+  clientManagerPath?: string
+}
 
 /**
  * Generate the reactor file content
  */
 export function generateReactorFile(options: ReactorGeneratorOptions): string {
-  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 pascalName = toPascalCase(options.canisterName)
+  const reactorName = getReactorName(options.canisterName)
+  const serviceName = getServiceTypeName(options.canisterName)
+  // Always use DisplayReactor for now
+  const reactorType = "DisplayReactor"
 
-  const didFileName = path.basename(canisterConfig.didFile)
-  const declarationsPath = `./declarations/${didFileName}`
+  const didFileName = path.basename(options.didFile)
+  const baseName = didFileName.replace(/\.did$/, "")
+  const declarationsPath = `./declarations/${baseName}`
+  const clientManagerPath = options.clientManagerPath ?? "../../clients"
 
   const vars: TemplateVars = {
-    canisterName,
+    canisterName: options.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)
+  // If we have DID content, we can generate method-specific hooks (clean & typed)
+  return generateStandardReactorFile(vars)
 }
 
 // ═══════════════════════════════════════════════════════════════════════════
@@ -76,36 +55,39 @@ interface TemplateVars {
   reactorType: string
   clientManagerPath: string
   declarationsPath: string
-  useDisplayReactor: boolean
 }
 
 // ═══════════════════════════════════════════════════════════════════════════
-// SHARED SECTIONS
+// STANDARD MODE
 // ═══════════════════════════════════════════════════════════════════════════
 
-function reactorInstance(vars: TemplateVars): string {
+function generateStandardReactorFile(vars: TemplateVars): string {
   const {
     pascalName,
     reactorName,
     serviceName,
     reactorType,
+    clientManagerPath,
+    declarationsPath,
     canisterName,
-    useDisplayReactor,
   } = vars
-  return `/**
- * ${pascalName} Reactor — ${useDisplayReactor ? "Display" : "Candid"} mode.
- * ${useDisplayReactor ? "Automatically converts bigint → string, Principal → 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: TemplateVars): string {
-  const { pascalName, reactorName } = vars
-  return `const {
+export const {
   useActorQuery: use${pascalName}Query,
   useActorSuspenseQuery: use${pascalName}SuspenseQuery,
   useActorInfiniteQuery: use${pascalName}InfiniteQuery,
@@ -113,178 +95,5 @@ function actorHooks(vars: TemplateVars): string {
   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,
-}`
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// SIMPLE MODE
-// ═══════════════════════════════════════════════════════════════════════════
-
-function generateSimpleReactorFile(vars: TemplateVars): string {
-  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 }
-`
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// ADVANCED MODE
-// ═══════════════════════════════════════════════════════════════════════════
-
-function generateAdvancedReactorFile(
-  vars: TemplateVars,
-  didContent: string
-): string {
-  const {
-    pascalName,
-    reactorName,
-    serviceName,
-    reactorType,
-    clientManagerPath,
-    declarationsPath,
-  } = vars
-
-  const methods = extractMethods(didContent)
-
-  // Determine which extra imports we need based on methods
-  const hasQueryWithoutArgs = methods.some(
-    (m) => m.type === "query" && !m.hasArgs
-  )
-  const hasMutationWithoutArgs = methods.some(
-    (m) => m.type === "mutation" && !m.hasArgs
-  )
-
-  const extraImports: string[] = []
-  if (hasQueryWithoutArgs) extraImports.push("createQuery")
-  if (hasMutationWithoutArgs) extraImports.push("createMutation")
-
-  // Generate per-method static hooks (no-args methods only)
-  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 "" // queries with args don't get static instances
-      } else {
-        if (!hasArgs) {
-          return `
-export const ${camelMethod}Mutation = createMutation(${reactorName}, {
-  functionName: "${name}",
-})`
-        }
-        return "" // mutations with args don't get static instances
-      }
-    })
-    .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} }
-`
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// FALLBACK (NO DECLARATIONS)
-// ═══════════════════════════════════════════════════════════════════════════
-
-function generateFallbackReactorFile(vars: TemplateVars): string {
-  const {
-    canisterName,
-    pascalName,
-    serviceName,
-    reactorType,
-    clientManagerPath,
-    declarationsPath,
-  } = vars
-
-  return `/**
- * ${pascalName} Reactor
- *
- * Auto-generated by @ic-reactor/codegen
- *
- * ⚠️ 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 — 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} }
 `
 }

package/src/did.test.ts

@@ -1,102 +0,0 @@
-import { describe, it, expect } from "vitest"
-import { extractMethods, formatMethodForDisplay } from "./did"
-import type { MethodInfo } from "./types"
-
-describe("DID Utilities", () => {
-  describe("extractMethods", () => {
-    it("extracts query methods", () => {
-      const didContent = `
-      type User = record { name : text; age : nat };
-      type Item = record { name : text; price : nat };
-
-      service : {
-        get_user: (nat) -> (opt User) query;
-        list_items: () -> (vec Item) query;
-      }`
-      const methods = extractMethods(didContent)
-      expect(methods).toHaveLength(2)
-      expect(methods[0]).toMatchObject({
-        name: "get_user",
-        type: "query",
-        hasArgs: true,
-      })
-      expect(methods[1]).toMatchObject({
-        name: "list_items",
-        type: "query",
-        hasArgs: false,
-      })
-    })
-
-    it("extracts mutation (update) methods", () => {
-      const didContent = `service : {
-        create_user: (User) -> (Result);
-        update_item: (nat, Item) -> (Result);
-      }`
-      const methods = extractMethods(didContent)
-      expect(methods).toHaveLength(2)
-      expect(methods[0]).toMatchObject({
-        name: "create_user",
-        type: "mutation",
-        hasArgs: true,
-      })
-      expect(methods[1]).toMatchObject({
-        name: "update_item",
-        type: "mutation",
-        hasArgs: true,
-      })
-    })
-
-    it("handles composite_query as query", () => {
-      const didContent = `service : {
-        search: (text) -> (vec Item) composite_query;
-      }`
-      const methods = extractMethods(didContent)
-      expect(methods[0].type).toBe("query")
-    })
-
-    it("ignores comments", () => {
-      const didContent = `service : {
-        // This is a comment
-        get_data: () -> (text) query;
-        /* create_data: (text) -> (); */
-      }`
-      const methods = extractMethods(didContent)
-      expect(methods).toHaveLength(1)
-      expect(methods[0].name).toBe("get_data")
-    })
-
-    it("extracts argument and return types correctly", () => {
-      const didContent = `service : {
-        weird_method: (record { foo: text; bar: nat }) -> (variant { Ok: null; Err: text }) query;
-      }`
-      const methods = extractMethods(didContent)
-      expect(methods[0].name).toBe("weird_method")
-      expect(methods[0].argsDescription).toContain(
-        "record { foo: text; bar: nat }"
-      )
-      expect(methods[0].returnDescription).toContain(
-        "variant { Ok: null; Err: text }"
-      )
-    })
-  })
-
-  describe("formatMethodForDisplay", () => {
-    it("formats query method with args", () => {
-      const method: MethodInfo = {
-        name: "search",
-        type: "query",
-        hasArgs: true,
-      }
-      expect(formatMethodForDisplay(method)).toBe("search (query, with args)")
-    })
-
-    it("formats update method without args", () => {
-      const method: MethodInfo = {
-        name: "init",
-        type: "mutation",
-        hasArgs: false,
-      }
-      expect(formatMethodForDisplay(method)).toBe("init (update, no args)")
-    })
-  })
-})

package/src/did.ts

@@ -1,85 +0,0 @@
-/**
- * DID file parser
- *
- * Extracts method information from Candid interface definition files.
- * Based on the CLI's parser implementation (with comment stripping).
- */
-
-import fs from "node:fs"
-import type { MethodInfo } from "./types.js"
-
-/**
- * Parse a .did file and extract method information
- */
-export function parseDIDFile(didFilePath: string): MethodInfo[] {
-  if (!fs.existsSync(didFilePath)) {
-    throw new Error(`DID file not found: ${didFilePath}`)
-  }
-
-  const content = fs.readFileSync(didFilePath, "utf-8")
-  return extractMethods(content)
-}
-
-/**
- * Extract methods from DID content
- *
- * Handles formats like:
- * - `name : (args) -> (result)`
- * - `name : (args) -> (result) query`
- * - `name : (args) -> (result) composite_query`
- * - `name : func (args) -> (result)`
- */
-export function extractMethods(didContent: string): MethodInfo[] {
-  const methods: MethodInfo[] = []
-
-  // Remove comments
-  const cleanContent = didContent
-    .replace(/\/\/.*$/gm, "") // Single line comments
-    .replace(/\/\*[\s\S]*?\*\//g, "") // Multi-line comments
-
-  // Match method definitions
-  // Pattern: name : [func] (args) -> (result) [query|composite_query]
-  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]
-
-    // Determine if it's a query or mutation
-    const isQuery =
-      queryAnnotation === "query" || queryAnnotation === "composite_query"
-
-    methods.push({
-      name,
-      type: isQuery ? "query" : "mutation",
-      hasArgs: args.length > 0 && args !== "",
-      argsDescription: args || undefined,
-      returnDescription: returnType || undefined,
-    })
-  }
-
-  return methods
-}
-
-/**
- * Get methods by type
- */
-export function getMethodsByType(
-  methods: MethodInfo[],
-  type: "query" | "mutation"
-): MethodInfo[] {
-  return methods.filter((m) => m.type === type)
-}
-
-/**
- * Format method info for display
- */
-export function formatMethodForDisplay(method: MethodInfo): string {
-  const typeLabel = method.type === "query" ? "query" : "update"
-  const argsLabel = method.hasArgs ? "with args" : "no args"
-  return `${method.name} (${typeLabel}, ${argsLabel})`
-}

package/src/templates/__snapshots__/infiniteQuery.test.ts.snap

@@ -1,44 +0,0 @@
-// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
-
-exports[`Infinite Query Hook Generation > generates infinite query hook correctly 1`] = `
-"/**
- * Infinite Query: list_items
- *
- * Auto-generated by @ic-reactor/codegen
- *
- * ⚠️ CUSTOMIZATION REQUIRED: Configure getArgs and getNextPageParam below.
- *
- * @example
- * const { data, fetchNextPage, hasNextPage } = listItemsInfiniteQuery.useInfiniteQuery()
- * const allItems = data?.pages.flatMap(page => page.items) ?? []
- */
-
-import { createInfiniteQuery } from "@ic-reactor/react"
-import { myCanisterReactor, type MyCanisterService } from "../reactor"
-
-/** Define your pagination cursor type */
-type PageCursor = number
-
-export const listItemsInfiniteQuery = createInfiniteQuery(myCanisterReactor, {
-  functionName: "list_items",
-
-  initialPageParam: 0 as PageCursor,
-
-  /** Convert page param to method arguments — customize for your API */
-  getArgs: (pageParam: PageCursor) => {
-    return [{ offset: pageParam, limit: 10 }] as Parameters<MyCanisterService["list_items"]>
-  },
-
-  /** Extract next page param — 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 list_items */
-export const useListItemsInfiniteQuery = listItemsInfiniteQuery.useInfiniteQuery
-"
-`;

package/src/templates/__snapshots__/mutation.test.ts.snap

@@ -1,59 +0,0 @@
-// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
-
-exports[`Mutation Hook Generation > generates hook correctly for mutation with args 1`] = `
-"/**
- * Mutation: create_item
- *
- * Auto-generated by @ic-reactor/codegen
- *
- * @example
- * const { mutate, isPending } = createItemMutation.useMutation()
- * mutate([arg1, arg2])
- *
- * // Direct execution (outside React)
- * const result = await createItemMutation.execute([arg1, arg2])
- */
-
-import { createMutation } from "@ic-reactor/react"
-import { myCanisterReactor } from "../reactor"
-
-export const createItemMutation = createMutation(myCanisterReactor, {
-  functionName: "create_item",
-})
-
-/** React hook for create_item */
-export const useCreateItemMutation = createItemMutation.useMutation
-
-/** Execute create_item directly (outside React) */
-export const executeCreateItem = createItemMutation.execute
-"
-`;
-
-exports[`Mutation Hook Generation > generates hook correctly for mutation without args 1`] = `
-"/**
- * Mutation: init_system
- *
- * Auto-generated by @ic-reactor/codegen
- *
- * @example
- * const { mutate, isPending } = initSystemMutation.useMutation()
- * mutate([])
- *
- * // Direct execution (outside React)
- * const result = await initSystemMutation.execute([])
- */
-
-import { createMutation } from "@ic-reactor/react"
-import { myCanisterReactor } from "../reactor"
-
-export const initSystemMutation = createMutation(myCanisterReactor, {
-  functionName: "init_system",
-})
-
-/** React hook for init_system */
-export const useInitSystemMutation = initSystemMutation.useMutation
-
-/** Execute init_system directly (outside React) */
-export const executeInitSystem = initSystemMutation.execute
-"
-`;

package/src/templates/__snapshots__/query.test.ts.snap

@@ -1,64 +0,0 @@
-// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
-
-exports[`Query Hook Generation > generates hook for query with arguments (factory) 1`] = `
-"/**
- * Query Factory: get_user
- *
- * Auto-generated by @ic-reactor/codegen
- *
- * @example
- * const { data } = getUserQuery([arg1, arg2]).useQuery()
- * const data = await getUserQuery([arg1, arg2]).fetch()
- * getUserQuery([arg1, arg2]).invalidate()
- */
-
-import { createQueryFactory } from "@ic-reactor/react"
-import { myCanisterReactor } from "../reactor"
-
-export const getUserQuery = createQueryFactory(myCanisterReactor, {
-  functionName: "get_user",
-})
-"
-`;
-
-exports[`Query Hook Generation > generates hook for query without arguments (static) 1`] = `
-"/**
- * Query: list_items
- *
- * Auto-generated by @ic-reactor/codegen
- *
- * @example
- * const { data } = listItemsQuery.useQuery()
- * const data = await listItemsQuery.fetch()
- * listItemsQuery.invalidate()
- */
-
-import { createQuery } from "@ic-reactor/react"
-import { myCanisterReactor } from "../reactor"
-
-export const listItemsQuery = createQuery(myCanisterReactor, {
-  functionName: "list_items",
-})
-"
-`;
-
-exports[`Query Hook Generation > generates suspense hooks correctly 1`] = `
-"/**
- * Query Factory: get_user
- *
- * Auto-generated by @ic-reactor/codegen
- *
- * @example
- * const { data } = getUserSuspenseQuery([arg1, arg2]).useSuspenseQuery()
- * const data = await getUserSuspenseQuery([arg1, arg2]).fetch()
- * getUserSuspenseQuery([arg1, arg2]).invalidate()
- */
-
-import { createSuspenseQueryFactory } from "@ic-reactor/react"
-import { myCanisterReactor } from "../reactor"
-
-export const getUserSuspenseQuery = createSuspenseQueryFactory(myCanisterReactor, {
-  functionName: "get_user",
-})
-"
-`;