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

package/src/lib/security.ts

@@ -5,199 +5,213 @@
 import * as components from "../models/components/index.js";
 
 export enum SecurityErrorCode {
-    Incomplete = "incomplete",
-    UnrecognisedSecurityType = "unrecognized_security_type",
+  Incomplete = "incomplete",
+  UnrecognisedSecurityType = "unrecognized_security_type",
 }
 
 export class SecurityError extends Error {
-    constructor(public code: SecurityErrorCode, message: string) {
-        super(message);
-        this.name = "SecurityError";
-    }
-
-    static incomplete(): SecurityError {
-        return new SecurityError(
-            SecurityErrorCode.Incomplete,
-            "Security requirements not met in order to perform the operation"
-        );
-    }
-    static unrecognizedType(type: string): SecurityError {
-        return new SecurityError(
-            SecurityErrorCode.UnrecognisedSecurityType,
-            `Unrecognised security type: ${type}`
-        );
-    }
+  constructor(
+    public code: SecurityErrorCode,
+    message: string,
+  ) {
+    super(message);
+    this.name = "SecurityError";
+  }
+
+  static incomplete(): SecurityError {
+    return new SecurityError(
+      SecurityErrorCode.Incomplete,
+      "Security requirements not met in order to perform the operation",
+    );
+  }
+  static unrecognizedType(type: string): SecurityError {
+    return new SecurityError(
+      SecurityErrorCode.UnrecognisedSecurityType,
+      `Unrecognised security type: ${type}`,
+    );
+  }
 }
 
 export type SecurityState = {
-    basic: { username?: string | undefined; password?: string | undefined };
-    headers: Record<string, string>;
-    queryParams: Record<string, string>;
-    cookies: Record<string, string>;
+  basic: { username?: string | undefined; password?: string | undefined };
+  headers: Record<string, string>;
+  queryParams: Record<string, string>;
+  cookies: Record<string, string>;
 };
 
 type SecurityInputBasic = {
-    type: "http:basic";
-    value: { username?: string | undefined; password?: string | undefined } | null | undefined;
+  type: "http:basic";
+  value:
+    | { username?: string | undefined; password?: string | undefined }
+    | null
+    | undefined;
 };
 
 type SecurityInputBearer = {
-    type: "http:bearer";
-    value: string | null | undefined;
-    fieldName: string;
+  type: "http:bearer";
+  value: string | null | undefined;
+  fieldName: string;
 };
 
 type SecurityInputAPIKey = {
-    type: "apiKey:header" | "apiKey:query" | "apiKey:cookie";
-    value: string | null | undefined;
-    fieldName: string;
+  type: "apiKey:header" | "apiKey:query" | "apiKey:cookie";
+  value: string | null | undefined;
+  fieldName: string;
 };
 
 type SecurityInputOIDC = {
-    type: "openIdConnect";
-    value: string | null | undefined;
-    fieldName: string;
+  type: "openIdConnect";
+  value: string | null | undefined;
+  fieldName: string;
 };
 
 type SecurityInputOAuth2 = {
-    type: "oauth2";
-    value: string | null | undefined;
-    fieldName: string;
+  type: "oauth2";
+  value: string | null | undefined;
+  fieldName: string;
 };
 
 type SecurityInputOAuth2ClientCredentials = {
-    type: "oauth2:client_credentials";
-    value: string | null | undefined;
-    fieldName: string;
+  type: "oauth2:client_credentials";
+  value: string | null | undefined;
+  fieldName: string;
 };
 
 type SecurityInputCustom = {
-    type: "http:custom";
-    value: any | null | undefined;
-    fieldName: string;
+  type: "http:custom";
+  value: any | null | undefined;
+  fieldName: string;
 };
 
 export type SecurityInput =
-    | SecurityInputBasic
-    | SecurityInputBearer
-    | SecurityInputAPIKey
-    | SecurityInputOAuth2
-    | SecurityInputOAuth2ClientCredentials
-    | SecurityInputOIDC
-    | SecurityInputCustom;
-
-export function resolveSecurity(...options: SecurityInput[][]): SecurityState | null {
-    const state: SecurityState = {
-        basic: { username: "", password: "" },
-        headers: {},
-        queryParams: {},
-        cookies: {},
-    };
-
-    const option = options.find((opts) => {
-        return opts.every((o) => {
-            if (o.value == null) {
-                return false;
-            } else if (o.type === "http:basic") {
-                return o.value.username != null || o.value.password != null;
-            } else if (o.type === "http:custom") {
-                return null;
-            } else if (typeof o.value === "string") {
-                return !!o.value;
-            } else {
-                throw new Error(
-                    `Unrecognized security type: ${o.type} (value type: ${typeof o.value})`
-                );
-            }
-        });
-    });
-    if (option == null) {
+  | SecurityInputBasic
+  | SecurityInputBearer
+  | SecurityInputAPIKey
+  | SecurityInputOAuth2
+  | SecurityInputOAuth2ClientCredentials
+  | SecurityInputOIDC
+  | SecurityInputCustom;
+
+export function resolveSecurity(
+  ...options: SecurityInput[][]
+): SecurityState | null {
+  const state: SecurityState = {
+    basic: { username: "", password: "" },
+    headers: {},
+    queryParams: {},
+    cookies: {},
+  };
+
+  const option = options.find((opts) => {
+    return opts.every((o) => {
+      if (o.value == null) {
+        return false;
+      } else if (o.type === "http:basic") {
+        return o.value.username != null || o.value.password != null;
+      } else if (o.type === "http:custom") {
         return null;
+      } else if (typeof o.value === "string") {
+        return !!o.value;
+      } else {
+        throw new Error(
+          `Unrecognized security type: ${o.type} (value type: ${typeof o
+            .value})`,
+        );
+      }
+    });
+  });
+  if (option == null) {
+    return null;
+  }
+
+  option.forEach((spec) => {
+    if (spec.value == null) {
+      return;
     }
 
-    option.forEach((spec) => {
-        if (spec.value == null) {
-            return;
-        }
-
-        const { type } = spec;
-
-        switch (type) {
-            case "apiKey:header":
-                state.headers[spec.fieldName] = spec.value;
-                break;
-            case "apiKey:query":
-                state.queryParams[spec.fieldName] = spec.value;
-                break;
-            case "apiKey:cookie":
-                state.cookies[spec.fieldName] = spec.value;
-                break;
-            case "http:basic":
-                applyBasic(state, spec);
-                break;
-            case "http:custom":
-                break;
-            case "http:bearer":
-                applyBearer(state, spec);
-                break;
-            case "oauth2":
-                applyBearer(state, spec);
-                break;
-            case "oauth2:client_credentials":
-                break;
-            case "openIdConnect":
-                applyBearer(state, spec);
-                break;
-            default:
-                spec satisfies never;
-                throw SecurityError.unrecognizedType(type);
-        }
-    });
+    const { type } = spec;
+
+    switch (type) {
+      case "apiKey:header":
+        state.headers[spec.fieldName] = spec.value;
+        break;
+      case "apiKey:query":
+        state.queryParams[spec.fieldName] = spec.value;
+        break;
+      case "apiKey:cookie":
+        state.cookies[spec.fieldName] = spec.value;
+        break;
+      case "http:basic":
+        applyBasic(state, spec);
+        break;
+      case "http:custom":
+        break;
+      case "http:bearer":
+        applyBearer(state, spec);
+        break;
+      case "oauth2":
+        applyBearer(state, spec);
+        break;
+      case "oauth2:client_credentials":
+        break;
+      case "openIdConnect":
+        applyBearer(state, spec);
+        break;
+      default:
+        spec satisfies never;
+        throw SecurityError.unrecognizedType(type);
+    }
+  });
 
-    return state;
+  return state;
 }
 
-function applyBasic(state: SecurityState, spec: SecurityInputBasic) {
-    if (spec.value == null) {
-        return;
-    }
+function applyBasic(
+  state: SecurityState,
+  spec: SecurityInputBasic,
+) {
+  if (spec.value == null) {
+    return;
+  }
 
-    state.basic = spec.value;
+  state.basic = spec.value;
 }
 
 function applyBearer(
-    state: SecurityState,
-    spec: SecurityInputBearer | SecurityInputOAuth2 | SecurityInputOIDC
+  state: SecurityState,
+  spec: SecurityInputBearer | SecurityInputOAuth2 | SecurityInputOIDC,
 ) {
-    if (spec.value == null) {
-        return;
-    }
+  if (spec.value == null) {
+    return;
+  }
 
-    let value = spec.value;
-    if (value.slice(0, 7).toLowerCase() !== "bearer ") {
-        value = `Bearer ${value}`;
-    }
+  let value = spec.value;
+  if (value.slice(0, 7).toLowerCase() !== "bearer ") {
+    value = `Bearer ${value}`;
+  }
 
-    state.headers[spec.fieldName] = value;
+  state.headers[spec.fieldName] = value;
 }
 export function resolveGlobalSecurity(
-    security: Partial<components.Security> | null | undefined
+  security: Partial<components.Security> | null | undefined,
 ): SecurityState | null {
-    return resolveSecurity([
-        {
-            fieldName: "Authorization",
-            type: "apiKey:header",
-            value: security?.apiKey,
-        },
-    ]);
+  return resolveSecurity(
+    [
+      {
+        fieldName: "Authorization",
+        type: "apiKey:header",
+        value: security?.apiKey,
+      },
+    ],
+  );
 }
 
-export async function extractSecurity<T extends string | Record<string, unknown>>(
-    sec: T | (() => Promise<T>) | undefined
-): Promise<T | undefined> {
-    if (sec == null) {
-        return;
-    }
+export async function extractSecurity<
+  T extends string | Record<string, unknown>,
+>(sec: T | (() => Promise<T>) | undefined): Promise<T | undefined> {
+  if (sec == null) {
+    return;
+  }
 
-    return typeof sec === "function" ? sec() : sec;
+  return typeof sec === "function" ? sec() : sec;
 }

package/src/models/components/activitiesresponsedto.ts

@@ -5,42 +5,42 @@
 import * as z from "zod";
 
 export type ActivitiesResponseDto = {
-    data: Array<string>;
-    hasMore: boolean;
-    page: number;
-    pageSize: number;
+  data: Array<string>;
+  hasMore: boolean;
+  page: number;
+  pageSize: number;
 };
 
 /** @internal */
 export const ActivitiesResponseDto$inboundSchema: z.ZodType<
-    ActivitiesResponseDto,
-    z.ZodTypeDef,
-    unknown
+  ActivitiesResponseDto,
+  z.ZodTypeDef,
+  unknown
 > = z.object({
-    data: z.array(z.string()),
-    hasMore: z.boolean(),
-    page: z.number(),
-    pageSize: z.number(),
+  data: z.array(z.string()),
+  hasMore: z.boolean(),
+  page: z.number(),
+  pageSize: z.number(),
 });
 
 /** @internal */
 export type ActivitiesResponseDto$Outbound = {
-    data: Array<string>;
-    hasMore: boolean;
-    page: number;
-    pageSize: number;
+  data: Array<string>;
+  hasMore: boolean;
+  page: number;
+  pageSize: number;
 };
 
 /** @internal */
 export const ActivitiesResponseDto$outboundSchema: z.ZodType<
-    ActivitiesResponseDto$Outbound,
-    z.ZodTypeDef,
-    ActivitiesResponseDto
+  ActivitiesResponseDto$Outbound,
+  z.ZodTypeDef,
+  ActivitiesResponseDto
 > = z.object({
-    data: z.array(z.string()),
-    hasMore: z.boolean(),
-    page: z.number(),
-    pageSize: z.number(),
+  data: z.array(z.string()),
+  hasMore: z.boolean(),
+  page: z.number(),
+  pageSize: z.number(),
 });
 
 /**
@@ -48,10 +48,10 @@ export const ActivitiesResponseDto$outboundSchema: z.ZodType<
  * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
  */
 export namespace ActivitiesResponseDto$ {
-    /** @deprecated use `ActivitiesResponseDto$inboundSchema` instead. */
-    export const inboundSchema = ActivitiesResponseDto$inboundSchema;
-    /** @deprecated use `ActivitiesResponseDto$outboundSchema` instead. */
-    export const outboundSchema = ActivitiesResponseDto$outboundSchema;
-    /** @deprecated use `ActivitiesResponseDto$Outbound` instead. */
-    export type Outbound = ActivitiesResponseDto$Outbound;
+  /** @deprecated use `ActivitiesResponseDto$inboundSchema` instead. */
+  export const inboundSchema = ActivitiesResponseDto$inboundSchema;
+  /** @deprecated use `ActivitiesResponseDto$outboundSchema` instead. */
+  export const outboundSchema = ActivitiesResponseDto$outboundSchema;
+  /** @deprecated use `ActivitiesResponseDto$Outbound` instead. */
+  export type Outbound = ActivitiesResponseDto$Outbound;
 }

package/src/models/components/activitygraphstatesresponse.ts

@@ -2,96 +2,94 @@
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
  */
 
+import * as z from "zod";
 import { remap as remap$ } from "../../lib/primitives.js";
 import { ClosedEnum } from "../../types/enums.js";
-import * as z from "zod";
 
 export const Channels = {
-    InApp: "in_app",
-    Email: "email",
-    Sms: "sms",
-    Chat: "chat",
-    Push: "push",
+  InApp: "in_app",
+  Email: "email",
+  Sms: "sms",
+  Chat: "chat",
+  Push: "push",
 } as const;
 export type Channels = ClosedEnum<typeof Channels>;
 
 export type ActivityGraphStatesResponse = {
-    id: string;
-    channels: Array<Channels>;
-    count: number;
-    templates: Array<string>;
+  id: string;
+  channels: Array<Channels>;
+  count: number;
+  templates: Array<string>;
 };
 
 /** @internal */
-export const Channels$inboundSchema: z.ZodNativeEnum<typeof Channels> = z.nativeEnum(Channels);
+export const Channels$inboundSchema: z.ZodNativeEnum<typeof Channels> = z
+  .nativeEnum(Channels);
 
 /** @internal */
-export const Channels$outboundSchema: z.ZodNativeEnum<typeof Channels> = Channels$inboundSchema;
+export const Channels$outboundSchema: z.ZodNativeEnum<typeof Channels> =
+  Channels$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;
+  /** @deprecated use `Channels$inboundSchema` instead. */
+  export const inboundSchema = Channels$inboundSchema;
+  /** @deprecated use `Channels$outboundSchema` instead. */
+  export const outboundSchema = Channels$outboundSchema;
 }
 
 /** @internal */
 export const ActivityGraphStatesResponse$inboundSchema: z.ZodType<
-    ActivityGraphStatesResponse,
-    z.ZodTypeDef,
-    unknown
-> = z
-    .object({
-        _id: z.string(),
-        channels: z.array(Channels$inboundSchema),
-        count: z.number(),
-        templates: z.array(z.string()),
-    })
-    .transform((v) => {
-        return remap$(v, {
-            _id: "id",
-        });
-    });
+  ActivityGraphStatesResponse,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  _id: z.string(),
+  channels: z.array(Channels$inboundSchema),
+  count: z.number(),
+  templates: z.array(z.string()),
+}).transform((v) => {
+  return remap$(v, {
+    "_id": "id",
+  });
+});
 
 /** @internal */
 export type ActivityGraphStatesResponse$Outbound = {
-    _id: string;
-    channels: Array<string>;
-    count: number;
-    templates: Array<string>;
+  _id: string;
+  channels: Array<string>;
+  count: number;
+  templates: Array<string>;
 };
 
 /** @internal */
 export const ActivityGraphStatesResponse$outboundSchema: z.ZodType<
-    ActivityGraphStatesResponse$Outbound,
-    z.ZodTypeDef,
-    ActivityGraphStatesResponse
-> = z
-    .object({
-        id: z.string(),
-        channels: z.array(Channels$outboundSchema),
-        count: z.number(),
-        templates: z.array(z.string()),
-    })
-    .transform((v) => {
-        return remap$(v, {
-            id: "_id",
-        });
-    });
+  ActivityGraphStatesResponse$Outbound,
+  z.ZodTypeDef,
+  ActivityGraphStatesResponse
+> = z.object({
+  id: z.string(),
+  channels: z.array(Channels$outboundSchema),
+  count: z.number(),
+  templates: z.array(z.string()),
+}).transform((v) => {
+  return remap$(v, {
+    id: "_id",
+  });
+});
 
 /**
  * @internal
  * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
  */
 export namespace ActivityGraphStatesResponse$ {
-    /** @deprecated use `ActivityGraphStatesResponse$inboundSchema` instead. */
-    export const inboundSchema = ActivityGraphStatesResponse$inboundSchema;
-    /** @deprecated use `ActivityGraphStatesResponse$outboundSchema` instead. */
-    export const outboundSchema = ActivityGraphStatesResponse$outboundSchema;
-    /** @deprecated use `ActivityGraphStatesResponse$Outbound` instead. */
-    export type Outbound = ActivityGraphStatesResponse$Outbound;
+  /** @deprecated use `ActivityGraphStatesResponse$inboundSchema` instead. */
+  export const inboundSchema = ActivityGraphStatesResponse$inboundSchema;
+  /** @deprecated use `ActivityGraphStatesResponse$outboundSchema` instead. */
+  export const outboundSchema = ActivityGraphStatesResponse$outboundSchema;
+  /** @deprecated use `ActivityGraphStatesResponse$Outbound` instead. */
+  export type Outbound = ActivityGraphStatesResponse$Outbound;
 }