Merge branch 'main' into PSG-5450-remove-deploy-workflow

Author: ctran88

src/classes/Auth/Auth.ts

@@ -8,19 +8,20 @@ import {
 } from 'jose';
 import { PassageBase, PassageInstanceConfig } from '../PassageBase';
 import { PassageError } from '../PassageError';
-import { CreateMagicLinkRequest, MagicLink, MagicLinksApi, ResponseError } from '../../generated';
+import { MagicLink, MagicLinksApi } from '../../generated';
+import { CreateMagicLinkArgs } from './types';
 
 /**
  * Auth class that provides methods for validating JWTs and creating Magic Links.
  */
 export class Auth extends PassageBase {
-    private jwks: (protectedHeader?: JWSHeaderParameters, token?: FlattenedJWSInput) => Promise<KeyLike>;
+    private readonly jwks: (protectedHeader?: JWSHeaderParameters, token?: FlattenedJWSInput) => Promise<KeyLike>;
 
     /**
      * Auth class constructor.
      * @param {PassageInstanceConfig} config config properties for Passage instance
      */
-    constructor(protected config: PassageInstanceConfig) {
+    public constructor(protected config: PassageInstanceConfig) {
         super(config);
         this.jwks = createRemoteJWKSet(
             new URL(`https://auth.passage.id/v1/apps/${this.config.appId}/.well-known/jwks.json`),
@@ -40,52 +41,48 @@ export class Auth extends PassageBase {
         try {
             const { kid } = decodeProtectedHeader(jwt);
             if (!kid) {
-                throw new PassageError('Could not find valid cookie for authentication.');
+                throw new PassageError('Could not find valid cookie for authentication. You must catch this error.');
             }
 
             const {
                 payload: { sub: userId, aud },
             } = await jwtVerify(jwt, this.jwks);
 
             if (!userId) {
-                throw new PassageError('Could not validate auth token.');
+                throw new PassageError('Could not validate auth token. You must catch this error.');
             }
             if (Array.isArray(aud)) {
                 if (!aud.includes(this.config.appId)) {
-                    throw new Error('Incorrect app ID claim in token.');
+                    throw new Error('Incorrect app ID claim in token. You must catch this error.');
                 }
             }
             return userId;
         } catch (e) {
             if (e instanceof Error) {
-                throw new PassageError(`Could not verify token: ${e.toString()}.`);
+                throw new PassageError(`Could not verify token: ${e.toString()}. You must catch this error.`);
             }
 
-            throw new PassageError(`Could not verify token.`);
+            throw new PassageError(`Could not verify token. You must catch this error.`);
         }
     }
 
     /**
      * Create a Magic Link for your app.
      *
-     * @param {MagicLinkRequest} magicLinkReq options for creating a MagicLink.
+     * @param {CreateMagicLinkArgs} args options for creating a MagicLink.
      * @return {Promise<MagicLink>} Passage MagicLink object
      */
-    public async createMagicLink(magicLinkReq: CreateMagicLinkRequest): Promise<MagicLink> {
+    public async createMagicLink(args: CreateMagicLinkArgs): Promise<MagicLink> {
         try {
             const magicLinksApi = new MagicLinksApi(this.config.apiConfiguration);
             const response = await magicLinksApi.createMagicLink({
                 appId: this.config.appId,
-                createMagicLinkRequest: magicLinkReq,
+                createMagicLinkRequest: args,
             });
 
             return response.magic_link;
         } catch (err) {
-            if (err instanceof ResponseError) {
-                throw await PassageError.fromResponseError(err, 'Could not create a magic link for this app');
-            }
-
-            throw err;
+            throw await this.parseError(err, 'Could not create a magic link for this app');
         }
     }
 }

src/classes/Auth/index.ts

@@ -1 +1,2 @@
 export * from './Auth';
+export * from './types';

src/classes/Auth/types.ts

@@ -0,0 +1,7 @@
+import { CreateMagicLinkRequest } from '../../generated';
+
+export type CreateMagicLinkArgs = CreateMagicLinkRequest;
+
+export { MagicLinkType, MagicLink } from '../../generated';
+
+export { CreateMagicLinkRequest };

src/classes/Passage/Passage.ts

@@ -1,31 +1,31 @@
 import { AuthStrategy } from '../../types/AuthStrategy';
 import { PassageConfig } from '../../types/PassageConfig';
 import { PassageError } from '../PassageError';
-import { AppInfo, AppsApi, Configuration, CreateMagicLinkRequest, MagicLink, ResponseError } from '../../generated';
+import { AppInfo, AppsApi, Configuration, MagicLink, ResponseError } from '../../generated';
 import apiConfiguration from '../../utils/apiConfiguration';
 import { IncomingMessage } from 'http';
 import { getHeaderFromRequest } from '../../utils/getHeader';
 import { PassageInstanceConfig } from '../PassageBase';
-import { Auth } from '../Auth';
+import { Auth, CreateMagicLinkArgs } from '../Auth';
 import { User } from '../User';
 
 /**
  * Passage Class
  */
 export class Passage {
-    private appId: string;
-    #apiKey: string | undefined;
-    private authStrategy: AuthStrategy;
-    public user: User;
-    public auth: Auth;
+    private readonly appId: string;
+    private _apiKey: string | undefined;
+    private readonly authStrategy: AuthStrategy;
+    public readonly user: User;
+    public readonly auth: Auth;
 
-    private _apiConfiguration: Configuration;
+    private readonly _apiConfiguration: Configuration;
 
     /**
      * Initialize a new Passage instance.
      * @param {PassageConfig} config The default config for Passage initialization
      */
-    constructor(config: PassageConfig) {
+    public constructor(config: PassageConfig) {
         if (!config.appID) {
             throw new PassageError(
                 'A Passage appID is required. Please include {appID: YOUR_APP_ID, apiKey: YOUR_API_KEY}.',
@@ -51,7 +51,7 @@ export class Passage {
 
         // To be removed on next major release
         this.appId = config.appID;
-        this.#apiKey = config.apiKey;
+        this._apiKey = config.apiKey;
 
         this.authStrategy = config?.authStrategy ? config.authStrategy : 'COOKIE';
     }
@@ -79,7 +79,7 @@ export class Passage {
      * @param {string} _apiKey
      */
     set apiKey(_apiKey) {
-        this.#apiKey = _apiKey;
+        this._apiKey = _apiKey;
     }
 
     /**
@@ -88,7 +88,7 @@ export class Passage {
      * @return {string | undefined} Passage API Key
      */
     get apiKey(): string | undefined {
-        return this.#apiKey;
+        return this._apiKey;
     }
 
     /**
@@ -171,11 +171,11 @@ export class Passage {
      * @deprecated Use Passage.auth.createMagicLink instead.
      * Create a Magic Link for your app.
      *
-     * @param {MagicLinkRequest} magicLinkReq options for creating a MagicLink.
+     * @param {CreateMagicLinkArgs} args options for creating a MagicLink.
      * @return {Promise<MagicLink>} Passage MagicLink object
      */
-    async createMagicLink(magicLinkReq: CreateMagicLinkRequest): Promise<MagicLink> {
-        return this.auth.createMagicLink(magicLinkReq);
+    async createMagicLink(args: CreateMagicLinkArgs): Promise<MagicLink> {
+        return this.auth.createMagicLink(args);
     }
 
     /**

src/classes/Passage/index.ts

@@ -1 +1,2 @@
 export * from './Passage';
+export * from './types';

src/classes/Passage/types.ts

@@ -0,0 +1 @@
+export { AppInfo, Layouts, LayoutConfig, UserMetadataFieldType, UserMetadataField } from '../../generated';

src/classes/PassageBase/PassageBase.ts

@@ -1,3 +1,4 @@
+import { PassageError, ResponseError } from '../PassageError';
 import { PassageInstanceConfig } from './types';
 
 /**
@@ -8,5 +9,18 @@ export class PassageBase {
      * PassageBase class constructor.
      * @param {PassageInstanceConfig} config config properties for Passage instance
      */
-    constructor(protected config: PassageInstanceConfig) {}
+    public constructor(protected config: PassageInstanceConfig) {}
+
+    /**
+     * Handle errors from PassageFlex API
+     * @param {unknown} err error from node-fetch request
+     * @param {string} message optional message to include in the error
+     * @return {Promise<void>}
+     */
+    protected async parseError(err: unknown, message?: string): Promise<Error> {
+        if (err instanceof ResponseError) {
+            throw await PassageError.fromResponseError(err, message);
+        }
+        return err as Error;
+    }
 }

src/classes/PassageError/index.ts

@@ -1 +1,2 @@
 export * from './PassageError';
+export * from './types';

src/classes/PassageError/types.ts

@@ -0,0 +1 @@
+export { ResponseError } from '../../generated';