react-native-authsignal 2.6.1 → 2.8.0-alpha.1

package/src/sms.web.ts

@@ -0,0 +1,107 @@
+import { getOrCreateWebClient } from './web-client';
+import { handleErrorCodes } from './error';
+import type { AuthsignalResponse, VerifyInput, VerifyResponse } from './types';
+
+interface ConstructorArgs {
+  tenantID: string;
+  baseURL: string;
+  enableLogging: boolean;
+}
+
+interface EnrollSmsInput {
+  phoneNumber: string;
+}
+
+export class AuthsignalSms {
+  tenantID: string;
+  baseURL: string;
+  enableLogging: boolean;
+
+  constructor({ tenantID, baseURL, enableLogging }: ConstructorArgs) {
+    this.tenantID = tenantID;
+    this.baseURL = baseURL;
+    this.enableLogging = enableLogging;
+  }
+
+  async enroll({
+    phoneNumber,
+  }: EnrollSmsInput): Promise<AuthsignalResponse<void>> {
+    try {
+      const client = this.getClient();
+      const result = await client.sms.enroll({ phoneNumber });
+
+      if (result.errorCode) {
+        return {
+          error: result.errorDescription ?? result.error,
+          errorCode: result.errorCode,
+        };
+      }
+
+      return {};
+    } catch (ex) {
+      return this.handleError(ex);
+    }
+  }
+
+  async challenge(): Promise<AuthsignalResponse<void>> {
+    try {
+      const client = this.getClient();
+      const result = await client.sms.challenge();
+
+      if (result.errorCode) {
+        return {
+          error: result.errorDescription ?? result.error,
+          errorCode: result.errorCode,
+        };
+      }
+
+      return {};
+    } catch (ex) {
+      return this.handleError(ex);
+    }
+  }
+
+  async verify({
+    code,
+  }: VerifyInput): Promise<AuthsignalResponse<VerifyResponse>> {
+    try {
+      const client = this.getClient();
+      const result = await client.sms.verify({ code });
+
+      if (result.errorCode) {
+        return {
+          error: result.errorDescription ?? result.error,
+          errorCode: result.errorCode,
+        };
+      }
+
+      return {
+        data: result.data
+          ? {
+              isVerified: result.data.isVerified,
+              token: result.data.token,
+              failureReason: result.data.failureReason,
+            }
+          : undefined,
+      };
+    } catch (ex) {
+      return this.handleError(ex);
+    }
+  }
+
+  private getClient() {
+    return getOrCreateWebClient({
+      tenantID: this.tenantID,
+      baseURL: this.baseURL,
+      enableLogging: this.enableLogging,
+    });
+  }
+
+  private handleError(ex: unknown) {
+    if (this.enableLogging) {
+      console.log(ex);
+    }
+
+    return handleErrorCodes(ex);
+  }
+}

package/src/totp.ts

@@ -0,0 +1,79 @@
+import { handleErrorCodes } from './error';
+import { getNativeModule } from './getNativeModule';
+import NativeAuthsignalTOTPModule, {
+  type Spec as AuthsignalTOTPModuleSpec,
+} from './NativeAuthsignalTOTPModule';
+import type { AuthsignalResponse, VerifyInput, VerifyResponse } from './types';
+
+interface ConstructorArgs {
+  tenantID: string;
+  baseURL: string;
+  enableLogging: boolean;
+}
+
+interface EnrollTotpResponse {
+  uri: string;
+  secret: string;
+}
+
+const AuthsignalTOTPModule = getNativeModule<AuthsignalTOTPModuleSpec>(
+  'AuthsignalTOTPModule',
+  NativeAuthsignalTOTPModule
+);
+
+export class AuthsignalTotp {
+  tenantID: string;
+  baseURL: string;
+  enableLogging: boolean;
+  private initialized = false;
+
+  constructor({ tenantID, baseURL, enableLogging }: ConstructorArgs) {
+    this.tenantID = tenantID;
+    this.baseURL = baseURL;
+    this.enableLogging = enableLogging;
+  }
+
+  async enroll(): Promise<AuthsignalResponse<EnrollTotpResponse>> {
+    await this.ensureModuleIsInitialized();
+
+    try {
+      const data = (await AuthsignalTOTPModule.enroll()) as EnrollTotpResponse;
+
+      return { data };
+    } catch (ex) {
+      return this.handleError(ex);
+    }
+  }
+
+  async verify({
+    code,
+  }: VerifyInput): Promise<AuthsignalResponse<VerifyResponse>> {
+    await this.ensureModuleIsInitialized();
+
+    try {
+      const data = (await AuthsignalTOTPModule.verify(code)) as VerifyResponse;
+
+      return { data };
+    } catch (ex) {
+      return this.handleError(ex);
+    }
+  }
+
+  private async ensureModuleIsInitialized() {
+    if (this.initialized) {
+      return;
+    }
+
+    await AuthsignalTOTPModule.initialize(this.tenantID, this.baseURL);
+
+    this.initialized = true;
+  }
+
+  private handleError(ex: unknown) {
+    if (this.enableLogging) {
+      console.log(ex);
+    }
+
+    return handleErrorCodes(ex);
+  }
+}

package/src/totp.web.ts

@@ -0,0 +1,95 @@
+import { getOrCreateWebClient } from './web-client';
+import { handleErrorCodes } from './error';
+import type { AuthsignalResponse, VerifyInput, VerifyResponse } from './types';
+
+interface ConstructorArgs {
+  tenantID: string;
+  baseURL: string;
+  enableLogging: boolean;
+}
+
+interface EnrollTotpResponse {
+  uri: string;
+  secret: string;
+}
+
+export class AuthsignalTotp {
+  tenantID: string;
+  baseURL: string;
+  enableLogging: boolean;
+
+  constructor({ tenantID, baseURL, enableLogging }: ConstructorArgs) {
+    this.tenantID = tenantID;
+    this.baseURL = baseURL;
+    this.enableLogging = enableLogging;
+  }
+
+  async enroll(): Promise<AuthsignalResponse<EnrollTotpResponse>> {
+    try {
+      const client = this.getClient();
+      const result = await client.totp.enroll();
+
+      if (result.errorCode) {
+        return {
+          error: result.errorDescription ?? result.error,
+          errorCode: result.errorCode,
+        };
+      }
+
+      return {
+        data: result.data
+          ? {
+              uri: result.data.uri,
+              secret: result.data.secret,
+            }
+          : undefined,
+      };
+    } catch (ex) {
+      return this.handleError(ex);
+    }
+  }
+
+  async verify({
+    code,
+  }: VerifyInput): Promise<AuthsignalResponse<VerifyResponse>> {
+    try {
+      const client = this.getClient();
+      const result = await client.totp.verify({ code });
+
+      if (result.errorCode) {
+        return {
+          error: result.errorDescription ?? result.error,
+          errorCode: result.errorCode,
+        };
+      }
+
+      return {
+        data: result.data
+          ? {
+              isVerified: result.data.isVerified,
+              token: result.data.token,
+              failureReason: result.data.failureReason,
+            }
+          : undefined,
+      };
+    } catch (ex) {
+      return this.handleError(ex);
+    }
+  }
+
+  private getClient() {
+    return getOrCreateWebClient({
+      tenantID: this.tenantID,
+      baseURL: this.baseURL,
+      enableLogging: this.enableLogging,
+    });
+  }
+
+  private handleError(ex: unknown) {
+    if (this.enableLogging) {
+      console.log(ex);
+    }
+
+    return handleErrorCodes(ex);
+  }
+}

package/src/types.ts

@@ -0,0 +1,167 @@
+import type { ErrorCode } from './error';
+
+export interface AuthsignalResponse<T> {
+  data?: T;
+  error?: string;
+  errorCode?: ErrorCode | string;
+}
+
+export interface TokenPayload {
+  aud: string;
+  exp: number;
+  iat: number;
+  other: {
+    actionCode: string;
+    idempotencyKey: string;
+    publishableKey: string;
+    tenantId: string;
+    userId: string;
+    username: string;
+  };
+  scope?: string;
+  sub: string;
+}
+
+export interface SignUpResponse {
+  token: string;
+}
+
+export interface SignInResponse {
+  isVerified: boolean;
+  token?: string;
+  userId?: string;
+  userAuthenticatorId?: string;
+  username?: string;
+  displayName?: string;
+}
+
+export interface VerifyInput {
+  code: string;
+}
+
+export interface VerifyResponse {
+  isVerified: boolean;
+  token?: string;
+  failureReason?: string;
+}
+
+export enum AppAttestationProvider {
+  apple = 'apple',
+  playIntegrity = 'playIntegrity',
+}
+
+export interface AppAttestation {
+  provider: AppAttestationProvider;
+  token: string;
+  keyId?: string;
+}
+
+export interface AddCredentialInput {
+  token?: string;
+  requireUserAuthentication?: boolean;
+  keychainAccess?: KeychainAccess;
+  appAttestation?: AppAttestation;
+}
+
+export interface AppChallenge {
+  challengeId: string;
+  actionCode?: string;
+  idempotencyKey?: string;
+  userAgent?: string;
+  deviceId?: string;
+  ipAddress?: string;
+}
+
+export interface AppCredential {
+  credentialId: string;
+  createdAt: string;
+  userId: string;
+  lastAuthenticatedAt?: string;
+}
+
+export interface ClaimChallengeInput {
+  challengeId: string;
+}
+
+export interface ClaimChallengeResponse {
+  success: boolean;
+  userAgent?: string;
+  ipAddress?: string;
+  actionCode?: string;
+  idempotencyKey?: string;
+}
+
+export interface UpdateChallengeInput {
+  challengeId: string;
+  approved: boolean;
+  verificationCode?: string | null;
+}
+
+export interface InAppGetCredentialInput {
+  username?: string;
+}
+
+export interface InAppAddCredentialInput extends AddCredentialInput {
+  username?: string;
+}
+
+export interface InAppRemoveCredentialInput {
+  username?: string;
+}
+
+export interface InAppVerifyInput {
+  action?: string;
+  username?: string;
+}
+
+export interface InAppVerifyResponse {
+  token: string;
+  userId: string;
+  userAuthenticatorId: string;
+  username?: string;
+}
+
+export interface CreatePinInput {
+  pin: string;
+  username: string;
+  token?: string;
+}
+
+export interface VerifyPinInput {
+  pin: string;
+  username: string;
+  action?: string;
+}
+
+export interface VerifyPinResponse {
+  isVerified: boolean;
+  token?: string;
+  userId?: string;
+}
+
+export interface DeletePinInput {
+  username: string;
+}
+
+export interface LaunchOptions {
+  mode?: 'popup' | 'redirect';
+}
+
+export enum KeychainAccess {
+  afterFirstUnlock = 'afterFirstUnlock',
+  afterFirstUnlockThisDeviceOnly = 'afterFirstUnlockThisDeviceOnly',
+  whenUnlocked = 'whenUnlocked',
+  whenUnlockedThisDeviceOnly = 'whenUnlockedThisDeviceOnly',
+  whenPasscodeSetThisDeviceOnly = 'whenPasscodeSetThisDeviceOnly',
+}
+
+export enum UserActionState {
+  ALLOW = 'ALLOW',
+  BLOCK = 'BLOCK',
+  CHALLENGE_REQUIRED = 'CHALLENGE_REQUIRED',
+  CHALLENGE_SUCCEEDED = 'CHALLENGE_SUCCEEDED',
+  CHALLENGE_FAILED = 'CHALLENGE_FAILED',
+  REVIEW_REQUIRED = 'REVIEW_REQUIRED',
+  REVIEW_SUCCEEDED = 'REVIEW_SUCCEEDED',
+  REVIEW_FAILED = 'REVIEW_FAILED',
+}

package/src/web-client.ts

@@ -0,0 +1,29 @@
+import { Authsignal as AuthsignalBrowser } from '@authsignal/browser';
+
+let client: AuthsignalBrowser | null = null;
+let currentTenantID: string | null = null;
+let currentBaseURL: string | null = null;
+
+interface WebClientConfig {
+  tenantID: string;
+  baseURL: string;
+  enableLogging?: boolean;
+}
+
+export function getOrCreateWebClient({
+  tenantID,
+  baseURL,
+  enableLogging = false,
+}: WebClientConfig): AuthsignalBrowser {
+  if (!client || tenantID !== currentTenantID || baseURL !== currentBaseURL) {
+    client = new AuthsignalBrowser({
+      tenantId: tenantID,
+      baseUrl: baseURL,
+      enableLogging,
+    });
+    currentTenantID = tenantID;
+    currentBaseURL = baseURL;
+  }
+
+  return client;
+}

package/src/whatsapp.ts

@@ -0,0 +1,76 @@
+import { handleErrorCodes } from './error';
+import { getNativeModule } from './getNativeModule';
+import NativeAuthsignalWhatsappModule, {
+  type Spec as AuthsignalWhatsappModuleSpec,
+} from './NativeAuthsignalWhatsappModule';
+import type { AuthsignalResponse, VerifyInput, VerifyResponse } from './types';
+
+interface ConstructorArgs {
+  tenantID: string;
+  baseURL: string;
+  enableLogging: boolean;
+}
+
+const AuthsignalWhatsappModule = getNativeModule<AuthsignalWhatsappModuleSpec>(
+  'AuthsignalWhatsappModule',
+  NativeAuthsignalWhatsappModule
+);
+
+export class AuthsignalWhatsapp {
+  tenantID: string;
+  baseURL: string;
+  enableLogging: boolean;
+  private initialized = false;
+
+  constructor({ tenantID, baseURL, enableLogging }: ConstructorArgs) {
+    this.tenantID = tenantID;
+    this.baseURL = baseURL;
+    this.enableLogging = enableLogging;
+  }
+
+  async challenge(): Promise<AuthsignalResponse<void>> {
+    await this.ensureModuleIsInitialized();
+
+    try {
+      await AuthsignalWhatsappModule.challenge();
+
+      return {};
+    } catch (ex) {
+      return this.handleError(ex);
+    }
+  }
+
+  async verify({
+    code,
+  }: VerifyInput): Promise<AuthsignalResponse<VerifyResponse>> {
+    await this.ensureModuleIsInitialized();
+
+    try {
+      const data = (await AuthsignalWhatsappModule.verify(
+        code
+      )) as VerifyResponse;
+
+      return { data };
+    } catch (ex) {
+      return this.handleError(ex);
+    }
+  }
+
+  private async ensureModuleIsInitialized() {
+    if (this.initialized) {
+      return;
+    }
+
+    await AuthsignalWhatsappModule.initialize(this.tenantID, this.baseURL);
+
+    this.initialized = true;
+  }
+
+  private handleError(ex: unknown) {
+    if (this.enableLogging) {
+      console.log(ex);
+    }
+
+    return handleErrorCodes(ex);
+  }
+}

package/src/whatsapp.web.ts

@@ -0,0 +1,83 @@
+import { getOrCreateWebClient } from './web-client';
+import { handleErrorCodes } from './error';
+import type { AuthsignalResponse, VerifyInput, VerifyResponse } from './types';
+
+interface ConstructorArgs {
+  tenantID: string;
+  baseURL: string;
+  enableLogging: boolean;
+}
+
+export class AuthsignalWhatsapp {
+  tenantID: string;
+  baseURL: string;
+  enableLogging: boolean;
+
+  constructor({ tenantID, baseURL, enableLogging }: ConstructorArgs) {
+    this.tenantID = tenantID;
+    this.baseURL = baseURL;
+    this.enableLogging = enableLogging;
+  }
+
+  async challenge(): Promise<AuthsignalResponse<void>> {
+    try {
+      const client = this.getClient();
+      const result = await client.whatsapp.challenge();
+
+      if (result.errorCode) {
+        return {
+          error: result.errorDescription ?? result.error,
+          errorCode: result.errorCode,
+        };
+      }
+
+      return {};
+    } catch (ex) {
+      return this.handleError(ex);
+    }
+  }
+
+  async verify({
+    code,
+  }: VerifyInput): Promise<AuthsignalResponse<VerifyResponse>> {
+    try {
+      const client = this.getClient();
+      const result = await client.whatsapp.verify({ code });
+
+      if (result.errorCode) {
+        return {
+          error: result.errorDescription ?? result.error,
+          errorCode: result.errorCode,
+        };
+      }
+
+      return {
+        data: result.data
+          ? {
+              isVerified: result.data.isVerified,
+              token: result.data.token,
+              failureReason: result.data.failureReason,
+            }
+          : undefined,
+      };
+    } catch (ex) {
+      return this.handleError(ex);
+    }
+  }
+
+  private getClient() {
+    return getOrCreateWebClient({
+      tenantID: this.tenantID,
+      baseURL: this.baseURL,
+      enableLogging: this.enableLogging,
+    });
+  }
+
+  private handleError(ex: unknown) {
+    if (this.enableLogging) {
+      console.log(ex);
+    }
+
+    return handleErrorCodes(ex);
+  }
+}