@novu/framework 2.10.0 → 2.10.1-alpha.0

package/dist/cjs/{health-check.types-DwKatX-8.d.cts → health-check.types-Nhsa_lGZ.d.cts}

@@ -1,4 +1,4 @@
-import { a as ContextPayload, b as ConditionalPartial, P as PickRequiredKeys, c as Step, d as Prettify, S as Subscriber, C as ContextResolved, D as DeepPartial$1, e as ChannelStepEnum, A as ActionStepEnum, f as Awaitable, W as WithPassthrough, g as StepOptions } from './subscriber.types-CftO3aFY.cjs';
+import { b as ContextPayload, c as ConditionalPartial, P as PickRequiredKeys, d as Step, e as Prettify, S as Subscriber, E as EnvironmentSystemVariables, C as ContextResolved, D as DeepPartial$1, f as ChannelStepEnum, A as ActionStepEnum, g as Awaitable, W as WithPassthrough, h as StepOptions } from './subscriber.types-CNLicO8m.cjs';
 import { S as Schema, J as JsonSchema } from './base.schema.types-BApIn9jr.cjs';
 
 type CodeResult = {
@@ -39,7 +39,8 @@ type ClientOptions = {
 declare enum PostActionEnum {
     TRIGGER = "trigger",
     EXECUTE = "execute",
-    PREVIEW = "preview"
+    PREVIEW = "preview",
+    AGENT_EVENT = "agent-event"
 }
 declare enum GetActionEnum {
     DISCOVER = "discover",
@@ -387,15 +388,22 @@ declare enum SeverityLevelEnum {
 /**
  * The parameters for the workflow function.
  */
-type ExecuteInput<T_Payload extends Record<string, unknown>, T_Controls extends Record<string, unknown>> = {
+type ExecuteInput<T_Payload extends Record<string, unknown>, T_Controls extends Record<string, unknown>, T_Env extends Record<string, unknown> = Record<string, unknown>> = {
     /** Define a step in your workflow. */
     step: Step;
     /** The payload for the event, provided during trigger. */
     payload: T_Payload;
     /** The subscriber for the event, provided during trigger. */
     subscriber: Prettify<Subscriber>;
-    /** The environment the workflow is running in. */
-    environment: Record<string, unknown>;
+    /**
+     * Environment variables defined in the Novu Dashboard, merged with built-in
+     * environment system variables (`name`, `type`).
+     *
+     * @example `env.name` — name of the current Novu environment
+     * @example `env.type` — type of the current Novu environment ("dev" | "prod")
+     * @example `env.MY_SECRET` — a user-defined environment variable
+     */
+    env: T_Env & EnvironmentSystemVariables;
     /** The controls for the event. Provided via the Dashboard. */
     controls: T_Controls;
     /** The resolved context for the event. */
@@ -404,7 +412,7 @@ type ExecuteInput<T_Payload extends Record<string, unknown>, T_Controls extends
 /**
  * The function to execute the workflow.
  */
-type Execute<T_Payload extends Record<string, unknown>, T_Controls extends Record<string, unknown>> = (event: ExecuteInput<T_Payload, T_Controls>) => Promise<void>;
+type Execute<T_Payload extends Record<string, unknown>, T_Controls extends Record<string, unknown>, T_Env extends Record<string, unknown> = Record<string, unknown>> = (event: ExecuteInput<T_Payload, T_Controls, T_Env>) => Promise<void>;
 /**
  * A preference for a notification delivery workflow.
  *
@@ -461,11 +469,13 @@ type WorkflowPreferences = DeepPartial$1<{
 /**
  * The options for the workflow.
  */
-type WorkflowOptions<T_PayloadSchema extends Schema, T_ControlSchema extends Schema> = {
+type WorkflowOptions<T_PayloadSchema extends Schema, T_ControlSchema extends Schema, T_EnvSchema extends Schema = Schema> = {
     /** The schema for the payload. */
     payloadSchema?: T_PayloadSchema;
     /** The schema for the controls. */
     controlSchema?: T_ControlSchema;
+    /** The schema for the environment variables. */
+    envSchema?: T_EnvSchema;
     /**
      * The preferences for the notification workflow.
      *
@@ -597,6 +607,10 @@ type DiscoverWorkflowOutput = {
         schema: JsonSchema;
         unknownSchema: Schema;
     };
+    env: {
+        schema: JsonSchema;
+        unknownSchema: Schema;
+    };
     preferences: WorkflowPreferencesPartial;
     tags: string[];
     name?: string;
@@ -629,8 +643,12 @@ type Workflow<T_Payload = never> = {
      */
     discover: () => Promise<DiscoverWorkflowOutput>;
 };
+type DiscoverAgentOutput = {
+    agentId: string;
+};
 type DiscoverOutput = {
     workflows: Array<DiscoverWorkflowOutput>;
+    agents: Array<DiscoverAgentOutput>;
 };
 
 type Event = {
@@ -642,7 +660,8 @@ type Event = {
     action: Exclude<PostActionEnum, PostActionEnum.TRIGGER>;
     subscriber: Subscriber;
     context: ContextResolved;
-    env?: Record<string, string>;
+    /** User-defined env vars merged with environment system variables (name, type). */
+    env: EnvironmentSystemVariables & Record<string, string>;
 };
 type State = {
     stepId: string;
@@ -680,4 +699,4 @@ type HealthCheck = {
     };
 };
 
-export { type ClientOptions as C, type DiscoverOutput as D, type ExecuteInput as E, GetActionEnum as G, type HealthCheck as H, PostActionEnum as P, SeverityLevelEnum as S, type Workflow as W, CronExpression as a, type CancelEventTriggerResponse as b, type ChannelPreference as c, type CodeResult as d, type DiscoverProviderOutput as e, type DiscoverStepOutput as f, type DiscoverWorkflowOutput as g, type Event as h, type EventTriggerParams as i, type EventTriggerResponse as j, type EventTriggerResult as k, type Execute as l, type ExecuteOutput as m, type ExecuteOutputMetadata as n, type ExecuteOutputOptions as o, type State as p, type StepType as q, WorkflowChannelEnum as r, type WorkflowOptions as s, type WorkflowPreference as t, type WorkflowPreferences as u };
+export { type ClientOptions as C, type DiscoverAgentOutput as D, type ExecuteInput as E, GetActionEnum as G, type HealthCheck as H, PostActionEnum as P, SeverityLevelEnum as S, type Workflow as W, CronExpression as a, type CancelEventTriggerResponse as b, type ChannelPreference as c, type CodeResult as d, type DiscoverOutput as e, type DiscoverProviderOutput as f, type DiscoverStepOutput as g, type DiscoverWorkflowOutput as h, type Event as i, type EventTriggerParams as j, type EventTriggerResponse as k, type EventTriggerResult as l, type Execute as m, type ExecuteOutput as n, type ExecuteOutputMetadata as o, type ExecuteOutputOptions as p, type State as q, type StepType as r, WorkflowChannelEnum as s, type WorkflowOptions as t, type WorkflowPreference as u, type WorkflowPreferences as v };

package/dist/cjs/index-naFCU9MB.d.cts

@@ -0,0 +1,268 @@
+import { ChatElement } from 'chat';
+import { C as ClientOptions, W as Workflow, H as HealthCheck, e as DiscoverOutput, i as Event, n as ExecuteOutput, d as CodeResult, j as EventTriggerParams, m as Execute, t as WorkflowOptions } from './health-check.types-Nhsa_lGZ.cjs';
+import { g as Awaitable } from './subscriber.types-CNLicO8m.cjs';
+import { S as Schema, a as FromSchema, F as FromSchemaUnvalidated } from './base.schema.types-BApIn9jr.cjs';
+import './step-resolver.cjs';
+
+interface AgentMessageAuthor {
+    userId: string;
+    fullName: string;
+    userName: string;
+    isBot: boolean | 'unknown';
+}
+interface AgentMessage {
+    text: string;
+    platformMessageId: string;
+    author: AgentMessageAuthor;
+    timestamp: string;
+}
+interface AgentConversation {
+    identifier: string;
+    status: string;
+    metadata: Record<string, unknown>;
+    messageCount: number;
+    createdAt: string;
+    lastActivityAt: string;
+}
+interface AgentSubscriber {
+    subscriberId: string;
+    firstName?: string;
+    lastName?: string;
+    email?: string;
+    phone?: string;
+    avatar?: string;
+    locale?: string;
+    data?: Record<string, unknown>;
+}
+interface AgentHistoryEntry {
+    role: string;
+    type: string;
+    content: string;
+    senderName?: string;
+    signalData?: {
+        type: string;
+        payload?: Record<string, unknown>;
+    };
+    createdAt: string;
+}
+interface AgentPlatformContext {
+    threadId: string;
+    channelId: string;
+    isDM: boolean;
+}
+interface FileRef {
+    filename: string;
+    mimeType?: string;
+    /** Base64-encoded file data (< 1 MB decoded) */
+    data?: string;
+    /** Publicly-accessible HTTPS URL */
+    url?: string;
+}
+/**
+ * Content accepted by ctx.reply() and ctx.update().
+ *
+ * - `string` — plain text
+ * - `{ markdown, files? }` — markdown-formatted text, optionally with file attachments
+ * - `ChatElement` — interactive card built with Card(), Button(), etc.
+ *   (must be a CardElement at runtime; validated by serializeContent)
+ */
+type MessageContent = string | {
+    markdown: string;
+    files?: FileRef[];
+} | ChatElement;
+interface AgentAction {
+    actionId: string;
+    value?: string;
+}
+interface AgentReaction {
+    messageId: string;
+    emoji: {
+        name: string;
+    };
+    added: boolean;
+    message: AgentMessage | null;
+}
+interface AgentContext {
+    readonly event: string;
+    readonly action: AgentAction | null;
+    readonly message: AgentMessage | null;
+    readonly reaction: AgentReaction | null;
+    readonly conversation: AgentConversation;
+    readonly subscriber: AgentSubscriber | null;
+    readonly history: AgentHistoryEntry[];
+    readonly platform: string;
+    readonly platformContext: AgentPlatformContext;
+    reply(content: MessageContent): Promise<void>;
+    update(content: MessageContent): Promise<void>;
+    resolve(summary?: string): void;
+    metadata: {
+        set(key: string, value: unknown): void;
+    };
+    trigger(workflowId: string, opts?: {
+        to?: string;
+        payload?: Record<string, unknown>;
+    }): void;
+}
+interface AgentHandlers {
+    onMessage: (ctx: AgentContext) => Promise<void>;
+    onReaction?: (ctx: AgentContext) => Promise<void>;
+    onAction?: (ctx: AgentContext) => Promise<void>;
+    onResolve?: (ctx: AgentContext) => Promise<void>;
+}
+interface Agent {
+    id: string;
+    handlers: AgentHandlers;
+}
+
+/**
+ * Define a new conversational agent.
+ *
+ * @param agentId - Unique identifier matching the agent entity created in Novu (e.g. 'wine-bot')
+ * @param handlers - Handler functions for agent events
+ */
+declare function agent(agentId: string, handlers: AgentHandlers): Agent;
+
+declare class Client {
+    private discoveredWorkflows;
+    private discoverWorkflowPromises;
+    private registeredAgents;
+    private templateEngine;
+    secretKey: string;
+    apiUrl: string;
+    version: string;
+    strictAuthentication: boolean;
+    verbose: boolean;
+    constructor(options?: ClientOptions);
+    private buildOptions;
+    private log;
+    /**
+     * Adds workflows to the client.
+     *
+     * A locking mechanism is used to ensure that duplicate workflows are not added.
+     *
+     * @param workflows - The workflows to add.
+     */
+    addWorkflows(workflows: Array<Workflow>): Promise<void>;
+    addAgents(agents: Array<Agent>): void;
+    getAgent(agentId: string): Agent | undefined;
+    private addWorkflow;
+    healthCheck(): HealthCheck;
+    private getWorkflow;
+    private getStep;
+    private getRegisteredWorkflows;
+    discover(): DiscoverOutput;
+    /**
+     * Mocks data based on the given schema.
+     * The `default` value in the schema is used as the base data.
+     * If no `default` value is provided, the data is generated using JSONSchemaFaker.
+     *
+     * @param schema
+     * @returns mocked data
+     */
+    private mock;
+    private validate;
+    private throwInvalidProvider;
+    private throwInvalidStep;
+    private throwInvalidEvent;
+    private executeStepFactory;
+    private shouldSanitize;
+    private shouldSkip;
+    executeWorkflow(event: Event): Promise<ExecuteOutput>;
+    private createExecutionPayload;
+    private prettyPrintExecute;
+    private executeProviders;
+    private previewProvider;
+    private executeProvider;
+    private executeStep;
+    private compileControls;
+    /**
+     * Preprocesses standalone translation patterns.
+     * Transforms {{t.key}} to [T:key] placeholder (not Liquid syntax, passes through unchanged).
+     */
+    private preprocessTranslationPatterns;
+    /**
+     * Preprocesses translation keys used as filter arguments.
+     * Transforms 't.key' to '[T:key]' placeholder (not Liquid syntax, passes through unchanged).
+     * Example: pluralize: 't.apple', 't.apples' → pluralize: '[T:apple]', '[T:apples]'
+     */
+    private preprocessFilterTranslationArgs;
+    /**
+     * Post-processes placeholders back to translation markers after Liquid render.
+     * Transforms [T:key] back to {{t.key}} for the translation service.
+     */
+    private postprocessTranslationMarkers;
+    /**
+     * Create the controls for a step, taking both the event controls and the default controls into account
+     *
+     * @param step The step to create the controls for
+     * @param event The event that triggered the step
+     * @returns The controls for the step
+     */
+    private createStepControls;
+    private previewStep;
+    private constructStepForPreview;
+    private extractMockDataForPreviousSteps;
+    private previewRequiredStep;
+    private getStepState;
+    private getStepCode;
+    private getWorkflowCode;
+    getCode(workflowId: string, stepId?: string): CodeResult;
+}
+
+interface ServeHandlerOptions {
+    client?: Client;
+    workflows?: Array<Workflow>;
+    agents?: Array<Agent>;
+}
+type INovuRequestHandlerOptions<Input extends any[] = any[], Output = any> = ServeHandlerOptions & {
+    frameworkName: string;
+    client?: Client;
+    workflows?: Array<Workflow>;
+    agents?: Array<Agent>;
+    handler: Handler<Input, Output>;
+};
+type Handler<Input extends any[] = any[], Output = any> = (...args: Input) => HandlerResponse<Output>;
+type HandlerResponse<Output = any> = {
+    body: () => Awaitable<any>;
+    headers: (key: string) => Awaitable<string | null | undefined>;
+    method: () => Awaitable<string>;
+    queryString?: (key: string, url: URL) => Awaitable<string | null | undefined>;
+    url: () => Awaitable<URL>;
+    transformResponse: (res: IActionResponse<string>) => Output;
+    waitUntil?: (promise: Promise<unknown>) => void;
+};
+type IActionResponse<TBody extends string = string> = {
+    status: number;
+    headers: Record<string, string>;
+    body: TBody;
+};
+declare class NovuRequestHandler<Input extends any[] = any[], Output = any> {
+    readonly frameworkName: string;
+    readonly handler: Handler<Input, Output>;
+    readonly client: Client;
+    private readonly hmacEnabled;
+    private readonly http;
+    private readonly workflows;
+    private readonly agents;
+    constructor(options: INovuRequestHandlerOptions<Input, Output>);
+    createHandler(): (...args: Input) => Promise<Output>;
+    private getStaticHeaders;
+    private createResponse;
+    private createError;
+    private handleAction;
+    private getPostActionMap;
+    triggerAction(triggerEvent: EventTriggerParams): () => Promise<IActionResponse<string>>;
+    private getGetActionMap;
+    private handlePostAction;
+    private handleGetAction;
+    private runAgentHandler;
+    private handleError;
+    private validateHmac;
+}
+
+/**
+ * Define a new notification workflow.
+ */
+declare function workflow<T_PayloadSchema extends Schema, T_ControlSchema extends Schema, T_EnvSchema extends Schema, T_PayloadValidated extends Record<string, unknown> = FromSchema<T_PayloadSchema>, T_PayloadUnvalidated extends Record<string, unknown> = FromSchemaUnvalidated<T_PayloadSchema>, T_Controls extends Record<string, unknown> = FromSchema<T_ControlSchema>, T_Env extends Record<string, unknown> = FromSchema<T_EnvSchema>>(workflowId: string, execute: Execute<T_PayloadValidated, T_Controls, T_Env>, workflowOptions?: WorkflowOptions<T_PayloadSchema, T_ControlSchema, T_EnvSchema>): Workflow<T_PayloadUnvalidated>;
+
+export { type Agent as A, Client as C, type FileRef as F, type INovuRequestHandlerOptions as I, type MessageContent as M, NovuRequestHandler as N, type ServeHandlerOptions as S, type AgentContext as a, type AgentHandlers as b, type AgentReaction as c, agent as d, workflow as w };