@ic-reactor/codegen 0.12.1 → 0.13.0

package/src/bindgen.test.ts

@@ -1,85 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest"
-import fs from "node:fs"
-import path from "node:path"
-import { generateDeclarations } from "./generators/index.js"
-
-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")
-  })
-})

package/src/naming.test.ts

@@ -1,45 +0,0 @@
-import { describe, it, expect } from "vitest"
-import {
-  toPascalCase,
-  toCamelCase,
-  getReactorName,
-  getServiceTypeName,
-} from "./naming.js"
-
-describe("Naming Utilities", () => {
-  describe("Base Conversions", () => {
-    it("converts to PascalCase", () => {
-      expect(toPascalCase("get_user")).toBe("GetUser")
-      expect(toPascalCase("my-canister")).toBe("MyCanister")
-      expect(toPascalCase("list_items_v2")).toBe("ListItemsV2")
-    })
-
-    it("converts to camelCase", () => {
-      expect(toCamelCase("get_user")).toBe("getUser")
-      expect(toCamelCase("my-canister")).toBe("myCanister")
-      expect(toCamelCase("ListItems")).toBe("listItems")
-    })
-  })
-
-  describe("Domain-Specific Naming", () => {
-    it("generates reactor names", () => {
-      expect(getReactorName("backend")).toBe("backendReactor")
-      expect(getReactorName("my-canister")).toBe("myCanisterReactor")
-    })
-
-    it("generates service type names", () => {
-      expect(getServiceTypeName("backend")).toBe("BackendService")
-      expect(getServiceTypeName("update_item")).toBe("UpdateItemService")
-    })
-
-    it("generates reactor names", () => {
-      expect(getReactorName("backend")).toBe("backendReactor")
-      expect(getReactorName("my-canister")).toBe("myCanisterReactor")
-    })
-
-    it("generates service type names", () => {
-      expect(getServiceTypeName("backend")).toBe("BackendService")
-      expect(getServiceTypeName("my-canister")).toBe("MyCanisterService")
-    })
-  })
-})

package/src/parser.ts

@@ -1,79 +0,0 @@
-/**
- * Candid Parser Utilities
- *
- * Parses Candid .did files to extract service method signatures.
- * Used by the CLI for listing methods and by advanced generators.
- */
-
-import { didToJs } from "@ic-reactor/parser"
-import fs from "node:fs"
-
-// ─────────────────────────────────────────────────────────────────────────────
-// TYPES
-// ─────────────────────────────────────────────────────────────────────────────
-
-export type MethodType = "query" | "mutation"
-
-export interface MethodInfo {
-  /** Method name as it appears in the Candid service */
-  name: string
-  /** "query" for read-only calls, "mutation" for update calls */
-  type: MethodType
-  /** True if the method takes at least one argument */
-  hasArgs: boolean
-}
-
-// ─────────────────────────────────────────────────────────────────────────────
-// PARSERS
-// ─────────────────────────────────────────────────────────────────────────────
-
-/**
- * Extract method information from raw Candid source text.
- *
- * Compiles the Candid to JS and inspects the IDL.Service definition.
- */
-export function extractMethods(didContent: string): MethodInfo[] {
-  try {
-    const jsContent = didToJs(didContent)
-
-    const methods: MethodInfo[] = []
-
-    // Find the IDL.Service({...}) body
-    const serviceMatch = /IDL\.Service\(\{([\s\S]*?)\}\)/.exec(jsContent)
-    if (!serviceMatch) return methods
-
-    const serviceBody = serviceMatch[1]
-
-    // Match each method: 'methodName': IDL.Func([args], [rets], [annotations])
-    const methodRegex =
-      /['"]([\w]+)['"]\s*:\s*IDL\.Func\(\s*\[(.*?)\],\s*\[.*?\],\s*\[(.*?)\]\)/g
-
-    let match: RegExpExecArray | null
-    while ((match = methodRegex.exec(serviceBody)) !== null) {
-      const [, name, args, annotations] = match
-      methods.push({
-        name,
-        type: annotations.includes("'query'") ? "query" : "mutation",
-        hasArgs: args.trim().length > 0,
-      })
-    }
-
-    return methods
-  } catch (error) {
-    const msg = error instanceof Error ? error.message : String(error)
-    throw new Error(`Failed to parse Candid: ${msg}`)
-  }
-}
-
-/**
- * Parse a .did file from disk and return its methods.
- *
- * @throws if the file does not exist or fails to parse
- */
-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)
-}

package/src/pipeline.test.ts

@@ -1,355 +0,0 @@
-import fs from "node:fs"
-import os from "node:os"
-import path from "node:path"
-import { afterEach, describe, expect, it } from "vitest"
-import { runCanisterPipeline } from "./pipeline.js"
-
-describe("Codegen pipeline", () => {
-  const tempDirs: string[] = []
-
-  afterEach(() => {
-    for (const dir of tempDirs) {
-      fs.rmSync(dir, { recursive: true, force: true })
-    }
-    tempDirs.length = 0
-  })
-
-  function createTempProject() {
-    const projectRoot = fs.mkdtempSync(
-      path.join(os.tmpdir(), "ic-reactor-codegen-pipeline-")
-    )
-    tempDirs.push(projectRoot)
-    return projectRoot
-  }
-
-  function writeDid(projectRoot: string, fileName: string) {
-    fs.writeFileSync(
-      path.join(projectRoot, fileName),
-      `service : {
-  greet: (text) -> (text) query;
-}`
-    )
-  }
-
-  it("uses per-canister mode to generate Reactor-based hooks", async () => {
-    const projectRoot = createTempProject()
-    writeDid(projectRoot, "workflow_engine.did")
-
-    const result = await runCanisterPipeline({
-      canisterConfig: {
-        name: "workflow_engine",
-        didFile: "workflow_engine.did",
-        mode: "Reactor",
-      },
-      projectRoot,
-      globalConfig: {
-        outDir: "src/declarations",
-        clientManagerPath: "../../clients",
-      },
-    })
-
-    expect(result.success).toBe(true)
-
-    const indexPath = path.join(
-      projectRoot,
-      "src/declarations/workflow_engine/index.generated.ts"
-    )
-    const generated = fs.readFileSync(indexPath, "utf-8")
-
-    expect(generated).toContain("new Reactor<WorkflowEngineService>")
-    expect(generated).not.toContain("new DisplayReactor<WorkflowEngineService>")
-    expect(
-      fs.readFileSync(
-        path.join(projectRoot, "src/declarations/workflow_engine/index.ts"),
-        "utf-8"
-      )
-    ).toContain('export * from "./index.generated"')
-  })
-
-  it("writes a configured canisterId into the generated reactor", async () => {
-    const projectRoot = createTempProject()
-    writeDid(projectRoot, "workflow.did")
-
-    const result = await runCanisterPipeline({
-      canisterConfig: {
-        name: "workflow",
-        didFile: "workflow.did",
-        canisterId: "yq4ns-hyaaa-aaaap-akbna-cai",
-      },
-      projectRoot,
-      globalConfig: {
-        outDir: "src/declarations",
-        clientManagerPath: "../../clients",
-      },
-    })
-
-    expect(result.success).toBe(true)
-
-    const indexPath = path.join(
-      projectRoot,
-      "src/declarations/workflow/index.generated.ts"
-    )
-    const generated = fs.readFileSync(indexPath, "utf-8")
-
-    expect(generated).toContain('canisterId: "yq4ns-hyaaa-aaaap-akbna-cai"')
-    expect(generated).toContain('name: "workflow"')
-  })
-
-  it("can generate declarations without creating reactor files", async () => {
-    const projectRoot = createTempProject()
-    writeDid(projectRoot, "backend.did")
-
-    const result = await runCanisterPipeline({
-      canisterConfig: {
-        name: "backend",
-        didFile: "backend.did",
-      },
-      projectRoot,
-      globalConfig: {
-        outDir: "src/declarations",
-        clientManagerPath: "../../clients",
-      },
-      generateReactor: false,
-    })
-
-    expect(result.success).toBe(true)
-    expect(
-      fs.existsSync(
-        path.join(
-          projectRoot,
-          "src/declarations/backend/declarations/backend.js"
-        )
-      )
-    ).toBe(true)
-    expect(
-      fs.existsSync(
-        path.join(
-          projectRoot,
-          "src/declarations/backend/declarations/backend.d.ts"
-        )
-      )
-    ).toBe(true)
-    expect(
-      fs.existsSync(
-        path.join(
-          projectRoot,
-          "src/declarations/backend/declarations/backend.did"
-        )
-      )
-    ).toBe(true)
-    expect(
-      fs.existsSync(
-        path.join(projectRoot, "src/declarations/backend/index.generated.ts")
-      )
-    ).toBe(false)
-    expect(
-      fs.existsSync(path.join(projectRoot, "src/declarations/backend/index.ts"))
-    ).toBe(false)
-    expect(
-      result.files.some((file) => file.filePath.endsWith("index.generated.ts"))
-    ).toBe(false)
-    expect(
-      result.files.some((file) => file.filePath.endsWith("index.ts"))
-    ).toBe(false)
-  })
-
-  it("leaves existing reactor files untouched when reactor generation is disabled", async () => {
-    const projectRoot = createTempProject()
-    writeDid(projectRoot, "backend.did")
-
-    const canisterOutDir = path.join(projectRoot, "src/declarations/backend")
-    fs.mkdirSync(canisterOutDir, { recursive: true })
-
-    const existingGenerated = "// existing generated reactor"
-    const existingEntry = "// existing entry wrapper"
-
-    fs.writeFileSync(
-      path.join(canisterOutDir, "index.generated.ts"),
-      existingGenerated
-    )
-    fs.writeFileSync(path.join(canisterOutDir, "index.ts"), existingEntry)
-
-    const result = await runCanisterPipeline({
-      canisterConfig: {
-        name: "backend",
-        didFile: "backend.did",
-      },
-      projectRoot,
-      globalConfig: {
-        outDir: "src/declarations",
-        clientManagerPath: "../../clients",
-      },
-      generateReactor: false,
-    })
-
-    expect(result.success).toBe(true)
-    expect(
-      fs.readFileSync(path.join(canisterOutDir, "index.generated.ts"), "utf-8")
-    ).toBe(existingGenerated)
-    expect(
-      fs.readFileSync(path.join(canisterOutDir, "index.ts"), "utf-8")
-    ).toBe(existingEntry)
-  })
-
-  it("supports a core target without generating React hooks", async () => {
-    const projectRoot = createTempProject()
-    writeDid(projectRoot, "backend.did")
-
-    const result = await runCanisterPipeline({
-      canisterConfig: {
-        name: "backend",
-        didFile: "backend.did",
-      },
-      projectRoot,
-      globalConfig: {
-        outDir: "src/declarations",
-        clientManagerPath: "../../clients",
-        target: "core",
-      },
-    })
-
-    expect(result.success).toBe(true)
-
-    const indexPath = path.join(
-      projectRoot,
-      "src/declarations/backend/index.generated.ts"
-    )
-    const generated = fs.readFileSync(indexPath, "utf-8")
-
-    expect(generated).toContain(
-      'import { DisplayReactor } from "@ic-reactor/core"'
-    )
-    expect(generated).not.toContain(
-      'import { createActorHooks } from "@ic-reactor/react"'
-    )
-    expect(generated).not.toContain("useBackendQuery")
-  })
-
-  it("does not overwrite user-modified index.ts on regenerate", async () => {
-    const projectRoot = createTempProject()
-    writeDid(projectRoot, "backend.did")
-
-    const options = {
-      canisterConfig: {
-        name: "backend",
-        didFile: "backend.did",
-      },
-      projectRoot,
-      globalConfig: {
-        outDir: "src/declarations",
-        clientManagerPath: "../../clients",
-      },
-    } as const
-
-    const first = await runCanisterPipeline(options)
-    expect(first.success).toBe(true)
-
-    const indexPath = path.join(
-      projectRoot,
-      "src/declarations/backend/index.ts"
-    )
-    fs.writeFileSync(
-      indexPath,
-      `// user custom canister file
-export const customBackendIndex = true
-`
-    )
-
-    const second = await runCanisterPipeline({
-      ...options,
-      canisterConfig: {
-        ...options.canisterConfig,
-        canisterId: "yq4ns-hyaaa-aaaap-akbna-cai",
-      },
-    })
-    expect(second.success).toBe(true)
-
-    const wrapper = fs.readFileSync(indexPath, "utf-8")
-    expect(wrapper).toContain("customBackendIndex = true")
-    const generatedImpl = fs.readFileSync(
-      path.join(projectRoot, "src/declarations/backend/index.generated.ts"),
-      "utf-8"
-    )
-    expect(generatedImpl).toContain('canisterId: "yq4ns-hyaaa-aaaap-akbna-cai"')
-    expect(second.files).toEqual(
-      expect.arrayContaining([
-        expect.objectContaining({
-          filePath: indexPath,
-          skipped: true,
-          success: true,
-        }),
-      ])
-    )
-  })
-
-  it("migrates a legacy generated index.ts to the managed wrapper", async () => {
-    const projectRoot = createTempProject()
-    writeDid(projectRoot, "backend.did")
-
-    const canisterOutDir = path.join(projectRoot, "src/declarations/backend")
-    fs.mkdirSync(canisterOutDir, { recursive: true })
-
-    const existingGeneratedIndex = `import { DisplayReactor, createActorHooks } from "@ic-reactor/react"
-import { clientManager } from "../../clients"
-import { idlFactory, type _SERVICE } from "./declarations/backend"
-
-export type BackendService = _SERVICE
-
-/**
- * Backend Reactor
- *
- * Auto-generated by @ic-reactor/codegen — do not edit.
- */
-export const backendReactor = new DisplayReactor<BackendService>({
-  clientManager,
-  idlFactory,
-  name: "backend",
-})
-
-export const {
-  useActorQuery: useBackendQuery,
-} = createActorHooks(backendReactor)
-`
-    fs.writeFileSync(
-      path.join(canisterOutDir, "index.ts"),
-      existingGeneratedIndex
-    )
-
-    const result = await runCanisterPipeline({
-      canisterConfig: {
-        name: "backend",
-        didFile: "backend.did",
-      },
-      projectRoot,
-      globalConfig: {
-        outDir: "src/declarations",
-        clientManagerPath: "../../clients",
-      },
-    })
-
-    expect(result.success).toBe(true)
-
-    const indexPath = path.join(canisterOutDir, "index.ts")
-    const entry = fs.readFileSync(indexPath, "utf-8")
-    const generated = fs.readFileSync(
-      path.join(canisterOutDir, "index.generated.ts"),
-      "utf-8"
-    )
-    expect(entry).toContain('export * from "./index.generated"')
-    expect(entry).not.toBe(existingGeneratedIndex)
-    expect(generated).toContain("new DisplayReactor<BackendService>")
-    expect(generated).toContain("useBackendMutation")
-    expect(result.files).toEqual(
-      expect.arrayContaining([
-        expect.objectContaining({
-          filePath: path.join(canisterOutDir, "index.generated.ts"),
-          success: true,
-        }),
-        expect.objectContaining({
-          filePath: indexPath,
-          success: true,
-        }),
-      ])
-    )
-  })
-})

package/src/reactor.test.ts

@@ -1,84 +0,0 @@
-import { describe, expect, it } from "vitest"
-import {
-  generateReactorEntryFile,
-  generateReactorFile,
-} from "./generators/index.js"
-
-describe("Reactor generator", () => {
-  it("keeps default behavior as DisplayReactor", () => {
-    const content = generateReactorFile({
-      canisterName: "backend",
-      didFile: "mock/backend.did",
-      clientManagerPath: "../../clients",
-    })
-
-    expect(content).toMatchSnapshot("display-reactor-index")
-    expect(content).toContain("new DisplayReactor<BackendService>")
-    expect(content).not.toContain("export const BackendReactorMode")
-  })
-
-  it("supports Reactor mode generation", () => {
-    const content = generateReactorFile({
-      canisterName: "workflow_engine",
-      didFile: "mock/workflow_engine.did",
-      reactorClass: "Reactor",
-    })
-
-    expect(content).toMatchSnapshot("reactor-index")
-    expect(content).toContain("new Reactor<WorkflowEngineService>")
-    expect(content).not.toContain("createWorkflowEngineDisplayReactor")
-  })
-
-  it("supports candid reactor subclasses", () => {
-    const content = generateReactorFile({
-      canisterName: "ledger",
-      didFile: "mock/ledger.did",
-      reactorClass: "MetadataDisplayReactor",
-    })
-
-    expect(content).toMatchSnapshot("metadata-display-reactor-index")
-    expect(content).toContain(
-      'import { createActorHooks } from "@ic-reactor/react"'
-    )
-    expect(content).toContain(
-      'import { MetadataDisplayReactor } from "@ic-reactor/candid"'
-    )
-    expect(content).toContain("new MetadataDisplayReactor<LedgerService>")
-  })
-
-  it("supports core target generation without React hooks", () => {
-    const content = generateReactorFile({
-      canisterName: "backend",
-      didFile: "mock/backend.did",
-      runtimeTarget: "core",
-      reactorClass: "DisplayReactor",
-    })
-
-    expect(content).toMatchSnapshot("core-display-reactor-index")
-    expect(content).toContain(
-      'import { DisplayReactor } from "@ic-reactor/core"'
-    )
-    expect(content).not.toContain(
-      'import { createActorHooks } from "@ic-reactor/react"'
-    )
-    expect(content).not.toContain("useBackendQuery")
-  })
-
-  it("writes a fixed canisterId when configured", () => {
-    const content = generateReactorFile({
-      canisterName: "workflow",
-      didFile: "mock/workflow.did",
-      canisterId: "yq4ns-hyaaa-aaaap-akbna-cai",
-    })
-
-    expect(content).toContain('canisterId: "yq4ns-hyaaa-aaaap-akbna-cai"')
-    expect(content).toContain('name: "workflow"')
-  })
-
-  it("generates a stable entry wrapper", () => {
-    const content = generateReactorEntryFile()
-
-    expect(content).toContain('export * from "./index.generated"')
-    expect(content).toContain("safe to customize")
-  })
-})