@pikku/core 0.11.1 → 0.12.0

package/dist/wirings/scheduler/scheduler-runner.js

@@ -1,22 +1,24 @@
 import { getErrorResponse, PikkuError } from '../../errors/error-handler.js';
+import { PikkuMissingMetaError } from '../../errors/errors.js';
 import { closeWireServices } from '../../utils.js';
 import { pikkuState } from '../../pikku-state.js';
 import { addFunction, runPikkuFunc } from '../../function/function-runner.js';
-import { PikkuSessionService } from '../../services/user-session-service.js';
+import { PikkuSessionService, createMiddlewareSessionWireProps, } from '../../services/user-session-service.js';
+import { rpcService } from '../rpc/rpc-runner.js';
 export const wireScheduler = (scheduledTask) => {
-    const meta = pikkuState('scheduler', 'meta');
+    const meta = pikkuState(null, 'scheduler', 'meta');
     const taskMeta = meta[scheduledTask.name];
     if (!taskMeta) {
-        throw new Error('Task metadata not found');
+        throw new PikkuMissingMetaError(`Missing generated metadata for scheduled task '${scheduledTask.name}'`);
     }
-    addFunction(taskMeta.pikkuFuncName, {
+    addFunction(taskMeta.pikkuFuncId, {
         func: scheduledTask.func.func,
         auth: scheduledTask.func.auth,
         permissions: scheduledTask.func.permissions,
         middleware: scheduledTask.func.middleware,
         tags: scheduledTask.func.tags,
     });
-    const tasks = pikkuState('scheduler', 'tasks');
+    const tasks = pikkuState(null, 'scheduler', 'tasks');
     if (tasks.has(scheduledTask.name)) {
         throw new Error(`Scheduled task already exists: ${scheduledTask.name}`);
     }
@@ -35,8 +37,8 @@ class ScheduledTaskSkippedError extends PikkuError {
 }
 export async function runScheduledTask({ name, session, singletonServices, createWireServices, }) {
     let wireServices;
-    const task = pikkuState('scheduler', 'tasks').get(name);
-    const meta = pikkuState('scheduler', 'meta')[name];
+    const task = pikkuState(null, 'scheduler', 'tasks').get(name);
+    const meta = pikkuState(null, 'scheduler', 'meta')[name];
     const userSession = new PikkuSessionService();
     if (session) {
         userSession.set(session);
@@ -57,11 +59,11 @@ export async function runScheduledTask({ name, session, singletonServices, creat
                 throw new ScheduledTaskSkippedError(name, reason);
             },
         },
-        session: userSession,
+        ...createMiddlewareSessionWireProps(userSession),
     };
     try {
         singletonServices.logger.info(`Running schedule task: ${name} | schedule: ${task.schedule}`);
-        await runPikkuFunc('scheduler', meta.name, meta.pikkuFuncName, {
+        await runPikkuFunc('scheduler', meta.name, meta.pikkuFuncId, {
             singletonServices,
             createWireServices,
             auth: false,
@@ -70,6 +72,7 @@ export async function runScheduledTask({ name, session, singletonServices, creat
             wireMiddleware: task.middleware,
             tags: task.tags,
             wire,
+            sessionService: userSession,
         });
     }
     catch (e) {
@@ -86,5 +89,20 @@ export async function runScheduledTask({ name, session, singletonServices, creat
     }
 }
 export const getScheduledTasks = () => {
-    return pikkuState('scheduler', 'tasks');
+    return pikkuState(null, 'scheduler', 'tasks');
+};
+export const createSchedulerRuntimeHandlers = ({ singletonServices, createWireServices, }) => {
+    return {
+        logger: singletonServices.logger,
+        invokeRPC: async (rpcName, data, session) => {
+            const wire = session ? { session } : {};
+            const rpc = rpcService.getContextRPCService(singletonServices, wire);
+            await rpc.invoke(rpcName, data);
+        },
+        runScheduledTask: async (name) => runScheduledTask({
+            name,
+            singletonServices,
+            createWireServices,
+        }),
+    };
 };

package/dist/wirings/secret/index.d.ts

@@ -0,0 +1,3 @@
+export { wireSecret } from './secret.types.js';
+export type { CoreSecret, OAuth2CredentialConfig, SecretDefinitionMeta, SecretDefinitionsMeta, SecretDefinitions, } from './secret.types.js';
+export { validateAndBuildSecretDefinitionsMeta } from './validate-secret-definitions.js';

package/dist/wirings/secret/index.js

@@ -0,0 +1,2 @@
+export { wireSecret } from './secret.types.js';
+export { validateAndBuildSecretDefinitionsMeta } from './validate-secret-definitions.js';

package/dist/wirings/secret/secret.types.d.ts

@@ -0,0 +1,27 @@
+export type CoreSecret<T = unknown> = {
+    name: string;
+    displayName: string;
+    description?: string;
+    secretId: string;
+    schema: T;
+};
+export type OAuth2CredentialConfig = {
+    tokenSecretId: string;
+    authorizationUrl: string;
+    tokenUrl: string;
+    scopes: string[];
+    pkce?: boolean;
+    additionalParams?: Record<string, string>;
+};
+export type SecretDefinitionMeta = {
+    name: string;
+    displayName: string;
+    description?: string;
+    secretId: string;
+    schema?: Record<string, unknown> | string;
+    oauth2?: OAuth2CredentialConfig;
+    sourceFile?: string;
+};
+export type SecretDefinitionsMeta = Record<string, SecretDefinitionMeta>;
+export type SecretDefinitions = SecretDefinitionMeta[];
+export declare const wireSecret: <T>(_config: CoreSecret<T>) => void;

package/dist/wirings/secret/secret.types.js

@@ -0,0 +1 @@
+export const wireSecret = (_config) => { };

package/dist/wirings/secret/validate-secret-definitions.d.ts

@@ -0,0 +1,6 @@
+import type { SecretDefinitions, SecretDefinitionsMeta } from './secret.types.js';
+export interface SchemaRefLike {
+    variableName: string;
+    sourceFile: string;
+}
+export declare function validateAndBuildSecretDefinitionsMeta(definitions: SecretDefinitions, schemaLookup: Map<string, SchemaRefLike>): SecretDefinitionsMeta;

package/dist/wirings/secret/validate-secret-definitions.js

@@ -0,0 +1,55 @@
+export function validateAndBuildSecretDefinitionsMeta(definitions, schemaLookup) {
+    const meta = {};
+    const secretIdToDefinition = 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);
+                const existingSchemaRef = schemaLookup.get(existingDef.schema);
+                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,
+                    oauth2: def.oauth2,
+                    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,
+                oauth2: def.oauth2,
+                sourceFile: def.sourceFile,
+            };
+        }
+    }
+    return meta;
+}

package/dist/wirings/trigger/index.d.ts

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

package/dist/wirings/trigger/index.js

@@ -0,0 +1,2 @@
+export { wireTrigger, wireTriggerSource } from './trigger-runner.js';
+export { PikkuTriggerService } from './pikku-trigger-service.js';

package/dist/wirings/trigger/pikku-trigger-service.d.ts

@@ -0,0 +1,26 @@
+import { CoreSingletonServices, CreateWireServices, CoreServices, CoreUserSession } from '../../types/core.types.js';
+import { TriggerInstance } from './trigger.types.js';
+import { TriggerService } from '../../services/trigger-service.js';
+export type TriggerTarget = {
+    targetType: 'rpc' | 'workflow';
+    targetName: string;
+    startNode?: string;
+};
+export type TriggerSourceInfo = {
+    name: string;
+    input: unknown;
+};
+export declare abstract class PikkuTriggerService implements TriggerService {
+    protected activeTriggers: Map<string, TriggerInstance>;
+    protected singletonServices?: CoreSingletonServices;
+    protected createWireServices?: CreateWireServices<CoreSingletonServices, CoreServices, CoreUserSession>;
+    setServices(singletonServices: CoreSingletonServices, createWireServices?: CreateWireServices<CoreSingletonServices, CoreServices, CoreUserSession>): void;
+    abstract start(): Promise<void>;
+    stop(): Promise<void>;
+    protected getTriggerTargets(): Map<string, TriggerTarget[]>;
+    protected getTriggerSources(): Map<string, {
+        input?: unknown;
+    }>;
+    protected setupTriggerInstance(name: string, input: unknown, onTrigger: (data: unknown) => Promise<void>): Promise<TriggerInstance>;
+    protected onTriggerFire(triggerName: string, targets: TriggerTarget[], data: unknown): Promise<void>;
+}

package/dist/wirings/trigger/pikku-trigger-service.js

@@ -0,0 +1,75 @@
+import { rpcService } from '../rpc/rpc-runner.js';
+import { setupTrigger } from './trigger-runner.js';
+import { pikkuState } from '../../pikku-state.js';
+export class PikkuTriggerService {
+    activeTriggers = new Map();
+    singletonServices;
+    createWireServices;
+    setServices(singletonServices, createWireServices) {
+        this.singletonServices = singletonServices;
+        this.createWireServices = createWireServices;
+    }
+    async stop() {
+        for (const [name, instance] of this.activeTriggers) {
+            try {
+                await instance.teardown();
+                this.singletonServices.logger.info(`Stopped trigger: ${name}`);
+            }
+            catch (error) {
+                this.singletonServices.logger.error(`Error stopping trigger ${name}: ${error}`);
+            }
+        }
+        this.activeTriggers.clear();
+    }
+    getTriggerTargets() {
+        const triggers = pikkuState(null, 'trigger', 'triggers');
+        const triggerTargets = new Map();
+        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;
+    }
+    getTriggerSources() {
+        return pikkuState(null, 'trigger', 'triggerSources');
+    }
+    async setupTriggerInstance(name, input, onTrigger) {
+        return setupTrigger({
+            name,
+            singletonServices: this.singletonServices,
+            createWireServices: this.createWireServices,
+            input,
+            onTrigger,
+        });
+    }
+    async onTriggerFire(triggerName, targets, data) {
+        const wireServices = await this.createWireServices?.(this.singletonServices, {});
+        const services = { ...this.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,
+                    });
+                    this.singletonServices.logger.info(`Trigger '${triggerName}' started workflow '${target.targetName}'`);
+                }
+                else {
+                    await rpc.invoke(target.targetName, data);
+                    this.singletonServices.logger.info(`Trigger '${triggerName}' invoked RPC '${target.targetName}'`);
+                }
+            }
+            catch (error) {
+                this.singletonServices.logger.error(`Error invoking ${target.targetType} '${target.targetName}' from trigger '${triggerName}': ${error}`);
+            }
+        }
+    }
+}

package/dist/wirings/trigger/trigger-runner.d.ts

@@ -0,0 +1,42 @@
+import { CreateWireServices, type CoreSingletonServices } from '../../types/core.types.js';
+import type { CoreTrigger, CoreTriggerSource, TriggerInstance } from './trigger.types.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 declare const wireTrigger: (trigger: CoreTrigger) => void;
+/**
+ * Registers a trigger source with the Pikku framework.
+ * Provides the actual subscription function and input data.
+ * Only imported in the trigger worker process.
+ */
+export declare const wireTriggerSource: <TInput = unknown, TOutput = unknown>(source: CoreTriggerSource<TInput, TOutput>) => void;
+/**
+ * Parameters for setting up a trigger
+ */
+export type SetupTriggerParams<TInput = unknown, TOutput = unknown> = {
+    name: string;
+    singletonServices: CoreSingletonServices;
+    createWireServices?: CreateWireServices;
+    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 singletonServices - The singleton services
+ * @param input - The input to pass to the trigger function
+ * @param onTrigger - Callback invoked when the trigger fires
+ */
+export declare function setupTrigger<TInput = unknown, TOutput = unknown>({ name, singletonServices, createWireServices, input, onTrigger, }: SetupTriggerParams<TInput, TOutput>): Promise<TriggerInstance>;
+/**
+ * Gets all registered triggers
+ */
+export declare const getRegisteredTriggers: () => Map<string, CoreTrigger<any>>;
+/**
+ * Gets trigger metadata
+ */
+export declare const getTriggerMeta: () => import("./trigger.types.js").TriggerMeta;

package/dist/wirings/trigger/trigger-runner.js

@@ -0,0 +1,85 @@
+import { pikkuState } 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) => {
+    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);
+    const triggers = pikkuState(null, 'trigger', 'triggers');
+    triggers.set(trigger.name, trigger);
+};
+/**
+ * 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 = (source) => {
+    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);
+    addFunction(triggerSourceMeta.pikkuFuncId, source.func, triggerSourceMeta.packageName);
+};
+/**
+ * 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 singletonServices - The singleton services
+ * @param input - The input to pass to the trigger function
+ * @param onTrigger - Callback invoked when the trigger fires
+ */
+export async function setupTrigger({ name, singletonServices, createWireServices, input, onTrigger, }) {
+    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 = {
+        trigger: {
+            invoke: (data) => {
+                singletonServices.logger.info(`Trigger fired: ${name}`);
+                onTrigger(data);
+            },
+        },
+    };
+    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 };
+}
+/**
+ * Gets all registered triggers
+ */
+export const getRegisteredTriggers = () => {
+    return pikkuState(null, 'trigger', 'triggers');
+};
+/**
+ * Gets trigger metadata
+ */
+export const getTriggerMeta = () => {
+    return pikkuState(null, 'trigger', 'meta');
+};

package/dist/wirings/trigger/trigger.types.d.ts

@@ -0,0 +1,130 @@
+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 declare 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>;
+/**
+ * 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/dist/wirings/trigger/trigger.types.js

@@ -0,0 +1,40 @@
+/**
+ * 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 = (triggerOrConfig) => {
+    if (typeof triggerOrConfig === 'function') {
+        return { func: triggerOrConfig };
+    }
+    return triggerOrConfig;
+};

package/dist/wirings/variable/index.d.ts

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

package/dist/wirings/variable/index.js

@@ -0,0 +1,2 @@
+export { wireVariable } from './variable.types.js';
+export { validateAndBuildVariableDefinitionsMeta } from './validate-variable-definitions.js';

package/dist/wirings/variable/validate-variable-definitions.d.ts

@@ -0,0 +1,6 @@
+import type { VariableDefinitions, VariableDefinitionsMeta } from './variable.types.js';
+export interface SchemaRefLike {
+    variableName: string;
+    sourceFile: string;
+}
+export declare function validateAndBuildVariableDefinitionsMeta(definitions: VariableDefinitions, schemaLookup: Map<string, SchemaRefLike>): VariableDefinitionsMeta;

package/dist/wirings/variable/validate-variable-definitions.js

@@ -0,0 +1,45 @@
+export function validateAndBuildVariableDefinitionsMeta(definitions, schemaLookup) {
+    const meta = {};
+    const variableIdToDefinition = 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);
+                const existingSchemaRef = schemaLookup.get(existingDef.schema);
+                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;
+}