@pikku/core 0.11.2 → 0.12.1

package/dist/wirings/workflow/wire-workflow.d.ts

@@ -1,42 +0,0 @@
-import type { WorkflowWires } from './workflow.types.js';
-import type { GraphNodeConfig } from './graph/workflow-graph.types.js';
-/**
- * Workflow definition with DSL function
- */
-export interface WorkflowDefinitionFunc {
-    wires: WorkflowWires;
-    func: {
-        func: (...args: any[]) => any;
-    } | ((...args: any[]) => any);
-}
-/**
- * Workflow definition with graph
- */
-export interface WorkflowDefinitionGraph<T extends Record<string, GraphNodeConfig<string>> = Record<string, GraphNodeConfig<string>>> {
-    wires: WorkflowWires;
-    graph: T;
-}
-/**
- * Union type for workflow definitions
- */
-export type WorkflowDefinition<T extends Record<string, GraphNodeConfig<string>> = Record<string, GraphNodeConfig<string>>> = WorkflowDefinitionFunc | WorkflowDefinitionGraph<T>;
-/**
- * Wire a workflow with triggers.
- * Accepts either a DSL function (func) or a graph definition (graph).
- *
- * @example
- * ```typescript
- * // DSL workflow
- * wireWorkflow({
- *   wires: { http: { route: '/start', method: 'post' } },
- *   func: myWorkflowFunc,
- * })
- *
- * // Graph workflow
- * wireWorkflow({
- *   wires: { http: { route: '/graph-start', method: 'post' } },
- *   graph: myGraphWorkflow,
- * })
- * ```
- */
-export declare function wireWorkflow<T extends Record<string, GraphNodeConfig<string>>>(definition: WorkflowDefinitionFunc | WorkflowDefinitionGraph<T>): void;

package/dist/wirings/workflow/wire-workflow.js

@@ -1,53 +0,0 @@
-import { pikkuState } from '../../pikku-state.js';
-/**
- * Type guard for DSL workflow definition
- */
-function isWorkflowDefinitionFunc(def) {
-    return 'func' in def;
-}
-/**
- * Type guard for graph workflow definition
- */
-function isWorkflowDefinitionGraph(def) {
-    return 'graph' in def;
-}
-/**
- * Wire a workflow with triggers.
- * Accepts either a DSL function (func) or a graph definition (graph).
- *
- * @example
- * ```typescript
- * // DSL workflow
- * wireWorkflow({
- *   wires: { http: { route: '/start', method: 'post' } },
- *   func: myWorkflowFunc,
- * })
- *
- * // Graph workflow
- * wireWorkflow({
- *   wires: { http: { route: '/graph-start', method: 'post' } },
- *   graph: myGraphWorkflow,
- * })
- * ```
- */
-export function wireWorkflow(definition) {
-    if (isWorkflowDefinitionFunc(definition)) {
-        // DSL workflow - store wiring for later registration by inspector
-        const wirings = pikkuState(null, 'workflows', 'wirings');
-        // The wiring will be matched to the function by the inspector
-        // Store the func reference and wires
-        wirings.set(definition.func, {
-            wires: definition.wires,
-            func: definition.func,
-        });
-    }
-    else if (isWorkflowDefinitionGraph(definition)) {
-        // Graph workflow - store for registration
-        const graphWirings = pikkuState(null, 'workflows', 'graphWirings');
-        // Store the graph reference and wires
-        graphWirings.set(definition.graph, {
-            wires: definition.wires,
-            graph: definition.graph,
-        });
-    }
-}

package/dist/wirings/workflow/workflow-utils.d.ts

@@ -1,23 +0,0 @@
-import { PikkuWire, CreateWireServices, CoreSingletonServices, CoreServices, CoreUserSession } from '../../types/core.types.js';
-import { HTTPWiringMeta } from '../http/http.types.js';
-/**
- * Result of finding a workflow by HTTP wire
- */
-export interface WorkflowHttpMatch {
-    workflowName: string;
-    startNode?: string;
-}
-/**
- * Find workflow name by matching route and method against workflow wires
- */
-export declare const findWorkflowByHttpWire: (route: string, method: string) => WorkflowHttpMatch | undefined;
-/**
- * Start a workflow triggered by an HTTP wire
- * The workflow is responsible for handling the HTTP response
- */
-export declare const startWorkflowByHttpWire: (singletonServices: CoreSingletonServices, createWireServices: CreateWireServices<CoreSingletonServices, CoreServices<CoreSingletonServices>, CoreUserSession> | undefined, matchedRoute: {
-    matchedPath: any;
-    params: any;
-    route: any;
-    meta: HTTPWiringMeta;
-}, wire: PikkuWire) => Promise<void>;

package/dist/wirings/workflow/workflow-utils.js

@@ -1,66 +0,0 @@
-import { pikkuState } from '../../pikku-state.js';
-import { NotFoundError } from '../../errors/errors.js';
-import { ContextAwareRPCService } from '../rpc/rpc-runner.js';
-/**
- * Find workflow name by matching route and method against workflow wires
- */
-export const findWorkflowByHttpWire = (route, method) => {
-    const wirings = pikkuState(null, 'workflows', 'wirings');
-    const graphWirings = pikkuState(null, 'workflows', 'graphWirings');
-    // Check DSL workflow wirings
-    for (const [, wiring] of wirings) {
-        const httpWires = wiring.wires?.http;
-        if (httpWires) {
-            const matchedWire = httpWires.find((w) => w.route === route && w.method === method);
-            if (matchedWire) {
-                const meta = pikkuState(null, 'workflows', 'meta');
-                for (const [name, workflowMeta] of Object.entries(meta)) {
-                    if (workflowMeta.source !== 'graph') {
-                        const registrations = pikkuState(null, 'workflows', 'registrations');
-                        if (registrations.has(name)) {
-                            return { workflowName: name, startNode: matchedWire.startNode };
-                        }
-                    }
-                }
-            }
-        }
-    }
-    // Check graph workflow wirings
-    for (const [, wiring] of graphWirings) {
-        const httpWires = wiring.wires?.http;
-        if (httpWires) {
-            const matchedWire = httpWires.find((w) => w.route === route && w.method === method);
-            if (matchedWire) {
-                const meta = pikkuState(null, 'workflows', 'meta');
-                for (const [name, workflowMeta] of Object.entries(meta)) {
-                    if (workflowMeta.source === 'graph') {
-                        return { workflowName: name, startNode: matchedWire.startNode };
-                    }
-                }
-            }
-        }
-    }
-    return undefined;
-};
-/**
- * Start a workflow triggered by an HTTP wire
- * The workflow is responsible for handling the HTTP response
- */
-export const startWorkflowByHttpWire = async (singletonServices, createWireServices, matchedRoute, wire) => {
-    const { meta } = matchedRoute;
-    const match = findWorkflowByHttpWire(meta.route, meta.method);
-    if (!match) {
-        throw new NotFoundError(`No workflow found for route ${meta.method.toUpperCase()} ${meta.route}`);
-    }
-    const workflowService = singletonServices.workflowService;
-    if (!workflowService) {
-        throw new Error('WorkflowService not available');
-    }
-    const data = await wire.http.request.data();
-    const wireServices = createWireServices?.(singletonServices, wire);
-    const rpcService = new ContextAwareRPCService({ ...singletonServices, ...wireServices }, wire, {});
-    await workflowService.startWorkflow(match.workflowName, data, rpcService, {
-        inline: true,
-        startNode: match.startNode,
-    });
-};

package/src/wirings/forge-node/forge-node.types.ts

@@ -1,135 +0,0 @@
-/**
- * Forge node types for workflow builder visualization.
- * wireForgeNode is metadata-only - no runtime behavior.
- * The CLI extracts this via AST and generates JSON metadata.
- */
-
-/**
- * The type of forge node.
- * - trigger: Starts workflows (webhooks, schedules, events)
- * - action: Operations that do something (API calls, send email, database ops)
- * - end: Terminal nodes with no outputs (logging, notifications)
- */
-export type ForgeNodeType = 'trigger' | 'action' | 'end'
-
-/**
- * Configuration for wireForgeNode.
- * This is the input type that developers use when defining nodes.
- */
-export type CoreForgeNode = {
-  /** Unique identifier for this node */
-  name: string
-  /** Human-readable name for UI display */
-  displayName: string
-  /** Grouping category (validated against forge.node.categories in config) */
-  category: string
-  /** Node type determining behavior and outputs */
-  type: ForgeNodeType
-  /** RPC name to call when node executes (local name, Forge handles package aliasing) */
-  rpc: string
-  /** Optional description for UI */
-  description?: string
-  /** Whether to add an error output port alongside the default output */
-  errorOutput?: boolean
-  /** Optional tags for filtering/categorization */
-  tags?: string[]
-}
-
-/**
- * Metadata generated for each forge node.
- * This is the output type that the CLI generates.
- */
-export type ForgeNodeMeta = {
-  name: string
-  displayName: string
-  category: string
-  type: ForgeNodeType
-  /** RPC name (local, remapped by Forge for external packages) */
-  rpc: string
-  description?: string
-  /** Whether node has error output port */
-  errorOutput: boolean
-  /** Input schema name extracted from RPC */
-  inputSchemaName: string | null
-  /** Output schema name extracted from RPC */
-  outputSchemaName: string | null
-  tags?: string[]
-}
-
-/**
- * Record of all forge node metadata, keyed by node name.
- */
-export type ForgeNodesMeta = Record<string, ForgeNodeMeta>
-
-/**
- * No-op function for wireForgeNode.
- * This exists purely for TypeScript type checking and will be tree-shaken.
- * The CLI extracts metadata via AST parsing.
- */
-export const wireForgeNode = (_config: CoreForgeNode): void => {
-  // No-op - metadata only, extracted by CLI via AST
-}
-
-/**
- * Configuration for wireForgeCredential.
- * Declares credentials/secrets required by a Forge package.
- * Uses Zod for schema definition - converted to JSON Schema at build time.
- */
-export type CoreForgeCredential<T = unknown> = {
-  /** Unique identifier for this credential */
-  name: string
-  /** Human-readable name for UI display */
-  displayName: string
-  /** Optional description for UI */
-  description?: string
-  /** Key used with SecretService.getSecret() to retrieve the credential */
-  secretId: string
-  /** Zod schema defining the structure of the credential */
-  schema: T
-}
-
-/**
- * Metadata generated for each forge credential.
- * Schema is converted from Zod to JSON Schema at build time.
- */
-export type ForgeCredentialMeta = {
-  name: string
-  displayName: string
-  description?: string
-  secretId: string
-  /** JSON Schema (converted from Zod at build time) or zodLookup reference name */
-  schema: Record<string, unknown> | string
-}
-
-/**
- * Record of all forge credential metadata, keyed by credential name.
- */
-export type ForgeCredentialsMeta = Record<string, ForgeCredentialMeta>
-
-/**
- * No-op function for wireForgeCredential.
- * This exists purely for TypeScript type checking and will be tree-shaken.
- * The CLI extracts metadata via AST parsing.
- *
- * @example
- * ```typescript
- * import { z } from 'zod'
- *
- * const slackCredentials = z.object({
- *   botToken: z.string().describe('Bot OAuth token'),
- *   signingSecret: z.string().describe('Request signing secret')
- * })
- *
- * wireForgeCredential({
- *   name: 'slack',
- *   displayName: 'Slack Credentials',
- *   secretId: 'SLACK_CREDENTIALS',
- *   schema: slackCredentials
- * })
- * ```
- */
-export const wireForgeCredential = <T>(
-  _config: CoreForgeCredential<T>
-): void => {
-  // No-op - metadata only, extracted by CLI via AST
-}

package/src/wirings/forge-node/index.ts

@@ -1 +0,0 @@
-export * from './forge-node.types.js'

package/src/wirings/workflow/wire-workflow.ts

@@ -1,94 +0,0 @@
-import { pikkuState } from '../../pikku-state.js'
-import type { WorkflowWires } from './workflow.types.js'
-import type { GraphNodeConfig } from './graph/workflow-graph.types.js'
-
-/**
- * Workflow definition with DSL function
- */
-export interface WorkflowDefinitionFunc {
-  wires: WorkflowWires
-  func: { func: (...args: any[]) => any } | ((...args: any[]) => any)
-}
-
-/**
- * Workflow definition with graph
- */
-export interface WorkflowDefinitionGraph<
-  T extends Record<string, GraphNodeConfig<string>> = Record<
-    string,
-    GraphNodeConfig<string>
-  >,
-> {
-  wires: WorkflowWires
-  graph: T
-}
-
-/**
- * Union type for workflow definitions
- */
-export type WorkflowDefinition<
-  T extends Record<string, GraphNodeConfig<string>> = Record<
-    string,
-    GraphNodeConfig<string>
-  >,
-> = WorkflowDefinitionFunc | WorkflowDefinitionGraph<T>
-
-/**
- * Type guard for DSL workflow definition
- */
-function isWorkflowDefinitionFunc(
-  def: WorkflowDefinition
-): def is WorkflowDefinitionFunc {
-  return 'func' in def
-}
-
-/**
- * Type guard for graph workflow definition
- */
-function isWorkflowDefinitionGraph(
-  def: WorkflowDefinition
-): def is WorkflowDefinitionGraph {
-  return 'graph' in def
-}
-
-/**
- * Wire a workflow with triggers.
- * Accepts either a DSL function (func) or a graph definition (graph).
- *
- * @example
- * ```typescript
- * // DSL workflow
- * wireWorkflow({
- *   wires: { http: { route: '/start', method: 'post' } },
- *   func: myWorkflowFunc,
- * })
- *
- * // Graph workflow
- * wireWorkflow({
- *   wires: { http: { route: '/graph-start', method: 'post' } },
- *   graph: myGraphWorkflow,
- * })
- * ```
- */
-export function wireWorkflow<T extends Record<string, GraphNodeConfig<string>>>(
-  definition: WorkflowDefinitionFunc | WorkflowDefinitionGraph<T>
-): void {
-  if (isWorkflowDefinitionFunc(definition)) {
-    // DSL workflow - store wiring for later registration by inspector
-    const wirings = pikkuState(null, 'workflows', 'wirings')
-    // The wiring will be matched to the function by the inspector
-    // Store the func reference and wires
-    wirings.set(definition.func, {
-      wires: definition.wires,
-      func: definition.func,
-    })
-  } else if (isWorkflowDefinitionGraph(definition)) {
-    // Graph workflow - store for registration
-    const graphWirings = pikkuState(null, 'workflows', 'graphWirings')
-    // Store the graph reference and wires
-    graphWirings.set(definition.graph, {
-      wires: definition.wires,
-      graph: definition.graph,
-    })
-  }
-}

package/src/wirings/workflow/workflow-utils.ts

@@ -1,120 +0,0 @@
-import { pikkuState } from '../../pikku-state.js'
-import { NotFoundError } from '../../errors/errors.js'
-import {
-  PikkuWire,
-  CreateWireServices,
-  CoreSingletonServices,
-  CoreServices,
-  CoreUserSession,
-} from '../../types/core.types.js'
-import { HTTPWiringMeta } from '../http/http.types.js'
-import { ContextAwareRPCService } from '../rpc/rpc-runner.js'
-
-/**
- * Result of finding a workflow by HTTP wire
- */
-export interface WorkflowHttpMatch {
-  workflowName: string
-  startNode?: string
-}
-
-/**
- * Find workflow name by matching route and method against workflow wires
- */
-export const findWorkflowByHttpWire = (
-  route: string,
-  method: string
-): WorkflowHttpMatch | undefined => {
-  const wirings = pikkuState(null, 'workflows', 'wirings')
-  const graphWirings = pikkuState(null, 'workflows', 'graphWirings')
-
-  // Check DSL workflow wirings
-  for (const [, wiring] of wirings) {
-    const httpWires = wiring.wires?.http
-    if (httpWires) {
-      const matchedWire = httpWires.find(
-        (w) => w.route === route && w.method === method
-      )
-      if (matchedWire) {
-        const meta = pikkuState(null, 'workflows', 'meta')
-        for (const [name, workflowMeta] of Object.entries(meta)) {
-          if (workflowMeta.source !== 'graph') {
-            const registrations = pikkuState(null, 'workflows', 'registrations')
-            if (registrations.has(name)) {
-              return { workflowName: name, startNode: matchedWire.startNode }
-            }
-          }
-        }
-      }
-    }
-  }
-
-  // Check graph workflow wirings
-  for (const [, wiring] of graphWirings) {
-    const httpWires = wiring.wires?.http
-    if (httpWires) {
-      const matchedWire = httpWires.find(
-        (w) => w.route === route && w.method === method
-      )
-      if (matchedWire) {
-        const meta = pikkuState(null, 'workflows', 'meta')
-        for (const [name, workflowMeta] of Object.entries(meta)) {
-          if (workflowMeta.source === 'graph') {
-            return { workflowName: name, startNode: matchedWire.startNode }
-          }
-        }
-      }
-    }
-  }
-
-  return undefined
-}
-
-/**
- * Start a workflow triggered by an HTTP wire
- * The workflow is responsible for handling the HTTP response
- */
-export const startWorkflowByHttpWire = async (
-  singletonServices: CoreSingletonServices,
-  createWireServices:
-    | CreateWireServices<
-        CoreSingletonServices,
-        CoreServices<CoreSingletonServices>,
-        CoreUserSession
-      >
-    | undefined,
-  matchedRoute: {
-    matchedPath: any
-    params: any
-    route: any
-    meta: HTTPWiringMeta
-  },
-  wire: PikkuWire
-): Promise<void> => {
-  const { meta } = matchedRoute
-
-  const match = findWorkflowByHttpWire(meta.route, meta.method)
-  if (!match) {
-    throw new NotFoundError(
-      `No workflow found for route ${meta.method.toUpperCase()} ${meta.route}`
-    )
-  }
-
-  const workflowService = singletonServices.workflowService
-  if (!workflowService) {
-    throw new Error('WorkflowService not available')
-  }
-
-  const data = await wire.http!.request!.data()
-
-  const wireServices = createWireServices?.(singletonServices, wire)
-  const rpcService = new ContextAwareRPCService(
-    { ...singletonServices, ...wireServices },
-    wire,
-    {}
-  )
-  await workflowService.startWorkflow(match.workflowName, data, rpcService, {
-    inline: true,
-    startNode: match.startNode,
-  })
-}