@pikku/core 0.12.107 → 0.12.112

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

@@ -1,232 +0,0 @@
-import { describe, test } from 'node:test'
-import assert from 'node:assert'
-import { validateAndBuildSecretDefinitionsMeta } from './validate-secret-definitions.js'
-
-describe('validateAndBuildSecretDefinitionsMeta', () => {
-  test('should build meta from single definition', () => {
-    const definitions = [
-      {
-        name: 'stripe',
-        displayName: 'Stripe',
-        description: 'API key',
-        secretId: 'STRIPE_KEY',
-        sourceFile: 'a.ts',
-      },
-    ]
-    const result = validateAndBuildSecretDefinitionsMeta(
-      definitions as any,
-      new Map()
-    )
-    assert.ok(result['stripe'])
-    assert.strictEqual(result['stripe'].secretId, 'STRIPE_KEY')
-    assert.strictEqual(result['stripe'].displayName, 'Stripe')
-  })
-
-  test('carries allowedHosts into the meta so the egress binding is enforced', () => {
-    const definitions = [
-      {
-        name: 'notion',
-        displayName: 'Notion',
-        secretId: 'NOTION_KEY',
-        allowedHosts: ['api.notion.com', '*.notion.com'],
-        sourceFile: 'a.ts',
-      },
-    ]
-    const result = validateAndBuildSecretDefinitionsMeta(
-      definitions as any,
-      new Map()
-    )
-    // assertSecretAllowedForHost reads allowedHosts off this meta; if it is
-    // dropped here the host binding silently permits every host.
-    assert.deepStrictEqual(result['notion']!.allowedHosts, [
-      'api.notion.com',
-      '*.notion.com',
-    ])
-  })
-
-  test('should allow duplicate secretId with same schema', () => {
-    const schemaLookup = new Map([
-      ['schema1', { variableName: 'Schema', sourceFile: 'types.ts' }],
-    ])
-    const definitions = [
-      {
-        name: 'cred1',
-        displayName: 'Cred 1',
-        description: 'd',
-        secretId: 'SHARED',
-        schema: 'schema1',
-        sourceFile: 'a.ts',
-      },
-      {
-        name: 'cred2',
-        displayName: 'Cred 2',
-        description: 'd',
-        secretId: 'SHARED',
-        schema: 'schema1',
-        sourceFile: 'b.ts',
-      },
-    ]
-    const result = validateAndBuildSecretDefinitionsMeta(
-      definitions as any,
-      schemaLookup
-    )
-    assert.ok(result['cred1'])
-    assert.ok(result['cred2'])
-  })
-
-  test('should throw when duplicate secretId has different schemas', () => {
-    const schemaLookup = new Map([
-      ['schema1', { variableName: 'SchemaA', sourceFile: 'types.ts' }],
-      ['schema2', { variableName: 'SchemaB', sourceFile: 'types2.ts' }],
-    ])
-    const definitions = [
-      {
-        name: 'cred1',
-        displayName: 'Cred 1',
-        description: 'd',
-        secretId: 'SHARED',
-        schema: 'schema1',
-        sourceFile: 'a.ts',
-      },
-      {
-        name: 'cred2',
-        displayName: 'Cred 2',
-        description: 'd',
-        secretId: 'SHARED',
-        schema: 'schema2',
-        sourceFile: 'b.ts',
-      },
-    ]
-    assert.throws(
-      () =>
-        validateAndBuildSecretDefinitionsMeta(definitions as any, schemaLookup),
-      (err: any) => err.message.includes('different schemas')
-    )
-  })
-
-  test('should throw when duplicate secretId has different oauth2 configs', () => {
-    const definitions = [
-      {
-        name: 'cred1',
-        displayName: 'C1',
-        description: 'd',
-        secretId: 'OAUTH',
-        oauth2: { provider: 'google' },
-        sourceFile: 'a.ts',
-      },
-      {
-        name: 'cred2',
-        displayName: 'C2',
-        description: 'd',
-        secretId: 'OAUTH',
-        oauth2: { provider: 'github' },
-        sourceFile: 'b.ts',
-      },
-    ]
-    assert.throws(
-      () =>
-        validateAndBuildSecretDefinitionsMeta(definitions as any, new Map()),
-      (err: any) => err.message.includes('different configurations')
-    )
-  })
-
-  test('should carry allowedHosts into the meta', () => {
-    const definitions = [
-      {
-        name: 'example-api',
-        displayName: 'Example API',
-        secretId: 'EXAMPLE_API_CREDENTIALS',
-        allowedHosts: ['api.example.com', '*.example.com'],
-        sourceFile: 'a.ts',
-      },
-    ]
-    const result = validateAndBuildSecretDefinitionsMeta(
-      definitions as any,
-      new Map()
-    )
-    assert.deepStrictEqual(result['example-api']!.allowedHosts, [
-      'api.example.com',
-      '*.example.com',
-    ])
-  })
-
-  test('should carry allowedHosts into the meta for a shared secretId', () => {
-    const definitions = [
-      {
-        name: 'cred1',
-        displayName: 'Cred 1',
-        secretId: 'SHARED',
-        allowedHosts: ['first.example.com'],
-        sourceFile: 'a.ts',
-      },
-      {
-        name: 'cred2',
-        displayName: 'Cred 2',
-        secretId: 'SHARED',
-        allowedHosts: ['second.example.com'],
-        sourceFile: 'b.ts',
-      },
-    ]
-    const result = validateAndBuildSecretDefinitionsMeta(
-      definitions as any,
-      new Map()
-    )
-    assert.deepStrictEqual(result['cred1']!.allowedHosts, ['first.example.com'])
-    assert.deepStrictEqual(result['cred2']!.allowedHosts, [
-      'second.example.com',
-    ])
-  })
-
-  test('should handle empty definitions', () => {
-    const result = validateAndBuildSecretDefinitionsMeta([], new Map())
-    assert.deepStrictEqual(result, {})
-  })
-
-  test('should not duplicate names in meta', () => {
-    const definitions = [
-      {
-        name: 'same',
-        displayName: 'Same',
-        description: 'd',
-        secretId: 'KEY1',
-        sourceFile: 'a.ts',
-      },
-      {
-        name: 'same',
-        displayName: 'Same',
-        description: 'd',
-        secretId: 'KEY2',
-        sourceFile: 'b.ts',
-      },
-    ]
-    const result = validateAndBuildSecretDefinitionsMeta(
-      definitions as any,
-      new Map()
-    )
-    assert.ok(result['same'])
-    assert.strictEqual(result['same'].secretId, 'KEY1')
-  })
-
-  test('carries optional into the meta so the deploy gate can stop blocking on it', () => {
-    const result = validateAndBuildSecretDefinitionsMeta(
-      [
-        {
-          name: 'scenarioActor',
-          displayName: 'Scenario Actor Secret',
-          secretId: 'SCENARIO_ACTOR_SECRET',
-          optional: true,
-          sourceFile: 'a.ts',
-        },
-        {
-          name: 'stripe',
-          displayName: 'Stripe',
-          secretId: 'STRIPE_KEY',
-          sourceFile: 'a.ts',
-        },
-      ] as any,
-      new Map()
-    )
-    assert.strictEqual(result['scenarioActor']!.optional, true)
-    assert.strictEqual(result['stripe']!.optional, undefined)
-  })
-})

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

@@ -1,88 +0,0 @@
-import type {
-  SecretDefinitions,
-  SecretDefinitionsMeta,
-} from './secret.types.js'
-import type { SchemaRefLike } from '../../types/core.types.js'
-
-export type { SchemaRefLike }
-
-export function validateAndBuildSecretDefinitionsMeta(
-  definitions: SecretDefinitions,
-  schemaLookup: Map<string, SchemaRefLike>
-): SecretDefinitionsMeta {
-  const meta: SecretDefinitionsMeta = {}
-  const secretIdToDefinition: Map<string, SecretDefinitions[0]> = new Map()
-
-  for (const def of definitions) {
-    const existingDef = secretIdToDefinition.get(def.secretId)
-
-    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(
-              `Secret '${def.secretId}' is defined with different schemas.\n` +
-                `  First definition: ${existingDef.sourceFile} (schema: ${existingSchemaRef.variableName})\n` +
-                `  Second definition: ${def.sourceFile} (schema: ${defSchemaRef.variableName})\n` +
-                `Credentials sharing a secretId must use the same schema.`
-            )
-          }
-        }
-      }
-
-      if (def.oauth2 && existingDef.oauth2) {
-        if (JSON.stringify(def.oauth2) !== JSON.stringify(existingDef.oauth2)) {
-          throw new Error(
-            `OAuth2 secret '${def.secretId}' is defined with different configurations.\n` +
-              `  First definition: ${existingDef.sourceFile}\n` +
-              `  Second definition: ${def.sourceFile}\n` +
-              `Credentials sharing a secretId must use the same configuration.`
-          )
-        }
-      }
-
-      if (!meta[def.name]) {
-        meta[def.name] = {
-          name: def.name,
-          displayName: def.displayName,
-          description: def.description,
-          secretId: def.secretId,
-          schema: def.schema,
-          optional: def.optional,
-          oauth2: def.oauth2,
-          rotationPeriod: def.rotationPeriod,
-          allowedHosts: def.allowedHosts,
-          docsUrl: def.docsUrl,
-          sourceFile: def.sourceFile,
-        }
-      }
-      continue
-    }
-
-    secretIdToDefinition.set(def.secretId, def)
-
-    if (!meta[def.name]) {
-      meta[def.name] = {
-        name: def.name,
-        displayName: def.displayName,
-        description: def.description,
-        secretId: def.secretId,
-        schema: def.schema,
-        optional: def.optional,
-        oauth2: def.oauth2,
-        rotationPeriod: def.rotationPeriod,
-        allowedHosts: def.allowedHosts,
-        docsUrl: def.docsUrl,
-        sourceFile: def.sourceFile,
-      }
-    }
-  }
-
-  return meta
-}

package/src/wirings/trigger/index.ts

@@ -1,9 +0,0 @@
-export { wireTrigger, wireTriggerSource } from './trigger-runner.js'
-export { PikkuTriggerService } from './pikku-trigger-service.js'
-export type {
-  TriggerMeta,
-  TriggerSourceMeta,
-  CorePikkuTriggerFunction,
-  CorePikkuTriggerFunctionConfig,
-  CoreTrigger,
-} from './trigger.types.js'

package/src/wirings/trigger/pikku-trigger-service.ts

@@ -1,107 +0,0 @@
-import { rpcService } from '../rpc/rpc-runner.js'
-import { setupTrigger } from './trigger-runner.js'
-import type { TriggerInstance } from './trigger.types.js'
-import type { TriggerService } from '../../services/trigger-service.js'
-import {
-  getSingletonServices,
-  getCreateWireServices,
-  pikkuState,
-} from '../../pikku-state.js'
-
-export type TriggerTarget = {
-  targetType: 'rpc' | 'workflow'
-  targetName: string
-  startNode?: string
-}
-
-export abstract class PikkuTriggerService implements TriggerService {
-  protected activeTriggers = new Map<string, TriggerInstance>()
-
-  abstract start(): Promise<void>
-
-  async stop(): Promise<void> {
-    const singletonServices = getSingletonServices()
-    for (const [name, instance] of this.activeTriggers) {
-      try {
-        await instance.teardown()
-        singletonServices.logger.info(`Stopped trigger: ${name}`)
-      } catch (error) {
-        singletonServices.logger.error(
-          `Error stopping trigger ${name}: ${error}`
-        )
-      }
-    }
-    this.activeTriggers.clear()
-  }
-
-  protected getTriggerTargets(): Map<string, TriggerTarget[]> {
-    const triggers = pikkuState(null, 'trigger', 'triggers')
-
-    const triggerTargets = new Map<string, TriggerTarget[]>()
-
-    for (const [name] of triggers) {
-      const meta = pikkuState(null, 'trigger', 'meta')[name]
-      if (meta) {
-        if (!triggerTargets.has(name)) {
-          triggerTargets.set(name, [])
-        }
-        triggerTargets.get(name)!.push({
-          targetType: 'rpc',
-          targetName: meta.pikkuFuncId,
-        })
-      }
-    }
-
-    return triggerTargets
-  }
-
-  protected getTriggerSources(): Map<string, { input?: unknown }> {
-    return pikkuState(null, 'trigger', 'triggerSources')
-  }
-
-  protected async setupTriggerInstance(
-    name: string,
-    input: unknown,
-    onTrigger: (data: unknown) => Promise<void>
-  ): Promise<TriggerInstance> {
-    return setupTrigger({
-      name,
-      input,
-      onTrigger,
-    })
-  }
-
-  protected async onTriggerFire(
-    triggerName: string,
-    targets: TriggerTarget[],
-    data: unknown
-  ): Promise<void> {
-    const singletonServices = getSingletonServices()
-    const createWireServices = getCreateWireServices()
-    const wireServices = await createWireServices?.(singletonServices, {})
-    const services = { ...singletonServices, ...wireServices }
-    const rpc = rpcService.getContextRPCService(services, {}, false)
-
-    for (const target of targets) {
-      try {
-        if (target.targetType === 'workflow') {
-          await rpc.startWorkflow(target.targetName, data, {
-            startNode: target.startNode,
-          })
-          singletonServices.logger.info(
-            `Trigger '${triggerName}' started workflow '${target.targetName}'`
-          )
-        } else {
-          await rpc.invoke(target.targetName, data)
-          singletonServices.logger.info(
-            `Trigger '${triggerName}' invoked RPC '${target.targetName}'`
-          )
-        }
-      } catch (error) {
-        singletonServices.logger.error(
-          `Error invoking ${target.targetType} '${target.targetName}' from trigger '${triggerName}': ${error}`
-        )
-      }
-    }
-  }
-}

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

@@ -1,78 +0,0 @@
-import { describe, test, beforeEach } from 'node:test'
-import assert from 'node:assert'
-import {
-  wireTrigger,
-  wireTriggerSource,
-  getRegisteredTriggers,
-  getTriggerMeta,
-} from './trigger-runner.js'
-import { resetPikkuState, pikkuState } from '../../pikku-state.js'
-
-beforeEach(() => {
-  resetPikkuState()
-})
-
-describe('wireTrigger', () => {
-  test('should register a trigger when meta exists', () => {
-    const meta = pikkuState(null, 'trigger', 'meta')
-    ;(meta as any)['myTrigger'] = { pikkuFuncId: 'triggerFunc' }
-
-    wireTrigger({ name: 'myTrigger', func: async () => {} } as any)
-
-    const triggers = getRegisteredTriggers()
-    assert.ok(triggers.has('myTrigger'))
-  })
-
-  test('should skip when trigger metadata not found', () => {
-    wireTrigger({ name: 'noMeta', func: async () => {} } as any)
-
-    const triggers = getRegisteredTriggers()
-    assert.ok(!triggers.has('noMeta'))
-  })
-})
-
-describe('wireTriggerSource', () => {
-  test('should register a trigger source when meta exists', () => {
-    const sourceMeta = pikkuState(null, 'trigger', 'sourceMeta')
-    ;(sourceMeta as any)['mySource'] = { pikkuFuncId: 'sourceFunc' }
-
-    wireTriggerSource({ name: 'mySource', func: async () => {} } as any)
-
-    const sources = pikkuState(null, 'trigger', 'triggerSources')
-    assert.ok(sources.has('mySource'))
-  })
-
-  test('should skip when trigger source metadata not found', () => {
-    wireTriggerSource({ name: 'noMeta', func: async () => {} } as any)
-
-    const sources = pikkuState(null, 'trigger', 'triggerSources')
-    assert.ok(!sources.has('noMeta'))
-  })
-
-  test('should throw when trigger source already exists', () => {
-    const sourceMeta = pikkuState(null, 'trigger', 'sourceMeta')
-    ;(sourceMeta as any)['dupSource'] = { pikkuFuncId: 'sourceFunc' }
-
-    wireTriggerSource({ name: 'dupSource', func: async () => {} } as any)
-
-    assert.throws(
-      () =>
-        wireTriggerSource({ name: 'dupSource', func: async () => {} } as any),
-      { message: 'Trigger source already exists: dupSource' }
-    )
-  })
-})
-
-describe('getRegisteredTriggers', () => {
-  test('should return the triggers Map', () => {
-    const triggers = getRegisteredTriggers()
-    assert.ok(triggers instanceof Map)
-  })
-})
-
-describe('getTriggerMeta', () => {
-  test('should return the trigger meta object', () => {
-    const meta = getTriggerMeta()
-    assert.ok(typeof meta === 'object')
-  })
-})

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

@@ -1,113 +0,0 @@
-import type { PikkuRawWire } 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 type { CorePikkuFunctionConfig } from '../../function/functions.types.js'
-import { PikkuMissingMetaError } from '../../errors/errors.js'
-
-export const wireTrigger = (trigger: CoreTrigger) => {
-  const meta = pikkuState(null, 'trigger', 'meta')
-  const triggerMeta = meta[trigger.name]
-  if (!triggerMeta) {
-    console.warn(
-      `[pikku] Skipping trigger '${trigger.name}' — metadata not found. Consider moving this wiring to its own file.`
-    )
-    return
-  }
-
-  addFunction(triggerMeta.pikkuFuncId, trigger.func)
-
-  const triggers = pikkuState(null, 'trigger', 'triggers')
-  triggers.set(trigger.name, trigger)
-}
-
-// knowledge: decisions/internals/trigger-declaration-is-split-from-trigger-source.md
-export const wireTriggerSource = <TInput = unknown, TOutput = unknown>(
-  source: CoreTriggerSource<TInput, TOutput>
-) => {
-  const sourceMeta = pikkuState(null, 'trigger', 'sourceMeta')
-  const triggerSourceMeta = sourceMeta[source.name]
-  if (!triggerSourceMeta) {
-    console.warn(
-      `[pikku] Skipping trigger source '${source.name}' — metadata not found. Consider moving this wiring to its own file.`
-    )
-    return
-  }
-
-  const triggerSources = pikkuState(null, 'trigger', 'triggerSources')
-  if (triggerSources.has(source.name)) {
-    throw new Error(`Trigger source already exists: ${source.name}`)
-  }
-  // knowledge: decisions/internals/wiring-registries-erase-the-generics-their-wire-functions-capture.md
-  triggerSources.set(source.name, source as CoreTriggerSource)
-
-  addFunction(
-    triggerSourceMeta.pikkuFuncId,
-    source.func as CorePikkuFunctionConfig<any, any>,
-    triggerSourceMeta.packageName
-  )
-}
-
-export type SetupTriggerParams<TInput = unknown, TOutput = unknown> = {
-  name: string
-  input?: TInput
-  onTrigger: (data: TOutput) => void | Promise<void>
-}
-
-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: PikkuRawWire = {
-    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,
-    wire,
-    packageName: sourceMeta.packageName || null,
-  })
-
-  return { name, teardown }
-}
-
-export const getRegisteredTriggers = () => {
-  return pikkuState(null, 'trigger', 'triggers')
-}
-
-export const getTriggerMeta = () => {
-  return pikkuState(null, 'trigger', 'meta')
-}