@novu/framework 0.24.3-alpha.6 → 0.24.3-alpha.7

package/dist/{handler-jSdMUIfN.d.ts → handler-VweGZ1Z4.d.ts}

@@ -1,5 +1,5 @@
-import { ValidateFunction } from 'ajv';
-import { JSONSchema, FromSchema } from 'json-schema-to-ts';
+import { JSONSchema, FromSchema as FromSchema$1 } from 'json-schema-to-ts';
+import { ZodSchema, infer } from 'zod';
 
 declare enum HttpHeaderKeysEnum {
     SIGNATURE = "x-novu-signature",
@@ -42,11 +42,6 @@ type ClientOptions = {
      * The API key is used to sign the HMAC header.
      */
     apiKey?: string;
-    /**
-     * Specify a custom Novu API URL.
-     * Defaults to 'https://api.novu.co'
-     */
-    apiUrl?: string;
     /**
      * Explicitly use HMAC signature verification.
      * Setting this to `false` will enable Novu to communicate with your Bridge API
@@ -61,7 +56,9 @@ type ClientOptions = {
     strictAuthentication?: boolean;
 };
 
-type Schema = JSONSchema;
+type Schema = JSONSchema | ZodSchema;
+type JsonSchema = JSONSchema;
+type FromSchema<T extends Schema> = T extends JSONSchema ? FromSchema$1<T> : T extends ZodSchema ? infer<T> : never;
 
 declare const providerSchemas: {
     chat: {
@@ -2428,7 +2425,7 @@ declare const delayResultSchema: {
     readonly additionalProperties: false;
 };
 
-declare const digestOutputSchema: {
+declare const digestRegularOutputSchema: {
     readonly type: "object";
     readonly properties: {
         readonly amount: {
@@ -2438,10 +2435,85 @@ declare const digestOutputSchema: {
             readonly type: "string";
             readonly enum: readonly ["seconds", "minutes", "hours", "days", "weeks", "months"];
         };
+        readonly digestKey: {
+            readonly type: "string";
+        };
+        readonly lookBackWindow: {
+            readonly type: "object";
+            readonly properties: {
+                readonly amount: {
+                    readonly type: "number";
+                };
+                readonly unit: {
+                    readonly type: "string";
+                    readonly enum: readonly ["seconds", "minutes", "hours", "days", "weeks", "months"];
+                };
+            };
+            readonly required: readonly ["amount", "unit"];
+            readonly additionalProperties: false;
+        };
     };
     readonly required: readonly ["amount", "unit"];
     readonly additionalProperties: false;
 };
+declare const digestTimedOutputSchema: {
+    readonly type: "object";
+    readonly properties: {
+        readonly cron: {
+            readonly type: "string";
+        };
+        readonly digestKey: {
+            readonly type: "string";
+        };
+    };
+    readonly required: readonly ["cron"];
+    readonly additionalProperties: false;
+};
+declare const digestOutputSchema: {
+    readonly oneOf: readonly [{
+        readonly type: "object";
+        readonly properties: {
+            readonly amount: {
+                readonly type: "number";
+            };
+            readonly unit: {
+                readonly type: "string";
+                readonly enum: readonly ["seconds", "minutes", "hours", "days", "weeks", "months"];
+            };
+            readonly digestKey: {
+                readonly type: "string";
+            };
+            readonly lookBackWindow: {
+                readonly type: "object";
+                readonly properties: {
+                    readonly amount: {
+                        readonly type: "number";
+                    };
+                    readonly unit: {
+                        readonly type: "string";
+                        readonly enum: readonly ["seconds", "minutes", "hours", "days", "weeks", "months"];
+                    };
+                };
+                readonly required: readonly ["amount", "unit"];
+                readonly additionalProperties: false;
+            };
+        };
+        readonly required: readonly ["amount", "unit"];
+        readonly additionalProperties: false;
+    }, {
+        readonly type: "object";
+        readonly properties: {
+            readonly cron: {
+                readonly type: "string";
+            };
+            readonly digestKey: {
+                readonly type: "string";
+            };
+        };
+        readonly required: readonly ["cron"];
+        readonly additionalProperties: false;
+    }];
+};
 declare const digestResultSchema: {
     readonly type: "object";
     readonly properties: {
@@ -2610,12 +2682,116 @@ type Awaitable<T> = T | Promise<T>;
 
 type Skip<T> = (inputs: T) => Awaitable<boolean>;
 
-type ActionStepOptions = {
-    skip?: Skip<unknown>;
+declare const actionStepSchemas: {
+    delay: {
+        output: {
+            readonly type: "object";
+            readonly properties: {
+                readonly type: {
+                    readonly enum: readonly ["regular"];
+                    readonly default: "regular";
+                };
+                readonly amount: {
+                    readonly type: "number";
+                };
+                readonly unit: {
+                    readonly type: "string";
+                    readonly enum: readonly ["seconds", "minutes", "hours", "days", "weeks", "months"];
+                };
+            };
+            readonly required: readonly ["amount", "unit"];
+            readonly additionalProperties: false;
+        };
+        result: {
+            readonly type: "object";
+            readonly properties: {
+                readonly duration: {
+                    readonly type: "number";
+                };
+            };
+            readonly required: readonly ["duration"];
+            readonly additionalProperties: false;
+        };
+    };
+    digest: {
+        output: {
+            readonly oneOf: readonly [{
+                readonly type: "object";
+                readonly properties: {
+                    readonly amount: {
+                        readonly type: "number";
+                    };
+                    readonly unit: {
+                        readonly type: "string";
+                        readonly enum: readonly ["seconds", "minutes", "hours", "days", "weeks", "months"];
+                    };
+                    readonly digestKey: {
+                        readonly type: "string";
+                    };
+                    readonly lookBackWindow: {
+                        readonly type: "object";
+                        readonly properties: {
+                            readonly amount: {
+                                readonly type: "number";
+                            };
+                            readonly unit: {
+                                readonly type: "string";
+                                readonly enum: readonly ["seconds", "minutes", "hours", "days", "weeks", "months"];
+                            };
+                        };
+                        readonly required: readonly ["amount", "unit"];
+                        readonly additionalProperties: false;
+                    };
+                };
+                readonly required: readonly ["amount", "unit"];
+                readonly additionalProperties: false;
+            }, {
+                readonly type: "object";
+                readonly properties: {
+                    readonly cron: {
+                        readonly type: "string";
+                    };
+                    readonly digestKey: {
+                        readonly type: "string";
+                    };
+                };
+                readonly required: readonly ["cron"];
+                readonly additionalProperties: false;
+            }];
+        };
+        result: {
+            readonly type: "object";
+            readonly properties: {
+                readonly events: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "object";
+                        readonly properties: {
+                            readonly id: {
+                                readonly type: "string";
+                            };
+                            readonly time: {
+                                readonly type: "string";
+                            };
+                            readonly payload: {
+                                readonly type: "object";
+                            };
+                        };
+                        readonly required: readonly ["id", "time", "payload"];
+                        readonly additionalProperties: false;
+                    };
+                };
+            };
+            readonly required: readonly ["events"];
+            readonly additionalProperties: false;
+        };
+    };
+};
+
+type StepOptions = {
+    skip?: Skip<any>;
     inputSchema?: Schema;
-    credentials?: (input: unknown) => Promise<Record<string, unknown>>;
-    providers?: Record<string, (payload: unknown) => unknown | Promise<unknown>>;
-    preferences?: (input: unknown) => Promise<Record<string, unknown>>;
+    providers?: Record<string, (payload: any) => Awaitable<any>>;
 };
 declare enum JobStatusEnum {
     PENDING = "pending",
@@ -2643,7 +2819,19 @@ type StepContext = {
     };
 };
 type StepOutput<T_Result> = Promise<T_Result & StepContext>;
-type ActionStep<T_Outputs, T_Result> = (name: string, resolve: (inputs: any) => Awaitable<T_Outputs>, options?: ActionStepOptions) => StepOutput<T_Result>;
+type ActionStep<T_Outputs, T_Result> = <
+/**
+ * The schema for the inputs of the step.
+ */
+T_InputSchema extends Schema, 
+/**
+ * The inputs for the step.
+ */
+T_Inputs = FromSchema<T_InputSchema>>(name: string, resolve: (inputs: T_Inputs) => Awaitable<T_Outputs>, options?: {
+    skip?: Skip<T_Inputs>;
+    inputSchema?: T_InputSchema;
+    providers?: Record<string, (payload: unknown) => Awaitable<unknown>>;
+}) => StepOutput<T_Result>;
 type CustomStep = <
 /**
  * The schema for the inputs of the step.
@@ -2747,6 +2935,12 @@ type ChatOutput = FromSchema<(typeof channelStepSchemas)[ChannelStepEnum.CHAT]['
 type ChatResult = FromSchema<(typeof channelStepSchemas)[ChannelStepEnum.CHAT]['result']>;
 type InAppOutput = FromSchema<(typeof channelStepSchemas)[ChannelStepEnum.IN_APP]['output']>;
 type InAppResult = FromSchema<(typeof channelStepSchemas)[ChannelStepEnum.IN_APP]['result']>;
+type DelayOutput = FromSchema<(typeof actionStepSchemas)[ActionStepEnum.DELAY]['output']>;
+type DelayResult = FromSchema<(typeof actionStepSchemas)[ActionStepEnum.DELAY]['result']>;
+type digestRegularOutput = FromSchema<typeof digestRegularOutputSchema>;
+type digestTimedOutput = FromSchema<typeof digestTimedOutputSchema>;
+type DigestOutput = FromSchema<(typeof actionStepSchemas)[ActionStepEnum.DIGEST]['output']>;
+type DigestResult = FromSchema<(typeof actionStepSchemas)[ActionStepEnum.DIGEST]['result']>;
 /**
  * The step type.
  */
@@ -2804,35 +2998,34 @@ type WorkflowOptions<T_PayloadSchema, T_InputSchema> = {
 };
 
 type StepType = `${ChannelStepEnum | ActionStepEnum}`;
-type Validate = ValidateFunction;
 type DiscoverProviderOutput = {
     type: string;
     code: string;
-    resolve: (stepInputs: unknown) => unknown | Promise<unknown>;
+    resolve: (inputs: unknown) => Awaitable<unknown>;
     outputs: {
-        schema: Schema;
-        validate: Validate;
+        schema: JsonSchema;
+        unknownSchema: Schema;
     };
 };
 type DiscoverStepOutput = {
     stepId: string;
     type: StepType;
     inputs: {
-        schema: Schema;
-        validate: Validate;
+        schema: JsonSchema;
+        unknownSchema: Schema;
     };
     outputs: {
-        schema: Schema;
-        validate: Validate;
+        schema: JsonSchema;
+        unknownSchema: Schema;
     };
     results: {
-        schema: Schema;
-        validate: Validate;
+        schema: JsonSchema;
+        unknownSchema: Schema;
     };
     code: string;
-    resolve: (stepInputs: unknown) => unknown | Promise<unknown>;
+    resolve: (inputs: any) => Awaitable<any>;
     providers: Array<DiscoverProviderOutput>;
-    options: ActionStepOptions;
+    options: StepOptions;
 };
 type DiscoverWorkflowOutput = {
     workflowId: string;
@@ -2841,12 +3034,12 @@ type DiscoverWorkflowOutput = {
     code: string;
     steps: Array<DiscoverStepOutput>;
     data: {
-        schema: Schema;
-        validate: Validate;
+        schema: JsonSchema;
+        unknownSchema: Schema;
     };
     inputs: {
-        schema: Schema;
-        validate: Validate;
+        schema: JsonSchema;
+        unknownSchema: Schema;
     };
 };
 type DiscoverOutput = {
@@ -2898,9 +3091,7 @@ type HealthCheck = {
 
 declare class Client {
     private discoveredWorkflows;
-    private ajv;
     private templateEngine;
-    private readonly apiUrl;
     apiKey?: string;
     version: string;
     strictAuthentication: boolean;
@@ -2913,7 +3104,6 @@ declare class Client {
     private getStep;
     private getRegisteredWorkflows;
     discover(): DiscoverOutput;
-    private getHeaders;
     /**
      * Mocks data based on the given schema.
      * The `default` value in the schema is used as the base data.
@@ -2924,9 +3114,9 @@ declare class Client {
      */
     private mock;
     private validate;
-    private validateProvider;
-    private validateStep;
-    private validateEvent;
+    private throwInvalidProvider;
+    private throwInvalidStep;
+    private throwInvalidEvent;
     private executeStepFactory;
     private shouldSkip;
     executeWorkflow(event: IEvent): Promise<ExecuteOutput>;
@@ -2996,4 +3186,4 @@ declare class NovuRequestHandler<Input extends any[] = any[], Output = any> {
     private hashHmac;
 }
 
-export { type ActionStepOptions as A, Client as C, type DiscoverWorkflowOutput as D, type Execute as E, type HealthCheck as H, type IEvent as I, JobStatusEnum as J, NovuRequestHandler as N, type PushOutput as P, type ServeHandlerOptions as S, type Validate as V, type WorkflowOptions as W, type CodeResult as a, type ClientOptions as b, type StepType as c, type DiscoverProviderOutput as d, type DiscoverStepOutput as e, type DiscoverOutput as f, type ExecuteOutputMetadata as g, type ExecuteOutput as h, type SupportedFrameworkName as i, type ActionStep as j, type CustomStep as k, type ChannelStep as l, type EmailOutput as m, type EmailResult as n, type SmsOutput as o, type SmsResult as p, type PushResult as q, type ChatOutput as r, type ChatResult as s, type InAppOutput as t, type InAppResult as u, type Step as v, type Subscriber as w, type Either as x, type Awaitable as y, type ExecuteInput as z };
+export { type ActionStep as A, type DigestOutput as B, Client as C, type DiscoverWorkflowOutput as D, type Execute as E, type FromSchema as F, type DigestResult as G, type HealthCheck as H, type IEvent as I, JobStatusEnum as J, type Step as K, type Subscriber as L, type Either as M, NovuRequestHandler as N, type Awaitable as O, type PushOutput as P, type ExecuteInput as Q, type Schema as S, type WorkflowOptions as W, type ServeHandlerOptions as a, type CodeResult as b, type ClientOptions as c, type StepType as d, type DiscoverProviderOutput as e, type DiscoverStepOutput as f, type DiscoverOutput as g, type ExecuteOutputMetadata as h, type ExecuteOutput as i, type SupportedFrameworkName as j, type StepOptions as k, type CustomStep as l, type ChannelStep as m, type EmailOutput as n, type EmailResult as o, type SmsOutput as p, type SmsResult as q, type PushResult as r, type ChatOutput as s, type ChatResult as t, type InAppOutput as u, type InAppResult as v, type DelayOutput as w, type DelayResult as x, type digestRegularOutput as y, type digestTimedOutput as z };

package/dist/index.d.ts

@@ -1,7 +1,7 @@
-import { E as Execute, W as WorkflowOptions, D as DiscoverWorkflowOutput } from './handler-jSdMUIfN.js';
-export { j as ActionStep, A as ActionStepOptions, y as Awaitable, l as ChannelStep, r as ChatOutput, s as ChatResult, C as Client, b as ClientOptions, a as CodeResult, k as CustomStep, f as DiscoverOutput, d as DiscoverProviderOutput, e as DiscoverStepOutput, x as Either, m as EmailOutput, n as EmailResult, z as ExecuteInput, h as ExecuteOutput, g as ExecuteOutputMetadata, H as HealthCheck, I as IEvent, t as InAppOutput, u as InAppResult, J as JobStatusEnum, N as NovuRequestHandler, P as PushOutput, q as PushResult, S as ServeHandlerOptions, o as SmsOutput, p as SmsResult, v as Step, c as StepType, w as Subscriber, i as SupportedFrameworkName, V as Validate } from './handler-jSdMUIfN.js';
-import { Schema } from 'ajv';
-import { FromSchema } from 'json-schema-to-ts';
+import { S as Schema, F as FromSchema, E as Execute, W as WorkflowOptions, D as DiscoverWorkflowOutput } from './handler-VweGZ1Z4.js';
+export { A as ActionStep, O as Awaitable, m as ChannelStep, s as ChatOutput, t as ChatResult, C as Client, c as ClientOptions, b as CodeResult, l as CustomStep, w as DelayOutput, x as DelayResult, B as DigestOutput, G as DigestResult, g as DiscoverOutput, e as DiscoverProviderOutput, f as DiscoverStepOutput, M as Either, n as EmailOutput, o as EmailResult, Q as ExecuteInput, i as ExecuteOutput, h as ExecuteOutputMetadata, H as HealthCheck, I as IEvent, u as InAppOutput, v as InAppResult, J as JobStatusEnum, N as NovuRequestHandler, P as PushOutput, r as PushResult, a as ServeHandlerOptions, p as SmsOutput, q as SmsResult, K as Step, k as StepOptions, d as StepType, L as Subscriber, j as SupportedFrameworkName, y as digestRegularOutput, z as digestTimedOutput } from './handler-VweGZ1Z4.js';
+import 'json-schema-to-ts';
+import 'zod';
 
 /**
  * Define a new notification workflow.