@ic-reactor/cli 0.2.0 → 0.3.1

package/src/commands/fetch.ts

@@ -1,600 +0,0 @@
-/**
- * Fetch command
- *
- * Fetch Candid interface from a live canister and generate hooks.
- */
-
-import * as p from "@clack/prompts"
-import fs from "node:fs"
-import path from "node:path"
-import pc from "picocolors"
-import {
-  loadConfig,
-  saveConfig,
-  getProjectRoot,
-  ensureDir,
-  findConfigFile,
-  CONFIG_FILE_NAME,
-  DEFAULT_CONFIG,
-} from "../utils/config.js"
-import { formatMethodForDisplay } from "@ic-reactor/codegen"
-import {
-  generateQueryHook,
-  generateMutationHook,
-  generateInfiniteQueryHook,
-} from "../generators/index.js"
-import { getHookFileName, toCamelCase } from "@ic-reactor/codegen"
-import {
-  fetchCandidFromCanister,
-  isValidCanisterId,
-  shortenCanisterId,
-  type NetworkType,
-} from "../utils/network.js"
-import { generateDeclarations } from "@ic-reactor/codegen"
-import type { MethodInfo, HookType, CanisterConfig } from "@ic-reactor/codegen"
-import type { ReactorConfig } from "../types.js"
-
-interface FetchOptions {
-  canisterId?: string
-  network?: NetworkType
-  name?: string
-  methods?: string[]
-  all?: boolean
-}
-
-export async function fetchCommand(options: FetchOptions) {
-  console.log()
-  p.intro(pc.cyan("🌐 Fetch from Live Canister"))
-
-  const projectRoot = getProjectRoot()
-
-  // Get canister ID
-  let canisterId = options.canisterId
-
-  if (!canisterId) {
-    const input = await p.text({
-      message: "Enter canister ID",
-      placeholder: "ryjl3-tyaaa-aaaaa-aaaba-cai",
-      validate: (value) => {
-        if (!value) return "Canister ID is required"
-        if (!isValidCanisterId(value)) {
-          return "Invalid canister ID format"
-        }
-        return undefined
-      },
-    })
-
-    if (p.isCancel(input)) {
-      p.cancel("Cancelled.")
-      process.exit(0)
-    }
-
-    canisterId = input as string
-  }
-
-  // Validate canister ID
-  if (!isValidCanisterId(canisterId)) {
-    p.log.error(`Invalid canister ID: ${pc.yellow(canisterId)}`)
-    process.exit(1)
-  }
-
-  // Get network
-  let network = options.network
-
-  if (!network) {
-    const result = await p.select({
-      message: "Select network",
-      options: [
-        { value: "ic", label: "IC Mainnet", hint: "icp-api.io" },
-        { value: "local", label: "Local Replica", hint: "localhost:4943" },
-      ],
-    })
-
-    if (p.isCancel(result)) {
-      p.cancel("Cancelled.")
-      process.exit(0)
-    }
-
-    network = result as NetworkType
-  }
-
-  // Fetch Candid from canister
-  const spinner = p.spinner()
-  spinner.start(`Fetching Candid from ${shortenCanisterId(canisterId)}...`)
-
-  let candidResult
-  try {
-    candidResult = await fetchCandidFromCanister({
-      canisterId,
-      network,
-    })
-    spinner.stop(
-      `Found ${pc.green(candidResult.methods.length.toString())} methods`
-    )
-  } catch (error) {
-    spinner.stop("Failed to fetch Candid")
-    p.log.error((error as Error).message)
-    process.exit(1)
-  }
-
-  const { methods, candidSource } = candidResult
-
-  if (methods.length === 0) {
-    p.log.warn("No methods found in canister interface")
-    process.exit(0)
-  }
-
-  // Get canister name
-  let canisterName = options.name
-
-  if (!canisterName) {
-    const input = await p.text({
-      message: "Name for this canister (used in generated code)",
-      placeholder: toCamelCase(canisterId.split("-")[0]),
-      defaultValue: toCamelCase(canisterId.split("-")[0]),
-      validate: (value) => {
-        if (!value) return "Name is required"
-        if (!/^[a-zA-Z][a-zA-Z0-9_-]*$/.test(value)) {
-          return "Name must start with a letter and contain only letters, numbers, hyphens, and underscores"
-        }
-        return undefined
-      },
-    })
-
-    if (p.isCancel(input)) {
-      p.cancel("Cancelled.")
-      process.exit(0)
-    }
-
-    canisterName = input as string
-  }
-
-  // Select methods
-  let selectedMethods: MethodInfo[]
-
-  if (options.all) {
-    selectedMethods = methods
-  } else if (options.methods && options.methods.length > 0) {
-    // Parse comma-separated method names
-    const requestedMethods = options.methods
-      .flatMap((m) => m.split(","))
-      .map((m) => m.trim())
-      .filter((m) => m.length > 0)
-
-    selectedMethods = methods.filter((m) => requestedMethods.includes(m.name))
-    const notFound = requestedMethods.filter(
-      (name) => !methods.some((m) => m.name === name)
-    )
-    if (notFound.length > 0) {
-      p.log.warn(`Methods not found: ${pc.yellow(notFound.join(", "))}`)
-    }
-  } else {
-    // Interactive selection
-    const result = await p.multiselect({
-      message: "Select methods to generate hooks for",
-      options: methods.map((method) => ({
-        value: method.name,
-        label: formatMethodForDisplay(method),
-      })),
-      required: true,
-    })
-
-    if (p.isCancel(result)) {
-      p.cancel("Cancelled.")
-      process.exit(0)
-    }
-
-    selectedMethods = methods.filter((m) =>
-      (result as string[]).includes(m.name)
-    )
-  }
-
-  if (selectedMethods.length === 0) {
-    p.log.warn("No methods selected.")
-    process.exit(0)
-  }
-
-  // Prompt for hook types for query methods
-  const methodsWithHookTypes: Array<{
-    method: MethodInfo
-    hookType: HookType
-  }> = []
-
-  for (const method of selectedMethods) {
-    if (method.type === "query") {
-      const hookType = await p.select({
-        message: `Hook type for ${pc.cyan(method.name)}`,
-        options: [
-          {
-            value: "skip",
-            label: "Skip",
-            hint: "Don't generate hook for this method",
-          },
-          { value: "query", label: "Query", hint: "Standard query hook" },
-          {
-            value: "suspenseQuery",
-            label: "Suspense Query",
-            hint: "For React Suspense",
-          },
-          {
-            value: "infiniteQuery",
-            label: "Infinite Query",
-            hint: "Paginated/infinite scroll",
-          },
-          {
-            value: "suspenseInfiniteQuery",
-            label: "Suspense Infinite Query",
-            hint: "Paginated with Suspense",
-          },
-        ],
-      })
-
-      if (p.isCancel(hookType)) {
-        p.cancel("Cancelled.")
-        process.exit(0)
-      }
-
-      // Skip this method if user chose "skip"
-      if (hookType === "skip") {
-        p.log.info(`Skipping ${pc.dim(method.name)}`)
-        continue
-      }
-
-      methodsWithHookTypes.push({ method, hookType: hookType as HookType })
-    } else {
-      // For mutations, also allow skipping
-      const hookType = await p.select({
-        message: `Hook type for ${pc.yellow(method.name)} (mutation)`,
-        options: [
-          {
-            value: "mutation",
-            label: "Mutation",
-            hint: "Standard mutation hook",
-          },
-          {
-            value: "skip",
-            label: "Skip",
-            hint: "Don't generate hook for this method",
-          },
-        ],
-      })
-
-      if (p.isCancel(hookType)) {
-        p.cancel("Cancelled.")
-        process.exit(0)
-      }
-
-      if (hookType === "skip") {
-        p.log.info(`Skipping ${pc.dim(method.name)}`)
-        continue
-      }
-
-      methodsWithHookTypes.push({ method, hookType: "mutation" })
-    }
-  }
-
-  // Check if any methods were selected after skipping
-  if (methodsWithHookTypes.length === 0) {
-    p.log.warn("All methods were skipped. Nothing to generate.")
-    process.exit(0)
-  }
-
-  // Load or create config
-  let configPath = findConfigFile()
-  let config: ReactorConfig
-
-  if (!configPath) {
-    // Create default config
-    configPath = path.join(projectRoot, CONFIG_FILE_NAME)
-    config = { ...DEFAULT_CONFIG }
-    p.log.info(`Creating ${pc.yellow(CONFIG_FILE_NAME)}`)
-  } else {
-    config = loadConfig(configPath) ?? { ...DEFAULT_CONFIG }
-  }
-
-  // Add canister to config
-  const canisterConfig: CanisterConfig = {
-    didFile: `./candid/${canisterName}.did`,
-    useDisplayReactor: true,
-    canisterId: canisterId,
-  }
-
-  config.canisters[canisterName] = canisterConfig
-
-  // Generate files
-  const canisterOutDir = path.join(projectRoot, config.outDir, canisterName)
-  const hooksOutDir = path.join(canisterOutDir, "hooks")
-  const candidDir = path.join(projectRoot, "candid")
-
-  ensureDir(hooksOutDir)
-  ensureDir(candidDir)
-
-  const genSpinner = p.spinner()
-  genSpinner.start("Generating hooks...")
-
-  const generatedFiles: string[] = []
-
-  // Save the Candid source file
-  const candidPath = path.join(candidDir, `${canisterName}.did`)
-  fs.writeFileSync(candidPath, candidSource)
-  generatedFiles.push(`candid/${canisterName}.did`)
-
-  // Generate TypeScript declarations using bindgen
-  genSpinner.message("Generating TypeScript declarations...")
-  const bindgenResult = await generateDeclarations({
-    didFile: candidPath,
-    outDir: canisterOutDir,
-    canisterName,
-  })
-
-  if (bindgenResult.success) {
-    generatedFiles.push("declarations/")
-  } else {
-    p.log.warn(`Could not generate declarations: ${bindgenResult.error}`)
-    p.log.info(
-      `You can manually run: npx @icp-sdk/bindgen --input ${candidPath} --output ${canisterOutDir}/declarations`
-    )
-  }
-
-  // Generate reactor.ts
-  genSpinner.message("Generating reactor...")
-  const reactorPath = path.join(canisterOutDir, "reactor.ts")
-  const reactorContent = generateReactorFileForFetch({
-    canisterName,
-    canisterConfig,
-    config,
-    canisterId,
-    hasDeclarations: bindgenResult.success,
-  })
-  fs.writeFileSync(reactorPath, reactorContent)
-  generatedFiles.push("reactor.ts")
-
-  // Generate hooks for each method
-  for (const { method, hookType } of methodsWithHookTypes) {
-    const fileName = getHookFileName(method.name, hookType)
-    const filePath = path.join(hooksOutDir, fileName)
-
-    let content: string
-
-    switch (hookType) {
-      case "query":
-      case "suspenseQuery":
-        content = generateQueryHook({
-          canisterName,
-          method,
-          config,
-        })
-        break
-      case "infiniteQuery":
-      case "suspenseInfiniteQuery":
-        content = generateInfiniteQueryHook({
-          canisterName,
-          method,
-          config,
-        })
-        break
-      case "mutation":
-        content = generateMutationHook({
-          canisterName,
-          method,
-          config,
-        })
-        break
-    }
-
-    fs.writeFileSync(filePath, content)
-    generatedFiles.push(path.join("hooks", fileName))
-  }
-
-  // Generate index.ts barrel export
-  const indexPath = path.join(hooksOutDir, "index.ts")
-  const indexContent = generateIndexFile(methodsWithHookTypes)
-  fs.writeFileSync(indexPath, indexContent)
-  generatedFiles.push("hooks/index.ts")
-
-  // Update config with generated hooks
-  config.generatedHooks[canisterName] = [
-    ...new Set([
-      ...(config.generatedHooks[canisterName] ?? []),
-      ...selectedMethods.map((m) => m.name),
-    ]),
-  ]
-  saveConfig(config, configPath)
-
-  genSpinner.stop("Hooks generated!")
-
-  // Display results
-  console.log()
-  p.note(
-    generatedFiles.map((f) => pc.green(`✓ ${f}`)).join("\n"),
-    `Generated in ${pc.dim(path.relative(projectRoot, canisterOutDir))}`
-  )
-
-  console.log()
-  p.note(
-    `Canister ID: ${pc.cyan(canisterId)}\n` +
-      `Network: ${pc.yellow(network)}\n` +
-      `Name: ${pc.green(canisterName)}\n` +
-      `Methods: ${pc.dim(selectedMethods.map((m) => m.name).join(", "))}`,
-    "Canister Info"
-  )
-
-  p.outro(pc.green("✓ Done!"))
-}
-
-/**
- * Generate reactor file specifically for fetched canisters
- * (with canister ID hardcoded or from environment)
- */
-function generateReactorFileForFetch(options: {
-  canisterName: string
-  canisterConfig: CanisterConfig
-  config: ReactorConfig
-  canisterId: string
-  hasDeclarations: boolean
-}): string {
-  const { canisterName, canisterConfig, config, canisterId, hasDeclarations } =
-    options
-
-  const pascalName =
-    canisterName.charAt(0).toUpperCase() + canisterName.slice(1)
-  const reactorName = `${canisterName}Reactor`
-  const serviceName = `${pascalName}Service`
-  const reactorType =
-    canisterConfig.useDisplayReactor !== false ? "DisplayReactor" : "Reactor"
-
-  // Calculate relative path to client manager (canister-specific → global → default)
-  const clientManagerPath =
-    canisterConfig.clientManagerPath ??
-    config.clientManagerPath ??
-    "../../lib/client"
-
-  // Calculate relative path to declarations (use DID file name)
-  const didFileName = path.basename(canisterConfig.didFile)
-
-  // Generate different imports based on whether declarations were generated
-  if (hasDeclarations) {
-    return `/**
- * ${pascalName} Reactor
- *
- * Auto-generated by @ic-reactor/cli
- * Fetched from canister: ${canisterId}
- *
- * You can customize this file to add global configuration.
- */
-
-import { ${reactorType}, createActorHooks } from "@ic-reactor/react"
-import { clientManager } from "${clientManagerPath}"
-
-// Import generated declarations
-import { idlFactory, type _SERVICE as ${serviceName} } from "./declarations/${didFileName}"
-
-// ═══════════════════════════════════════════════════════════════════════════
-// REACTOR INSTANCE
-// ═══════════════════════════════════════════════════════════════════════════
-
-/**
- * ${pascalName} Reactor
- *
- * Canister ID: ${canisterId}
- */
-export const ${reactorName} = new ${reactorType}<${serviceName}>({
-  clientManager,
-  idlFactory,
-  canisterId: "${canisterId}",
-  name: "${canisterName}",
-})
-
-// ═══════════════════════════════════════════════════════════════════════════
-// ACTOR HOOKS
-// ═══════════════════════════════════════════════════════════════════════════
-
-/**
- * Actor hooks for ${canisterName} - use these directly or import method-specific hooks.
- */
-export const {
-  useActorQuery,
-  useActorMutation,
-  useActorSuspenseQuery,
-  useActorInfiniteQuery,
-  useActorSuspenseInfiniteQuery,
-  useActorMethod,
-} = createActorHooks(${reactorName})
-
-// ═══════════════════════════════════════════════════════════════════════════
-// RE-EXPORTS
-// ═══════════════════════════════════════════════════════════════════════════
-
-export { idlFactory }
-export type { ${serviceName} }
-`
-  }
-
-  // Fallback when declarations weren't generated
-  return `/**
- * ${pascalName} Reactor
- *
- * Auto-generated by @ic-reactor/cli
- * Fetched from canister: ${canisterId}
- *
- * You can customize this file to add global configuration.
- */
-
-import { ${reactorType}, createActorHooks } from "@ic-reactor/react"
-import { clientManager } from "${clientManagerPath}"
-
-// ═══════════════════════════════════════════════════════════════════════════
-// DECLARATIONS
-// ═══════════════════════════════════════════════════════════════════════════
-
-// TODO: Generate proper types by running:
-// npx @icp-sdk/bindgen --input ./candid/${canisterName}.did --output ./${canisterName}/declarations
-
-// For now, import just the IDL factory (you may need to create this manually)
-// import { idlFactory, type _SERVICE as ${serviceName} } from "./declarations/${didFileName}"
-
-// Fallback generic type - replace with generated types
-type ${serviceName} = Record<string, (...args: unknown[]) => Promise<unknown>>
-
-// You'll need to define idlFactory here or import from declarations
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-const idlFactory = ({ IDL }: { IDL: any }) => IDL.Service({})
-
-// ═══════════════════════════════════════════════════════════════════════════
-// REACTOR INSTANCE
-// ═══════════════════════════════════════════════════════════════════════════
-
-/**
- * ${pascalName} Reactor
- *
- * Canister ID: ${canisterId}
- */
-export const ${reactorName} = new ${reactorType}<${serviceName}>({
-  clientManager,
-  idlFactory,
-  canisterId: "${canisterId}",
-  name: "${canisterName}",
-})
-
-// ═══════════════════════════════════════════════════════════════════════════
-// ACTOR HOOKS
-// ═══════════════════════════════════════════════════════════════════════════
-
-/**
- * Actor hooks for ${canisterName} - use these directly or import method-specific hooks.
- */
-export const {
-  useActorQuery,
-  useActorMutation,
-  useActorSuspenseQuery,
-  useActorInfiniteQuery,
-  useActorSuspenseInfiniteQuery,
-  useActorMethod,
-} = createActorHooks(${reactorName})
-
-// ═══════════════════════════════════════════════════════════════════════════
-// RE-EXPORTS
-// ═══════════════════════════════════════════════════════════════════════════
-
-export { idlFactory }
-export type { ${serviceName} }
-`
-}
-
-function generateIndexFile(
-  methods: Array<{ method: MethodInfo; hookType: HookType }>
-): string {
-  const exports = methods.map(({ method, hookType }) => {
-    const fileName = getHookFileName(method.name, hookType).replace(".ts", "")
-    return `export * from "./${fileName}"`
-  })
-
-  return `/**
- * Hook barrel exports
- *
- * Auto-generated by @ic-reactor/cli
- */
-
-${exports.join("\n")}
-`
-}

package/src/generators/infiniteQuery.ts

@@ -1,34 +0,0 @@
-/**
- * Infinite Query hook generator
- *
- * Generates createInfiniteQuery-based hooks for paginated canister methods.
- */
-
-import {
-  type MethodInfo,
-  type HookType,
-  generateInfiniteQueryHook as generateInfiniteQueryHookFromCodegen,
-} from "@ic-reactor/codegen"
-import type { ReactorConfig } from "../types.js"
-
-export interface InfiniteQueryHookOptions {
-  canisterName: string
-  method: MethodInfo
-  type?: HookType
-  config: ReactorConfig // Unused
-}
-
-/**
- * Generate an infinite query hook file content
- */
-export function generateInfiniteQueryHook(
-  options: InfiniteQueryHookOptions
-): string {
-  const { canisterName, method, type } = options
-
-  return generateInfiniteQueryHookFromCodegen({
-    canisterName,
-    method,
-    type,
-  })
-}

package/src/generators/mutation.ts

@@ -1,29 +0,0 @@
-/**
- * Mutation hook generator
- *
- * Generates createMutation-based hooks for canister update methods.
- */
-
-import {
-  type MethodInfo,
-  generateMutationHook as generateMutationHookFromCodegen,
-} from "@ic-reactor/codegen"
-import type { ReactorConfig } from "../types.js"
-
-export interface MutationHookOptions {
-  canisterName: string
-  method: MethodInfo
-  config: ReactorConfig // Unused
-}
-
-/**
- * Generate a mutation hook file content
- */
-export function generateMutationHook(options: MutationHookOptions): string {
-  const { canisterName, method } = options
-
-  return generateMutationHookFromCodegen({
-    canisterName,
-    method,
-  })
-}

package/src/generators/query.ts

@@ -1,32 +0,0 @@
-/**
- * Query hook generator
- *
- * Generates createQuery-based hooks for canister query methods.
- */
-
-import {
-  type MethodInfo,
-  type HookType,
-  generateQueryHook as generateQueryHookFromCodegen,
-} from "@ic-reactor/codegen"
-import type { ReactorConfig } from "../types.js"
-
-export interface QueryHookOptions {
-  canisterName: string
-  method: MethodInfo
-  config: ReactorConfig // Not used by codegen but kept for CLI consistency if needed
-  type?: HookType
-}
-
-/**
- * Generate a query hook file content
- */
-export function generateQueryHook(options: QueryHookOptions): string {
-  const { canisterName, method, type } = options
-
-  return generateQueryHookFromCodegen({
-    canisterName,
-    method,
-    type,
-  })
-}