@novu/api 0.0.1-alpha.11 → 0.0.1-alpha.114

package/src/lib/retries.ts

@@ -26,23 +26,44 @@ export type RetryConfig =
       retryConnectionErrors?: boolean;
     };
 
-class PermanentError extends Error {
-  inner: unknown;
+/**
+ * PermanentError is an error that is not recoverable. Throwing this error will
+ * cause a retry loop to terminate.
+ */
+export class PermanentError extends Error {
+  /** The underlying cause of the error. */
+  override readonly cause: unknown;
+
+  constructor(message: string, options?: { cause?: unknown }) {
+    let msg = message;
+    if (options?.cause) {
+      msg += `: ${options.cause}`;
+    }
 
-  constructor(inner: unknown) {
-    super("Permanent error");
-    this.inner = inner;
+    super(msg, options);
+    this.name = "PermanentError";
+    // In older runtimes, the cause field would not have been assigned through
+    // the super() call.
+    if (typeof this.cause === "undefined") {
+      this.cause = options?.cause;
+    }
 
     Object.setPrototypeOf(this, PermanentError.prototype);
   }
 }
 
-class TemporaryError extends Error {
-  res: Response;
+/**
+ * TemporaryError is an error is used to signal that an HTTP request can be
+ * retried as part of a retry loop. If retry attempts are exhausted and this
+ * error is thrown, the response will be returned to the caller.
+ */
+export class TemporaryError extends Error {
+  response: Response;
 
-  constructor(res: Response) {
-    super("Temporary error");
-    this.res = res;
+  constructor(message: string, response: Response) {
+    super(message);
+    this.response = response;
+    this.name = "TemporaryError";
 
     Object.setPrototypeOf(this, TemporaryError.prototype);
   }
@@ -80,11 +101,14 @@ function wrapFetcher(
     try {
       const res = await fn();
       if (isRetryableResponse(res, options.statusCodes)) {
-        throw new TemporaryError(res);
+        throw new TemporaryError(
+          "Response failed with retryable status code",
+          res,
+        );
       }
 
       return res;
-    } catch (err) {
+    } catch (err: unknown) {
       if (err instanceof TemporaryError) {
         throw err;
       }
@@ -96,7 +120,7 @@ function wrapFetcher(
         throw err;
       }
 
-      throw new PermanentError(err);
+      throw new PermanentError("Permanent error", { cause: err });
     }
   };
 }
@@ -139,37 +163,25 @@ async function retryBackoff(
     try {
       const res = await fn();
       return res;
-    } catch (err) {
+    } catch (err: unknown) {
       if (err instanceof PermanentError) {
-        throw err.inner;
+        throw err.cause;
       }
       const elapsed = Date.now() - start;
       if (elapsed > maxElapsedTime) {
         if (err instanceof TemporaryError) {
-          return err.res;
+          return err.response;
         }
 
         throw err;
       }
 
       let retryInterval = 0;
-      if (err instanceof TemporaryError && err.res && err.res.headers) {
-        const retryVal = err.res.headers.get("retry-after") || "";
-        if (retryVal != "") {
-          const parsedNumber = Number(retryVal);
-          if (!isNaN(parsedNumber) && Number.isInteger(parsedNumber)) {
-            retryInterval = parsedNumber * 1000;
-          } else {
-            const parsedDate = Date.parse(retryVal);
-            if (!isNaN(parsedDate)) {
-              const deltaMS = parsedDate - Date.now();
-              retryInterval = deltaMS > 0 ? Math.ceil(deltaMS) : 0;
-            }
-          }
-        }
+      if (err instanceof TemporaryError) {
+        retryInterval = retryIntervalFromResponse(err.response);
       }
 
-      if (retryInterval == 0) {
+      if (retryInterval <= 0) {
         retryInterval =
           initialInterval * Math.pow(x, exponent) + Math.random() * 1000;
       }
@@ -182,6 +194,26 @@ async function retryBackoff(
   }
 }
 
+function retryIntervalFromResponse(res: Response): number {
+  const retryVal = res.headers.get("retry-after") || "";
+  if (!retryVal) {
+    return 0;
+  }
+
+  const parsedNumber = Number(retryVal);
+  if (Number.isInteger(parsedNumber)) {
+    return parsedNumber * 1000;
+  }
+
+  const parsedDate = Date.parse(retryVal);
+  if (Number.isInteger(parsedDate)) {
+    const deltaMS = parsedDate - Date.now();
+    return deltaMS > 0 ? Math.ceil(deltaMS) : 0;
+  }
+
+  return 0;
+}
+
 async function delay(delay: number): Promise<void> {
   return new Promise((resolve) => setTimeout(resolve, delay));
 }

package/src/lib/sdks.ts

@@ -71,11 +71,11 @@ const isBrowserLike = webWorkerLike
   || (typeof window === "object" && typeof window.document !== "undefined");
 
 export class ClientSDK {
-  private readonly httpClient: HTTPClient;
-  protected readonly baseURL: URL | null;
-  protected readonly hooks$: SDKHooks;
-  protected readonly logger?: Logger | undefined;
-  public readonly options$: SDKOptions & { hooks?: SDKHooks };
+  readonly #httpClient: HTTPClient;
+  readonly #hooks: SDKHooks;
+  readonly #logger?: Logger | undefined;
+  protected readonly _baseURL: URL | null;
+  public readonly _options: SDKOptions & { hooks?: SDKHooks };
 
   constructor(options: SDKOptions = {}) {
     const opt = options as unknown;
@@ -85,33 +85,33 @@ export class ClientSDK {
       && "hooks" in opt
       && opt.hooks instanceof SDKHooks
     ) {
-      this.hooks$ = opt.hooks;
+      this.#hooks = opt.hooks;
     } else {
-      this.hooks$ = new SDKHooks();
+      this.#hooks = new SDKHooks();
     }
-    this.options$ = { ...options, hooks: this.hooks$ };
+    this._options = { ...options, hooks: this.#hooks };
 
     const url = serverURLFromOptions(options);
     if (url) {
       url.pathname = url.pathname.replace(/\/+$/, "") + "/";
     }
-    const { baseURL, client } = this.hooks$.sdkInit({
+    const { baseURL, client } = this.#hooks.sdkInit({
       baseURL: url,
       client: options.httpClient || new HTTPClient(),
     });
-    this.baseURL = baseURL;
-    this.httpClient = client;
-    this.logger = options.debugLogger;
+    this._baseURL = baseURL;
+    this.#httpClient = client;
+    this.#logger = options.debugLogger;
   }
 
-  public createRequest$(
+  public _createRequest(
     context: HookContext,
     conf: RequestConfig,
     options?: RequestOptions,
   ): Result<Request, InvalidRequestError | UnexpectedClientError> {
     const { method, path, query, headers: opHeaders, security } = conf;
 
-    const base = conf.baseURL ?? this.baseURL;
+    const base = conf.baseURL ?? this._baseURL;
     if (!base) {
       return ERR(new InvalidRequestError("No base URL provided for operation"));
     }
@@ -195,7 +195,7 @@ export class ClientSDK {
 
     let input;
     try {
-      input = this.hooks$.beforeCreateRequest(context, {
+      input = this.#hooks.beforeCreateRequest(context, {
         url: reqURL,
         options: {
           ...fetchOptions,
@@ -215,13 +215,13 @@ export class ClientSDK {
     return OK(new Request(input.url, input.options));
   }
 
-  public async do$(
+  public async _do(
     request: Request,
     options: {
       context: HookContext;
       errorCodes: number | string | (number | string)[];
-      retryConfig?: RetryConfig | undefined;
-      retryCodes?: string[] | undefined;
+      retryConfig: RetryConfig;
+      retryCodes: string[];
     },
   ): Promise<
     Result<
@@ -233,34 +233,38 @@ export class ClientSDK {
     >
   > {
     const { context, errorCodes } = options;
-    const retryConfig = options.retryConfig || { strategy: "none" };
-    const retryCodes = options.retryCodes || [];
 
     return retry(
       async () => {
-        const req = await this.hooks$.beforeRequest(context, request.clone());
-        await logRequest(this.logger, req).catch((e) =>
-          this.logger?.log("Failed to log request:", e)
+        const req = await this.#hooks.beforeRequest(context, request.clone());
+        await logRequest(this.#logger, req).catch((e) =>
+          this.#logger?.log("Failed to log request:", e)
         );
 
-        let response = await this.httpClient.request(req);
+        let response = await this.#httpClient.request(req);
 
-        if (matchStatusCode(response, errorCodes)) {
-          const result = await this.hooks$.afterError(context, response, null);
-          if (result.error) {
-            throw result.error;
+        try {
+          if (matchStatusCode(response, errorCodes)) {
+            const result = await this.#hooks.afterError(
+              context,
+              response,
+              null,
+            );
+            if (result.error) {
+              throw result.error;
+            }
+            response = result.response || response;
+          } else {
+            response = await this.#hooks.afterSuccess(context, response);
           }
-          response = result.response || response;
-        } else {
-          response = await this.hooks$.afterSuccess(context, response);
+        } finally {
+          await logResponse(this.#logger, response, req)
+            .catch(e => this.#logger?.log("Failed to log response:", e));
         }
 
-        await logResponse(this.logger, response, req)
-          .catch(e => this.logger?.log("Failed to log response:", e));
-
         return response;
       },
-      { config: retryConfig, statusCodes: retryCodes },
+      { config: options.retryConfig, statusCodes: options.retryCodes },
     ).then(
       (r) => OK(r),
       (err) => {

package/src/lib/security.ts

@@ -4,6 +4,14 @@
 
 import * as components from "../models/components/index.js";
 
+type OAuth2PasswordFlow = {
+  username: string;
+  password?: string | undefined;
+  clientID: string;
+  clientSecret?: string | undefined;
+  tokenURL: string;
+};
+
 export enum SecurityErrorCode {
   Incomplete = "incomplete",
   UnrecognisedSecurityType = "unrecognized_security_type",
@@ -37,6 +45,7 @@ export type SecurityState = {
   headers: Record<string, string>;
   queryParams: Record<string, string>;
   cookies: Record<string, string>;
+  oauth2: ({ type: "password" } & OAuth2PasswordFlow) | { type: "none" };
 };
 
 type SecurityInputBasic = {
@@ -73,7 +82,18 @@ type SecurityInputOAuth2 = {
 
 type SecurityInputOAuth2ClientCredentials = {
   type: "oauth2:client_credentials";
-  value: string | null | undefined;
+  value:
+    | { clientID?: string | undefined; clientSecret?: string | undefined }
+    | null
+    | undefined;
+};
+
+type SecurityInputOAuth2PasswordCredentials = {
+  type: "oauth2:password";
+  value:
+    | string
+    | null
+    | undefined;
   fieldName: string;
 };
 
@@ -89,6 +109,7 @@ export type SecurityInput =
   | SecurityInputAPIKey
   | SecurityInputOAuth2
   | SecurityInputOAuth2ClientCredentials
+  | SecurityInputOAuth2PasswordCredentials
   | SecurityInputOIDC
   | SecurityInputCustom;
 
@@ -100,6 +121,7 @@ export function resolveSecurity(
     headers: {},
     queryParams: {},
     cookies: {},
+    oauth2: { type: "none" },
   };
 
   const option = options.find((opts) => {
@@ -110,6 +132,12 @@ export function resolveSecurity(
         return o.value.username != null || o.value.password != null;
       } else if (o.type === "http:custom") {
         return null;
+      } else if (o.type === "oauth2:password") {
+        return (
+          typeof o.value === "string" && !!o.value
+        );
+      } else if (o.type === "oauth2:client_credentials") {
+        return o.value.clientID != null || o.value.clientSecret != null;
       } else if (typeof o.value === "string") {
         return !!o.value;
       } else {
@@ -152,6 +180,9 @@ export function resolveSecurity(
       case "oauth2":
         applyBearer(state, spec);
         break;
+      case "oauth2:password":
+        applyBearer(state, spec);
+        break;
       case "oauth2:client_credentials":
         break;
       case "openIdConnect":
@@ -179,9 +210,13 @@ function applyBasic(
 
 function applyBearer(
   state: SecurityState,
-  spec: SecurityInputBearer | SecurityInputOAuth2 | SecurityInputOIDC,
+  spec:
+    | SecurityInputBearer
+    | SecurityInputOAuth2
+    | SecurityInputOIDC
+    | SecurityInputOAuth2PasswordCredentials,
 ) {
-  if (spec.value == null) {
+  if (typeof spec.value !== "string" || !spec.value) {
     return;
   }
 
@@ -192,6 +227,7 @@ function applyBearer(
 
   state.headers[spec.fieldName] = value;
 }
+
 export function resolveGlobalSecurity(
   security: Partial<components.Security> | null | undefined,
 ): SecurityState | null {

package/src/models/components/activitiesresponsedto.ts

@@ -3,12 +3,33 @@
  */
 
 import * as z from "zod";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import {
+  ActivityNotificationResponseDto,
+  ActivityNotificationResponseDto$inboundSchema,
+  ActivityNotificationResponseDto$Outbound,
+  ActivityNotificationResponseDto$outboundSchema,
+} from "./activitynotificationresponsedto.js";
 
 export type ActivitiesResponseDto = {
-  data: Array<string>;
+  /**
+   * Whether there are more activities
+   */
   hasMore: boolean;
-  page: number;
+  /**
+   * Array of activity notifications
+   */
+  data: Array<ActivityNotificationResponseDto>;
+  /**
+   * Page size of the activities
+   */
   pageSize: number;
+  /**
+   * Current page of the activities
+   */
+  page: number;
 };
 
 /** @internal */
@@ -17,18 +38,18 @@ export const ActivitiesResponseDto$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  data: z.array(z.string()),
   hasMore: z.boolean(),
-  page: z.number(),
+  data: z.array(ActivityNotificationResponseDto$inboundSchema),
   pageSize: z.number(),
+  page: z.number(),
 });
 
 /** @internal */
 export type ActivitiesResponseDto$Outbound = {
-  data: Array<string>;
   hasMore: boolean;
-  page: number;
+  data: Array<ActivityNotificationResponseDto$Outbound>;
   pageSize: number;
+  page: number;
 };
 
 /** @internal */
@@ -37,10 +58,10 @@ export const ActivitiesResponseDto$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   ActivitiesResponseDto
 > = z.object({
-  data: z.array(z.string()),
   hasMore: z.boolean(),
-  page: z.number(),
+  data: z.array(ActivityNotificationResponseDto$outboundSchema),
   pageSize: z.number(),
+  page: z.number(),
 });
 
 /**
@@ -55,3 +76,21 @@ export namespace ActivitiesResponseDto$ {
   /** @deprecated use `ActivitiesResponseDto$Outbound` instead. */
   export type Outbound = ActivitiesResponseDto$Outbound;
 }
+
+export function activitiesResponseDtoToJSON(
+  activitiesResponseDto: ActivitiesResponseDto,
+): string {
+  return JSON.stringify(
+    ActivitiesResponseDto$outboundSchema.parse(activitiesResponseDto),
+  );
+}
+
+export function activitiesResponseDtoFromJSON(
+  jsonString: string,
+): SafeParseResult<ActivitiesResponseDto, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ActivitiesResponseDto$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ActivitiesResponseDto' from JSON`,
+  );
+}

package/src/models/components/activitygraphstatesresponse.ts

@@ -4,41 +4,50 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
 import { ClosedEnum } from "../../types/enums.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
-export const Channels = {
+export const ActivityGraphStatesResponseChannels = {
   InApp: "in_app",
   Email: "email",
   Sms: "sms",
   Chat: "chat",
   Push: "push",
 } as const;
-export type Channels = ClosedEnum<typeof Channels>;
+export type ActivityGraphStatesResponseChannels = ClosedEnum<
+  typeof ActivityGraphStatesResponseChannels
+>;
 
 export type ActivityGraphStatesResponse = {
   id: string;
-  channels: Array<Channels>;
   count: number;
   templates: Array<string>;
+  channels: Array<ActivityGraphStatesResponseChannels>;
 };
 
 /** @internal */
-export const Channels$inboundSchema: z.ZodNativeEnum<typeof Channels> = z
-  .nativeEnum(Channels);
+export const ActivityGraphStatesResponseChannels$inboundSchema: z.ZodNativeEnum<
+  typeof ActivityGraphStatesResponseChannels
+> = z.nativeEnum(ActivityGraphStatesResponseChannels);
 
 /** @internal */
-export const Channels$outboundSchema: z.ZodNativeEnum<typeof Channels> =
-  Channels$inboundSchema;
+export const ActivityGraphStatesResponseChannels$outboundSchema:
+  z.ZodNativeEnum<typeof ActivityGraphStatesResponseChannels> =
+    ActivityGraphStatesResponseChannels$inboundSchema;
 
 /**
  * @internal
  * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
  */
-export namespace Channels$ {
-  /** @deprecated use `Channels$inboundSchema` instead. */
-  export const inboundSchema = Channels$inboundSchema;
-  /** @deprecated use `Channels$outboundSchema` instead. */
-  export const outboundSchema = Channels$outboundSchema;
+export namespace ActivityGraphStatesResponseChannels$ {
+  /** @deprecated use `ActivityGraphStatesResponseChannels$inboundSchema` instead. */
+  export const inboundSchema =
+    ActivityGraphStatesResponseChannels$inboundSchema;
+  /** @deprecated use `ActivityGraphStatesResponseChannels$outboundSchema` instead. */
+  export const outboundSchema =
+    ActivityGraphStatesResponseChannels$outboundSchema;
 }
 
 /** @internal */
@@ -48,9 +57,9 @@ export const ActivityGraphStatesResponse$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   _id: z.string(),
-  channels: z.array(Channels$inboundSchema),
   count: z.number(),
   templates: z.array(z.string()),
+  channels: z.array(ActivityGraphStatesResponseChannels$inboundSchema),
 }).transform((v) => {
   return remap$(v, {
     "_id": "id",
@@ -60,9 +69,9 @@ export const ActivityGraphStatesResponse$inboundSchema: z.ZodType<
 /** @internal */
 export type ActivityGraphStatesResponse$Outbound = {
   _id: string;
-  channels: Array<string>;
   count: number;
   templates: Array<string>;
+  channels: Array<string>;
 };
 
 /** @internal */
@@ -72,9 +81,9 @@ export const ActivityGraphStatesResponse$outboundSchema: z.ZodType<
   ActivityGraphStatesResponse
 > = z.object({
   id: z.string(),
-  channels: z.array(Channels$outboundSchema),
   count: z.number(),
   templates: z.array(z.string()),
+  channels: z.array(ActivityGraphStatesResponseChannels$outboundSchema),
 }).transform((v) => {
   return remap$(v, {
     id: "_id",
@@ -93,3 +102,23 @@ export namespace ActivityGraphStatesResponse$ {
   /** @deprecated use `ActivityGraphStatesResponse$Outbound` instead. */
   export type Outbound = ActivityGraphStatesResponse$Outbound;
 }
+
+export function activityGraphStatesResponseToJSON(
+  activityGraphStatesResponse: ActivityGraphStatesResponse,
+): string {
+  return JSON.stringify(
+    ActivityGraphStatesResponse$outboundSchema.parse(
+      activityGraphStatesResponse,
+    ),
+  );
+}
+
+export function activityGraphStatesResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<ActivityGraphStatesResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ActivityGraphStatesResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ActivityGraphStatesResponse' from JSON`,
+  );
+}