@carlonicora/nextjs-jsonapi 1.40.1 → 1.41.0

package/src/features/auth/data/totp-verify.ts

@@ -0,0 +1,22 @@
+import { AbstractApiData } from "../../../core";
+
+export type TotpVerifyInput = {
+  id: string;
+  authenticatorId: string;
+  code: string;
+};
+
+export class TotpVerify extends AbstractApiData {
+  createJsonApi(data: TotpVerifyInput) {
+    return {
+      data: {
+        type: "totp-authenticators",
+        id: data.id,
+        attributes: {
+          authenticatorId: data.authenticatorId,
+          code: data.code,
+        },
+      },
+    };
+  }
+}

package/src/features/auth/data/two-factor-challenge.interface.ts

@@ -0,0 +1,7 @@
+import { ApiDataInterface } from "../../../core";
+
+export interface TwoFactorChallengeInterface extends ApiDataInterface {
+  get pendingToken(): string;
+  get availableMethods(): ("totp" | "passkey" | "backup")[];
+  get expiresAt(): Date;
+}

package/src/features/auth/data/two-factor-challenge.ts

@@ -0,0 +1,45 @@
+import { AbstractApiData, JsonApiHydratedDataInterface } from "../../../core";
+import { TwoFactorChallengeInterface } from "./two-factor-challenge.interface";
+
+export type TwoFactorChallengeInput = {
+  id: string;
+  method: "totp" | "passkey" | "backup";
+};
+
+export class TwoFactorChallenge extends AbstractApiData implements TwoFactorChallengeInterface {
+  private _pendingToken: string = "";
+  private _availableMethods: ("totp" | "passkey" | "backup")[] = [];
+  private _expiresAt: Date = new Date();
+
+  get pendingToken(): string {
+    return this._pendingToken;
+  }
+
+  get availableMethods(): ("totp" | "passkey" | "backup")[] {
+    return this._availableMethods;
+  }
+
+  get expiresAt(): Date {
+    return this._expiresAt;
+  }
+
+  rehydrate(data: JsonApiHydratedDataInterface): this {
+    super.rehydrate(data);
+    this._pendingToken = data.jsonApi.attributes.pendingToken ?? "";
+    this._availableMethods = data.jsonApi.attributes.availableMethods ?? [];
+    this._expiresAt = data.jsonApi.attributes.expiresAt ? new Date(data.jsonApi.attributes.expiresAt) : new Date();
+    return this;
+  }
+
+  createJsonApi(data: TwoFactorChallengeInput) {
+    return {
+      data: {
+        type: "two-factor-configs",
+        id: data.id,
+        attributes: {
+          method: data.method,
+        },
+      },
+    };
+  }
+}

package/src/features/auth/data/two-factor-enable.ts

@@ -0,0 +1,20 @@
+import { AbstractApiData } from "../../../core";
+
+export type TwoFactorEnableInput = {
+  id: string;
+  preferredMethod: "totp" | "passkey";
+};
+
+export class TwoFactorEnable extends AbstractApiData {
+  createJsonApi(data: TwoFactorEnableInput) {
+    return {
+      data: {
+        type: "two-factor-configs",
+        id: data.id,
+        attributes: {
+          preferredMethod: data.preferredMethod,
+        },
+      },
+    };
+  }
+}

package/src/features/auth/data/two-factor-status.interface.ts

@@ -0,0 +1,11 @@
+import { ApiDataInterface } from "../../../core";
+import { TotpAuthenticatorInterface } from "./totp-authenticator.interface";
+import { PasskeyInterface } from "./passkey.interface";
+
+export interface TwoFactorStatusInterface extends ApiDataInterface {
+  get isEnabled(): boolean;
+  get preferredMethod(): "totp" | "passkey" | undefined;
+  get totpAuthenticators(): TotpAuthenticatorInterface[];
+  get passkeys(): PasskeyInterface[];
+  get backupCodesCount(): number;
+}

package/src/features/auth/data/two-factor-status.ts

@@ -0,0 +1,40 @@
+import { AbstractApiData, JsonApiHydratedDataInterface } from "../../../core";
+import { TwoFactorStatusInterface } from "./two-factor-status.interface";
+import { TotpAuthenticatorInterface } from "./totp-authenticator.interface";
+import { PasskeyInterface } from "./passkey.interface";
+
+export class TwoFactorStatus extends AbstractApiData implements TwoFactorStatusInterface {
+  private _isEnabled: boolean = false;
+  private _preferredMethod?: "totp" | "passkey";
+  private _totpAuthenticators: TotpAuthenticatorInterface[] = [];
+  private _passkeys: PasskeyInterface[] = [];
+  private _backupCodesCount: number = 0;
+
+  get isEnabled(): boolean {
+    return this._isEnabled;
+  }
+
+  get preferredMethod(): "totp" | "passkey" | undefined {
+    return this._preferredMethod;
+  }
+
+  get totpAuthenticators(): TotpAuthenticatorInterface[] {
+    return this._totpAuthenticators;
+  }
+
+  get passkeys(): PasskeyInterface[] {
+    return this._passkeys;
+  }
+
+  get backupCodesCount(): number {
+    return this._backupCodesCount;
+  }
+
+  rehydrate(data: JsonApiHydratedDataInterface): this {
+    super.rehydrate(data);
+    this._isEnabled = data.jsonApi.attributes.isEnabled ?? false;
+    this._preferredMethod = data.jsonApi.attributes.preferredMethod;
+    this._backupCodesCount = data.jsonApi.attributes.backupCodesCount ?? 0;
+    return this;
+  }
+}

package/src/features/auth/data/two-factor.service.ts

@@ -0,0 +1,331 @@
+import { AuthenticationResponseJSON, RegistrationResponseJSON } from "@simplewebauthn/browser";
+import { AbstractService, EndpointCreator, HttpMethod, Modules } from "../../../core";
+import { getTokenHandler } from "../config";
+import { AuthInterface } from "./auth.interface";
+import { PasskeyInterface } from "./passkey.interface";
+import { PasskeyAuthenticationOptionsInterface } from "./passkey-authentication-options.interface";
+import { PasskeyRegistrationOptionsInterface } from "./passkey-registration-options";
+import { TotpAuthenticatorInterface } from "./totp-authenticator.interface";
+import { TotpSetupInterface } from "./totp-setup.interface";
+import { TwoFactorChallengeInterface } from "./two-factor-challenge.interface";
+import { TwoFactorStatusInterface } from "./two-factor-status.interface";
+
+export class TwoFactorService extends AbstractService {
+  // ============================================================
+  // Status
+  // ============================================================
+
+  static async getStatus(): Promise<TwoFactorStatusInterface> {
+    return this.callApi<TwoFactorStatusInterface>({
+      type: Modules.TwoFactorStatus,
+      method: HttpMethod.GET,
+      endpoint: new EndpointCreator({
+        endpoint: Modules.Auth,
+        id: "two-factor",
+        childEndpoint: "status",
+      }).generate(),
+    });
+  }
+
+  static async enable(params: { id: string; preferredMethod: "totp" | "passkey" }): Promise<void> {
+    await this.callApi({
+      type: Modules.TwoFactorEnable,
+      method: HttpMethod.POST,
+      endpoint: new EndpointCreator({
+        endpoint: Modules.Auth,
+        id: "two-factor",
+        childEndpoint: "enable",
+      }).generate(),
+      input: params,
+    });
+  }
+
+  static async disable(params: { code: string }): Promise<void> {
+    await this.callApi({
+      type: Modules.Auth,
+      method: HttpMethod.POST,
+      endpoint: new EndpointCreator({
+        endpoint: Modules.Auth,
+        id: "two-factor",
+        childEndpoint: "disable",
+      }).generate(),
+      input: { code: params.code },
+    });
+  }
+
+  // ============================================================
+  // TOTP
+  // ============================================================
+
+  static async setupTotp(params: { id: string; name: string; accountName: string }): Promise<TotpSetupInterface> {
+    return this.callApi<TotpSetupInterface>({
+      type: Modules.TotpSetup,
+      method: HttpMethod.POST,
+      endpoint: new EndpointCreator({
+        endpoint: Modules.Auth,
+        id: "totp",
+        childEndpoint: "setup",
+      }).generate(),
+      input: params,
+    });
+  }
+
+  static async verifyTotpSetup(params: { id: string; authenticatorId: string; code: string }): Promise<void> {
+    await this.callApi({
+      type: Modules.TotpVerify,
+      method: HttpMethod.POST,
+      endpoint: new EndpointCreator({
+        endpoint: Modules.Auth,
+        id: "totp",
+        childEndpoint: "verify-setup",
+      }).generate(),
+      input: params,
+    });
+  }
+
+  static async listTotpAuthenticators(): Promise<TotpAuthenticatorInterface[]> {
+    return this.callApi<TotpAuthenticatorInterface[]>({
+      type: Modules.TotpAuthenticator,
+      method: HttpMethod.GET,
+      endpoint: new EndpointCreator({
+        endpoint: Modules.Auth,
+        id: "totp",
+        childEndpoint: "authenticators",
+      }).generate(),
+    });
+  }
+
+  static async deleteTotpAuthenticator(params: { id: string }): Promise<void> {
+    await this.callApi({
+      type: Modules.Auth,
+      method: HttpMethod.DELETE,
+      endpoint: new EndpointCreator({
+        endpoint: Modules.Auth,
+        id: "totp",
+        childEndpoint: "authenticators",
+        childId: params.id,
+      }).generate(),
+    });
+  }
+
+  // ============================================================
+  // Passkeys
+  // ============================================================
+
+  static async getPasskeyRegistrationOptions(params: {
+    id: string;
+    userName: string;
+    userDisplayName?: string;
+  }): Promise<PasskeyRegistrationOptionsInterface> {
+    return this.callApi<PasskeyRegistrationOptionsInterface>({
+      type: Modules.PasskeyRegistrationOptions,
+      method: HttpMethod.POST,
+      endpoint: new EndpointCreator({
+        endpoint: Modules.Auth,
+        id: "passkey",
+        childEndpoint: "register",
+        childId: "options",
+      }).generate(),
+      input: params,
+    });
+  }
+
+  static async verifyPasskeyRegistration(params: {
+    id: string;
+    pendingId: string;
+    name: string;
+    response: RegistrationResponseJSON;
+  }): Promise<PasskeyInterface> {
+    return this.callApi<PasskeyInterface>({
+      type: Modules.PasskeyRegistrationVerify,
+      method: HttpMethod.POST,
+      endpoint: new EndpointCreator({
+        endpoint: Modules.Auth,
+        id: "passkey",
+        childEndpoint: "register",
+        childId: "verify",
+      }).generate(),
+      input: params,
+    });
+  }
+
+  static async listPasskeys(): Promise<PasskeyInterface[]> {
+    return this.callApi<PasskeyInterface[]>({
+      type: Modules.Passkey,
+      method: HttpMethod.GET,
+      endpoint: new EndpointCreator({
+        endpoint: Modules.Auth,
+        id: "passkeys",
+      }).generate(),
+    });
+  }
+
+  static async deletePasskey(params: { id: string }): Promise<void> {
+    await this.callApi({
+      type: Modules.Auth,
+      method: HttpMethod.DELETE,
+      endpoint: new EndpointCreator({
+        endpoint: Modules.Auth,
+        id: "passkeys",
+        childEndpoint: params.id,
+      }).generate(),
+    });
+  }
+
+  static async renamePasskey(params: { id: string; name: string }): Promise<PasskeyInterface> {
+    return this.callApi<PasskeyInterface>({
+      type: Modules.PasskeyRename,
+      method: HttpMethod.PATCH,
+      endpoint: new EndpointCreator({
+        endpoint: Modules.Auth,
+        id: "passkeys",
+        childEndpoint: params.id,
+      }).generate(),
+      input: { id: params.id, name: params.name },
+    });
+  }
+
+  // ============================================================
+  // Backup Codes
+  // ============================================================
+
+  static async generateBackupCodes(): Promise<string[]> {
+    const response = await this.callApi<{ codes: string[] }>({
+      type: Modules.Auth,
+      method: HttpMethod.POST,
+      endpoint: new EndpointCreator({
+        endpoint: Modules.Auth,
+        id: "backup-codes",
+        childEndpoint: "generate",
+      }).generate(),
+    });
+    return response.codes;
+  }
+
+  static async getBackupCodesCount(): Promise<number> {
+    const response = await this.callApi<{ count: number }>({
+      type: Modules.Auth,
+      method: HttpMethod.GET,
+      endpoint: new EndpointCreator({
+        endpoint: Modules.Auth,
+        id: "backup-codes",
+        childEndpoint: "count",
+      }).generate(),
+    });
+    return response.count;
+  }
+
+  // ============================================================
+  // Login 2FA Verification
+  // ============================================================
+
+  private static async handleSuccessfulAuth(auth: AuthInterface): Promise<AuthInterface> {
+    const handler = getTokenHandler();
+    if (handler) {
+      await handler.updateToken({
+        token: auth.token,
+        refreshToken: auth.refreshToken,
+        userId: auth.user.id,
+        companyId: auth.user.company?.id,
+        roles: auth.user.roles.map((role) => role.id),
+        features: auth.user.company?.features?.map((feature) => feature.id) ?? [],
+        modules: auth.user.modules.map((module) => ({
+          id: module.id,
+          permissions: module.permissions,
+        })),
+      });
+    }
+
+    return auth;
+  }
+
+  static async getChallenge(params: {
+    id: string;
+    pendingToken: string;
+    method: "totp" | "passkey" | "backup";
+  }): Promise<TwoFactorChallengeInterface> {
+    return this.callApi<TwoFactorChallengeInterface>({
+      type: Modules.TwoFactorChallenge,
+      method: HttpMethod.POST,
+      endpoint: new EndpointCreator({
+        endpoint: Modules.Auth,
+        id: "two-factor",
+        childEndpoint: "challenge",
+      }).generate(),
+      input: { id: params.id, method: params.method },
+    });
+  }
+
+  static async verifyTotp(params: { id: string; pendingToken: string; code: string }): Promise<AuthInterface> {
+    const auth = await this.callApi<AuthInterface>({
+      type: Modules.TotpVerifyLogin, // Request: { type: "totp-authenticators", attributes: { code } }
+      responseType: Modules.Auth, // Response: Auth with user relationship
+      method: HttpMethod.POST,
+      endpoint: new EndpointCreator({
+        endpoint: Modules.Auth,
+        id: "two-factor",
+        childEndpoint: "verify",
+        childId: "totp",
+      }).generate(),
+      input: { id: params.id, code: params.code },
+      token: params.pendingToken,
+    });
+
+    return this.handleSuccessfulAuth(auth);
+  }
+
+  static async getPasskeyAuthOptions(params: { pendingToken: string }): Promise<PasskeyAuthenticationOptionsInterface> {
+    return this.callApi<PasskeyAuthenticationOptionsInterface>({
+      type: Modules.PasskeyAuthenticationOptions,
+      method: HttpMethod.POST,
+      endpoint: new EndpointCreator({
+        endpoint: Modules.Auth,
+        id: "two-factor",
+        childEndpoint: "verify/passkey",
+        childId: "options",
+      }).generate(),
+      token: params.pendingToken,
+    });
+  }
+
+  static async verifyPasskey(params: {
+    id: string;
+    pendingToken: string;
+    pendingId: string;
+    credential: AuthenticationResponseJSON;
+  }): Promise<AuthInterface> {
+    const auth = await this.callApi<AuthInterface>({
+      type: Modules.PasskeyVerifyLogin, // Request: passkey verification format
+      responseType: Modules.Auth, // Response: Auth with user relationship
+      method: HttpMethod.POST,
+      endpoint: new EndpointCreator({
+        endpoint: Modules.Auth,
+        id: "two-factor",
+        childEndpoint: "verify",
+        childId: "passkey",
+      }).generate(),
+      input: { id: params.id, pendingId: params.pendingId, response: params.credential },
+      token: params.pendingToken,
+    });
+
+    return this.handleSuccessfulAuth(auth);
+  }
+
+  static async verifyBackupCode(params: { id: string; pendingToken: string; code: string }): Promise<AuthInterface> {
+    const auth = await this.callApi<AuthInterface>({
+      type: Modules.BackupCodeVerify, // Request: backup code verification format
+      responseType: Modules.Auth, // Response: Auth with user relationship
+      method: HttpMethod.POST,
+      endpoint: new EndpointCreator({
+        endpoint: Modules.Auth,
+        id: "two-factor",
+        childEndpoint: "verify",
+        childId: "backup",
+      }).generate(),
+      input: { id: params.id, code: params.code },
+      token: params.pendingToken,
+    });
+
+    return this.handleSuccessfulAuth(auth);
+  }
+}

package/src/features/auth/enums/AuthComponent.ts

@@ -6,4 +6,5 @@ export enum AuthComponent {
   AcceptInvitation,
   Register,
   Landing,
+  TwoFactorChallenge = "2fa_challenge",
 }

package/src/features/auth/index.ts

@@ -1,4 +1,17 @@
 export * from "./auth.module";
+export * from "./totp-authenticator.module";
+export * from "./totp-setup.module";
+export * from "./totp-verify.module";
+export * from "./totp-verify-login.module";
+export * from "./passkey.module";
+export * from "./passkey-registration-options.module";
+export * from "./passkey-registration-verify.module";
+export * from "./passkey-rename.module";
+export * from "./passkey-verify-login.module";
+export * from "./passkey-authentication-options.module";
+export * from "./two-factor-enable.module";
+export * from "./two-factor-challenge.module";
+export * from "./backup-code-verify.module";
 export { configureAuth, type TokenHandler, type TokenParams } from "./config";
 export * from "./data";
 export * from "./enums";

package/src/features/auth/passkey-authentication-options.module.ts

@@ -0,0 +1,9 @@
+import { ModuleFactory } from "../../permissions";
+import { PasskeyAuthenticationOptions } from "./data/passkey-authentication-options";
+
+export const PasskeyAuthenticationOptionsModule = (factory: ModuleFactory) =>
+  factory({
+    name: "passkey-authentication-options",
+    pageUrl: "/passkeys",
+    model: PasskeyAuthenticationOptions,
+  });

package/src/features/auth/passkey-registration-options.module.ts

@@ -0,0 +1,9 @@
+import { ModuleFactory } from "../../permissions";
+import { PasskeyRegistrationOptions } from "./data/passkey-registration-options";
+
+export const PasskeyRegistrationOptionsModule = (factory: ModuleFactory) =>
+  factory({
+    name: "passkey-registration-options",
+    pageUrl: "/passkeys",
+    model: PasskeyRegistrationOptions,
+  });

package/src/features/auth/passkey-registration-verify.module.ts

@@ -0,0 +1,9 @@
+import { ModuleFactory } from "../../permissions";
+import { PasskeyRegistrationVerify } from "./data/passkey-registration-verify";
+
+export const PasskeyRegistrationVerifyModule = (factory: ModuleFactory) =>
+  factory({
+    name: "passkey-registration-verify",
+    pageUrl: "/passkeys",
+    model: PasskeyRegistrationVerify,
+  });

package/src/features/auth/passkey-rename.module.ts

@@ -0,0 +1,9 @@
+import { ModuleFactory } from "../../permissions";
+import { PasskeyRename } from "./data/passkey-rename";
+
+export const PasskeyRenameModule = (factory: ModuleFactory) =>
+  factory({
+    name: "passkey-rename",
+    pageUrl: "/passkeys-rename",
+    model: PasskeyRename,
+  });

package/src/features/auth/passkey-verify-login.module.ts

@@ -0,0 +1,9 @@
+import { ModuleFactory } from "../../permissions";
+import { PasskeyVerifyLogin } from "./data/passkey-verify-login";
+
+export const PasskeyVerifyLoginModule = (factory: ModuleFactory) =>
+  factory({
+    name: "passkey-verify-login",
+    pageUrl: "/passkeys",
+    model: PasskeyVerifyLogin,
+  });

package/src/features/auth/passkey.module.ts

@@ -0,0 +1,9 @@
+import { ModuleFactory } from "../../permissions";
+import { Passkey } from "./data/passkey";
+
+export const PasskeyModule = (factory: ModuleFactory) =>
+  factory({
+    name: "passkeys",
+    pageUrl: "/passkeys",
+    model: Passkey,
+  });

package/src/features/auth/totp-authenticator.module.ts

@@ -0,0 +1,9 @@
+import { ModuleFactory } from "../../permissions";
+import { TotpAuthenticator } from "./data/totp-authenticator";
+
+export const TotpAuthenticatorModule = (factory: ModuleFactory) =>
+  factory({
+    name: "totp-authenticators",
+    pageUrl: "/totp-authenticators",
+    model: TotpAuthenticator,
+  });

package/src/features/auth/totp-setup.module.ts

@@ -0,0 +1,9 @@
+import { ModuleFactory } from "../../permissions";
+import { TotpSetup } from "./data/totp-setup";
+
+export const TotpSetupModule = (factory: ModuleFactory) =>
+  factory({
+    name: "totp-setup",
+    pageUrl: "/totp-setup",
+    model: TotpSetup,
+  });

package/src/features/auth/totp-verify-login.module.ts

@@ -0,0 +1,9 @@
+import { ModuleFactory } from "../../permissions";
+import { TotpVerifyLogin } from "./data/totp-verify-login";
+
+export const TotpVerifyLoginModule = (factory: ModuleFactory) =>
+  factory({
+    name: "totp-verify-login",
+    pageUrl: "/totp-verify-login",
+    model: TotpVerifyLogin,
+  });

package/src/features/auth/totp-verify.module.ts

@@ -0,0 +1,9 @@
+import { ModuleFactory } from "../../permissions";
+import { TotpVerify } from "./data/totp-verify";
+
+export const TotpVerifyModule = (factory: ModuleFactory) =>
+  factory({
+    name: "totp-verify",
+    pageUrl: "/totp-verify",
+    model: TotpVerify,
+  });

package/src/features/auth/two-factor-challenge.module.ts

@@ -0,0 +1,9 @@
+import { ModuleFactory } from "../../permissions";
+import { TwoFactorChallenge } from "./data/two-factor-challenge";
+
+export const TwoFactorChallengeModule = (factory: ModuleFactory) =>
+  factory({
+    name: "two-factor-challenge",
+    pageUrl: "/two-factor-challenge",
+    model: TwoFactorChallenge,
+  });

package/src/features/auth/two-factor-enable.module.ts

@@ -0,0 +1,9 @@
+import { ModuleFactory } from "../../permissions";
+import { TwoFactorEnable } from "./data/two-factor-enable";
+
+export const TwoFactorEnableModule = (factory: ModuleFactory) =>
+  factory({
+    name: "two-factor-enable",
+    pageUrl: "/two-factor-enable",
+    model: TwoFactorEnable,
+  });

package/src/features/auth/two-factor-status.module.ts

@@ -0,0 +1,9 @@
+import { ModuleFactory } from "../../permissions";
+import { TwoFactorStatus } from "./data/two-factor-status";
+
+export const TwoFactorStatusModule = (factory: ModuleFactory) =>
+  factory({
+    name: "two-factor-status",
+    pageUrl: "/two-factor-status",
+    model: TwoFactorStatus,
+  });

package/src/features/billing/modules/billing.module.ts

@@ -4,6 +4,7 @@ import { Billing } from "../data/Billing";
 export const BillingModule = (factory: ModuleFactory) =>
   factory({
     name: "billing",
+    pageUrl: "/billing",
     model: Billing,
     moduleId: "3266b307-5a9a-46f9-b78d-631f672f8735",
   });

package/src/features/billing/stripe-customer/stripe-customer.module.ts

@@ -4,6 +4,7 @@ import { StripeCustomer } from "./data";
 export const StripeCustomerModule = (factory: ModuleFactory) =>
   factory({
     name: "stripe-customers",
+    pageUrl: "/stripe-customers",
     model: StripeCustomer,
     moduleId: "25a80cb3-bf18-47fd-963a-639212519920",
   });

package/src/features/billing/stripe-customer/stripe-payment-method.module.ts

@@ -4,6 +4,7 @@ import { PaymentMethod } from "./data/payment-method";
 export const StripePaymentMethodModule = (factory: ModuleFactory) =>
   factory({
     name: "stripe-payment-methods",
+    pageUrl: "/stripe-payment-methods",
     model: PaymentMethod,
     moduleId: "e8f7d6c5-b4a3-4928-8170-1f2e3d4c5b6a",
   });