@pikku/core 0.12.2 → 0.12.4

package/src/wirings/trigger/trigger-runner.ts

@@ -1,135 +0,0 @@
-import type { PikkuWire } from '../../types/core.types.js'
-import type {
-  CoreTrigger,
-  CoreTriggerSource,
-  TriggerInstance,
-} from './trigger.types.js'
-import {
-  pikkuState,
-  getSingletonServices,
-  getCreateWireServices,
-} from '../../pikku-state.js'
-import { addFunction, runPikkuFunc } from '../../function/function-runner.js'
-import { PikkuMissingMetaError } from '../../errors/errors.js'
-
-/**
- * Registers a trigger with the Pikku framework.
- * Declares a trigger name and its target pikku function.
- * Runs everywhere. Inspector extracts at build time.
- */
-export const wireTrigger = (trigger: CoreTrigger) => {
-  const meta = pikkuState(null, 'trigger', 'meta')
-  const triggerMeta = meta[trigger.name]
-  if (!triggerMeta) {
-    throw new PikkuMissingMetaError(
-      `Missing generated metadata for trigger '${trigger.name}'`
-    )
-  }
-
-  addFunction(triggerMeta.pikkuFuncId, trigger.func as any)
-
-  const triggers = pikkuState(null, 'trigger', 'triggers')
-  triggers.set(trigger.name, trigger as any)
-}
-
-/**
- * Registers a trigger source with the Pikku framework.
- * Provides the actual subscription function and input data.
- * Only imported in the trigger worker process.
- */
-export const wireTriggerSource = <TInput = unknown, TOutput = unknown>(
-  source: CoreTriggerSource<TInput, TOutput>
-) => {
-  const sourceMeta = pikkuState(null, 'trigger', 'sourceMeta')
-  const triggerSourceMeta = sourceMeta[source.name]
-  if (!triggerSourceMeta) {
-    throw new PikkuMissingMetaError(
-      `Missing generated metadata for trigger source '${source.name}'`
-    )
-  }
-
-  const triggerSources = pikkuState(null, 'trigger', 'triggerSources')
-  if (triggerSources.has(source.name)) {
-    throw new Error(`Trigger source already exists: ${source.name}`)
-  }
-  triggerSources.set(source.name, source as any)
-
-  addFunction(
-    triggerSourceMeta.pikkuFuncId,
-    source.func as any,
-    triggerSourceMeta.packageName
-  )
-}
-
-/**
- * Parameters for setting up a trigger
- */
-export type SetupTriggerParams<TInput = unknown, TOutput = unknown> = {
-  name: string
-  input?: TInput
-  onTrigger: (data: TOutput) => void | Promise<void>
-}
-
-/**
- * Sets up a registered trigger and starts listening for events.
- * Returns a TriggerInstance with a teardown function.
- *
- * @param name - The trigger name (must be registered via wireTrigger)
- * @param input - The input to pass to the trigger function
- * @param onTrigger - Callback invoked when the trigger fires
- */
-export async function setupTrigger<TInput = unknown, TOutput = unknown>({
-  name,
-  input,
-  onTrigger,
-}: SetupTriggerParams<TInput, TOutput>): Promise<TriggerInstance> {
-  const singletonServices = getSingletonServices()
-  const createWireServices = getCreateWireServices()
-  const source = pikkuState(null, 'trigger', 'triggerSources').get(name)
-  const sourceMeta = pikkuState(null, 'trigger', 'sourceMeta')[name]
-
-  if (!source) {
-    throw new Error(`Trigger source not found: ${name}`)
-  }
-  if (!sourceMeta) {
-    throw new PikkuMissingMetaError(
-      `Missing generated metadata for trigger source '${name}'`
-    )
-  }
-
-  const wire: PikkuWire = {
-    trigger: {
-      invoke: (data: unknown) => {
-        singletonServices.logger.info(`Trigger fired: ${name}`)
-        onTrigger(data as TOutput)
-      },
-    },
-  }
-
-  singletonServices.logger.info(`Setting up trigger: ${name}`)
-
-  const teardown = await runPikkuFunc('trigger', name, sourceMeta.pikkuFuncId, {
-    singletonServices,
-    createWireServices,
-    auth: false,
-    data: () => input as any,
-    wire,
-    packageName: sourceMeta.packageName || null,
-  })
-
-  return { name, teardown }
-}
-
-/**
- * Gets all registered triggers
- */
-export const getRegisteredTriggers = () => {
-  return pikkuState(null, 'trigger', 'triggers')
-}
-
-/**
- * Gets trigger metadata
- */
-export const getTriggerMeta = () => {
-  return pikkuState(null, 'trigger', 'meta')
-}

package/src/wirings/trigger/trigger.types.ts

@@ -1,178 +0,0 @@
-import type {
-  CommonWireMeta,
-  CoreSingletonServices,
-} from '../../types/core.types.js'
-import type { StandardSchemaV1 } from '@standard-schema/spec'
-import type { CoreNodeConfig } from '../node/node.types.js'
-
-/**
- * The trigger interaction object passed to trigger functions via the wire.
- * Call trigger() to fire the trigger and start a new workflow/execution.
- */
-export interface PikkuTrigger<TOutput = unknown> {
-  invoke: (data: TOutput) => void
-}
-
-/**
- * Metadata for registered triggers stored in state.
- */
-export type TriggerMeta = Record<string, CommonWireMeta & { name: string }>
-
-export type TriggerSourceMeta = Record<
-  string,
-  { name: string; pikkuFuncId: string; packageName?: string }
->
-
-/**
- * A trigger function that sets up a subscription and returns a teardown function.
- * The trigger is fired via wire.trigger.invoke(data).
- *
- * @template TInput - Input type (configuration passed when wired)
- * @template TOutput - Output type produced when trigger fires
- * @template Services - Services available to the trigger
- */
-export type CorePikkuTriggerFunction<
-  TInput = unknown,
-  TOutput = unknown,
-  Services extends CoreSingletonServices = CoreSingletonServices,
-> = (
-  services: Services,
-  input: TInput,
-  wire: { trigger: { invoke: (data: TOutput) => void } }
-) => Promise<() => void | Promise<void>>
-
-/**
- * Configuration object for creating a trigger function with metadata
- */
-export type CorePikkuTriggerFunctionConfig<
-  TInput = unknown,
-  TOutput = unknown,
-  Services extends CoreSingletonServices = CoreSingletonServices,
-  InputSchema extends StandardSchemaV1 | undefined = undefined,
-  OutputSchema extends StandardSchemaV1 | undefined = undefined,
-> = {
-  /** Optional human-readable title for the trigger */
-  title?: string
-  /** Optional description of what the trigger does */
-  description?: string
-  /** Optional tags for categorization */
-  tags?: string[]
-  /** The trigger function */
-  func: CorePikkuTriggerFunction<TInput, TOutput, Services>
-  /** Optional Zod schema for input validation */
-  input?: InputSchema
-  /** Optional Zod schema for output validation */
-  output?: OutputSchema
-  /** Optional node configuration */
-  node?: CoreNodeConfig
-}
-
-/**
- * Factory function for creating trigger functions
- * Supports both direct function and configuration object syntax
- *
- * @example
- * ```typescript
- * // Direct function syntax
- * export const redisSubscribeTrigger = pikkuTriggerFunc<
- *   { channel: string },
- *   { message: string }
- * >(async ({ redis }, { channel }, { trigger }) => {
- *   const subscriber = redis.duplicate()
- *   await subscriber.subscribe(channel, (msg) => {
- *     trigger.invoke({ message: msg })
- *   })
- *   return () => subscriber.unsubscribe()
- * })
- *
- * // Configuration object syntax with metadata
- * export const redisSubscribeTrigger = pikkuTriggerFunc({
- *   title: 'Redis Subscribe Trigger',
- *   description: 'Listens to Redis pub/sub channel',
- *   input: z.object({ channel: z.string() }),
- *   output: z.object({ message: z.string() }),
- *   func: async ({ redis }, { channel }, { trigger }) => {
- *     const subscriber = redis.duplicate()
- *     await subscriber.subscribe(channel, (msg) => {
- *       trigger.invoke({ message: msg })
- *     })
- *     return () => subscriber.unsubscribe()
- *   }
- * })
- * ```
- */
-export const pikkuTriggerFunc = <
-  TInput = unknown,
-  TOutput = unknown,
-  Services extends CoreSingletonServices = CoreSingletonServices,
-  InputSchema extends StandardSchemaV1 | undefined = undefined,
-  OutputSchema extends StandardSchemaV1 | undefined = undefined,
->(
-  triggerOrConfig:
-    | CorePikkuTriggerFunction<TInput, TOutput, Services>
-    | CorePikkuTriggerFunctionConfig<
-        TInput,
-        TOutput,
-        Services,
-        InputSchema,
-        OutputSchema
-      >
-): CorePikkuTriggerFunctionConfig<
-  TInput,
-  TOutput,
-  Services,
-  InputSchema,
-  OutputSchema
-> => {
-  if (typeof triggerOrConfig === 'function') {
-    return { func: triggerOrConfig }
-  }
-  return triggerOrConfig
-}
-
-/**
- * Core trigger definition for registration.
- *
- * @template TInput - Input type (configuration passed when wired)
- * @template TOutput - Output type
- */
-export interface CoreTrigger<PikkuFunctionConfig = any> {
-  /** Unique name for this trigger */
-  name: string
-  /** The target RPC function to invoke when the trigger fires */
-  func: PikkuFunctionConfig
-  /** Optional description */
-  description?: string
-  /** Optional tags for categorization */
-  tags?: string[]
-  /** Whether this trigger is used by a graph workflow */
-  graph?: true
-}
-
-/**
- * Represents a trigger instance with teardown capability
- */
-export interface TriggerInstance {
-  name: string
-  teardown: () => void | Promise<void>
-}
-
-/**
- * A trigger source that provides the subscription function.
- * Only imported in the trigger worker process.
- *
- * @template TInput - Input type passed to the trigger function
- * @template TOutput - Output type produced when trigger fires
- */
-export type CoreTriggerSource<TInput = unknown, TOutput = unknown> = {
-  /** Must match a wireTrigger name */
-  name: string
-  /** The trigger function config that sets up the subscription */
-  func: CorePikkuTriggerFunctionConfig<
-    TInput,
-    TOutput,
-    CoreSingletonServices,
-    StandardSchemaV1 | undefined,
-    StandardSchemaV1 | undefined
-  >
-} & (unknown extends TInput ? { input?: TInput } : { input: TInput })

package/src/wirings/variable/index.ts

@@ -1,8 +0,0 @@
-export { wireVariable } from './variable.types.js'
-export type {
-  CoreVariable,
-  VariableDefinitionMeta,
-  VariableDefinitionsMeta,
-  VariableDefinitions,
-} from './variable.types.js'
-export { validateAndBuildVariableDefinitionsMeta } from './validate-variable-definitions.js'

package/src/wirings/variable/validate-variable-definitions.test.ts

@@ -1,91 +0,0 @@
-import { describe, test } from 'node:test'
-import assert from 'node:assert'
-import { validateAndBuildVariableDefinitionsMeta } from './validate-variable-definitions.js'
-
-describe('validateAndBuildVariableDefinitionsMeta', () => {
-  test('should build meta from single definition', () => {
-    const definitions = [
-      {
-        name: 'dbUrl',
-        displayName: 'Database URL',
-        description: 'Connection string',
-        variableId: 'DB_URL',
-        sourceFile: 'a.ts',
-      },
-    ]
-    const result = validateAndBuildVariableDefinitionsMeta(
-      definitions as any,
-      new Map()
-    )
-    assert.ok(result['dbUrl'])
-    assert.strictEqual(result['dbUrl'].variableId, 'DB_URL')
-  })
-
-  test('should allow duplicate variableId with same schema', () => {
-    const schemaLookup = new Map([
-      ['schema1', { variableName: 'Schema', sourceFile: 'types.ts' }],
-    ])
-    const definitions = [
-      {
-        name: 'var1',
-        displayName: 'Var 1',
-        description: 'd',
-        variableId: 'SHARED',
-        schema: 'schema1',
-        sourceFile: 'a.ts',
-      },
-      {
-        name: 'var2',
-        displayName: 'Var 2',
-        description: 'd',
-        variableId: 'SHARED',
-        schema: 'schema1',
-        sourceFile: 'b.ts',
-      },
-    ]
-    const result = validateAndBuildVariableDefinitionsMeta(
-      definitions as any,
-      schemaLookup
-    )
-    assert.ok(result['var1'])
-    assert.ok(result['var2'])
-  })
-
-  test('should throw when duplicate variableId has different schemas', () => {
-    const schemaLookup = new Map([
-      ['schema1', { variableName: 'SchemaA', sourceFile: 'types.ts' }],
-      ['schema2', { variableName: 'SchemaB', sourceFile: 'types2.ts' }],
-    ])
-    const definitions = [
-      {
-        name: 'var1',
-        displayName: 'Var 1',
-        description: 'd',
-        variableId: 'SHARED',
-        schema: 'schema1',
-        sourceFile: 'a.ts',
-      },
-      {
-        name: 'var2',
-        displayName: 'Var 2',
-        description: 'd',
-        variableId: 'SHARED',
-        schema: 'schema2',
-        sourceFile: 'b.ts',
-      },
-    ]
-    assert.throws(
-      () =>
-        validateAndBuildVariableDefinitionsMeta(
-          definitions as any,
-          schemaLookup
-        ),
-      (err: any) => err.message.includes('different schemas')
-    )
-  })
-
-  test('should handle empty definitions', () => {
-    const result = validateAndBuildVariableDefinitionsMeta([], new Map())
-    assert.deepStrictEqual(result, {})
-  })
-})

package/src/wirings/variable/validate-variable-definitions.ts

@@ -1,69 +0,0 @@
-import type {
-  VariableDefinitions,
-  VariableDefinitionsMeta,
-} from './variable.types.js'
-
-export interface SchemaRefLike {
-  variableName: string
-  sourceFile: string
-}
-
-export function validateAndBuildVariableDefinitionsMeta(
-  definitions: VariableDefinitions,
-  schemaLookup: Map<string, SchemaRefLike>
-): VariableDefinitionsMeta {
-  const meta: VariableDefinitionsMeta = {}
-  const variableIdToDefinition: Map<string, VariableDefinitions[0]> = new Map()
-
-  for (const def of definitions) {
-    const existingDef = variableIdToDefinition.get(def.variableId)
-
-    if (existingDef) {
-      if (def.schema && existingDef.schema) {
-        const defSchemaRef = schemaLookup.get(def.schema as string)
-        const existingSchemaRef = schemaLookup.get(existingDef.schema as string)
-
-        if (defSchemaRef && existingSchemaRef) {
-          if (
-            defSchemaRef.variableName !== existingSchemaRef.variableName ||
-            defSchemaRef.sourceFile !== existingSchemaRef.sourceFile
-          ) {
-            throw new Error(
-              `Variable '${def.variableId}' is defined with different schemas.\n` +
-                `  First definition: ${existingDef.sourceFile} (schema: ${existingSchemaRef.variableName})\n` +
-                `  Second definition: ${def.sourceFile} (schema: ${defSchemaRef.variableName})\n` +
-                `Variables sharing a variableId must use the same schema.`
-            )
-          }
-        }
-      }
-
-      if (!meta[def.name]) {
-        meta[def.name] = {
-          name: def.name,
-          displayName: def.displayName,
-          description: def.description,
-          variableId: def.variableId,
-          schema: def.schema,
-          sourceFile: def.sourceFile,
-        }
-      }
-      continue
-    }
-
-    variableIdToDefinition.set(def.variableId, def)
-
-    if (!meta[def.name]) {
-      meta[def.name] = {
-        name: def.name,
-        displayName: def.displayName,
-        description: def.description,
-        variableId: def.variableId,
-        schema: def.schema,
-        sourceFile: def.sourceFile,
-      }
-    }
-  }
-
-  return meta
-}

package/src/wirings/variable/variable.types.ts

@@ -1,22 +0,0 @@
-export type CoreVariable<T = unknown> = {
-  name: string
-  displayName: string
-  description?: string
-  variableId: string
-  schema: T
-}
-
-export type VariableDefinitionMeta = {
-  name: string
-  displayName: string
-  description?: string
-  variableId: string
-  schema?: Record<string, unknown> | string
-  sourceFile?: string
-}
-
-export type VariableDefinitionsMeta = Record<string, VariableDefinitionMeta>
-
-export type VariableDefinitions = VariableDefinitionMeta[]
-
-export const wireVariable = <T>(_config: CoreVariable<T>): void => {}

package/src/wirings/workflow/dsl/index.ts

@@ -1,31 +0,0 @@
-/**
- * DSL (Domain Specific Language) workflow exports
- */
-export { addWorkflow } from './workflow-runner.js'
-
-export type {
-  WorkflowStepOptions,
-  WorkflowWireDoRPC,
-  WorkflowWireDoInline,
-  WorkflowWireSleep,
-  WorkflowWireSuspend,
-  InputSource,
-  OutputBinding,
-  RpcStepMeta,
-  SimpleCondition,
-  Condition,
-  BranchStepMeta,
-  ParallelGroupStepMeta,
-  FanoutStepMeta,
-  ReturnStepMeta,
-  InlineStepMeta,
-  SleepStepMeta,
-  CancelStepMeta,
-  SwitchCaseMeta,
-  SwitchStepMeta,
-  FilterStepMeta,
-  ArrayPredicateStepMeta,
-  WorkflowStepMeta,
-  WorkflowStepWire,
-  PikkuWorkflowWire,
-} from './workflow-dsl.types.js'