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

package/src/email.web.ts

@@ -0,0 +1,105 @@
+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 EnrollEmailInput {
+  email: string;
+}
+
+export class AuthsignalEmail {
+  tenantID: string;
+  baseURL: string;
+  enableLogging: boolean;
+
+  constructor({ tenantID, baseURL, enableLogging }: ConstructorArgs) {
+    this.tenantID = tenantID;
+    this.baseURL = baseURL;
+    this.enableLogging = enableLogging;
+  }
+
+  async enroll({ email }: EnrollEmailInput): Promise<AuthsignalResponse<void>> {
+    try {
+      const client = this.getClient();
+      const result = await client.email.enroll({ email });
+
+      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.email.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.email.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/error.ts

@@ -0,0 +1,28 @@
+import { Platform } from 'react-native';
+
+export const LINKING_ERROR =
+  `The package 'react-native-authsignal' doesn't seem to be linked. Make sure: \n\n` +
+  Platform.select({ ios: "- You have run 'pod install'\n", default: '' }) +
+  '- You rebuilt the app after installing the package\n' +
+  '- You are not using Expo Go\n';
+
+export enum ErrorCode {
+  user_canceled = 'user_canceled',
+  no_credential = 'no_credential',
+  matched_excluded_credential = 'matched_excluded_credential',
+  token_not_set = 'token_not_set',
+  token_required = 'token_required',
+  token_invalid = 'token_invalid',
+}
+
+export function handleErrorCodes(ex: any) {
+  return {
+    error: ex.message,
+    errorCode: ex.code,
+  } as ErrorResponse;
+}
+
+interface ErrorResponse {
+  error: string;
+  errorCode: string;
+}

package/src/error.web.ts

@@ -0,0 +1,21 @@
+export enum ErrorCode {
+  token_not_set = 'token_not_set',
+  token_required = 'token_required',
+  token_invalid = 'token_invalid',
+}
+
+export function handleErrorCodes(ex: any) {
+  const message =
+    ex?.errorDescription ?? ex?.message ?? ex?.error ?? String(ex);
+  const code = ex?.errorCode ?? ex?.code ?? undefined;
+
+  return {
+    error: message,
+    errorCode: code,
+  } as ErrorResponse;
+}
+
+interface ErrorResponse {
+  error: string;
+  errorCode: string;
+}

package/src/getNativeModule.ts

@@ -0,0 +1,28 @@
+import { NativeModules } from 'react-native';
+import { LINKING_ERROR } from './error';
+
+export function getNativeModule<Spec>(
+  moduleName: string,
+  turboModule: Spec | null
+): Spec {
+  if (turboModule != null) {
+    return turboModule;
+  }
+
+  const legacyModule = (NativeModules as Record<string, Spec | undefined>)[
+    moduleName
+  ];
+
+  if (legacyModule != null) {
+    return legacyModule;
+  }
+
+  return new Proxy(
+    {},
+    {
+      get() {
+        throw new Error(LINKING_ERROR);
+      },
+    }
+  ) as Spec;
+}

package/src/inapp.ts

@@ -0,0 +1,220 @@
+import { handleErrorCodes } from './error';
+import { getNativeModule } from './getNativeModule';
+import NativeAuthsignalInAppModule, {
+  type Spec as AuthsignalInAppModuleSpec,
+} from './NativeAuthsignalInAppModule';
+import type {
+  AuthsignalResponse,
+  AppCredential,
+  InAppVerifyInput,
+  InAppVerifyResponse,
+  InAppAddCredentialInput,
+  InAppGetCredentialInput,
+  InAppRemoveCredentialInput,
+  CreatePinInput,
+  VerifyPinInput,
+  VerifyPinResponse,
+  DeletePinInput,
+} from './types';
+
+interface ConstructorArgs {
+  tenantID: string;
+  baseURL: string;
+  enableLogging: boolean;
+}
+
+const AuthsignalInAppModule = getNativeModule<AuthsignalInAppModuleSpec>(
+  'AuthsignalInAppModule',
+  NativeAuthsignalInAppModule
+);
+
+export class AuthsignalInApp {
+  tenantID: string;
+  baseURL: string;
+  enableLogging: boolean;
+  private initialized = false;
+
+  constructor({ tenantID, baseURL, enableLogging }: ConstructorArgs) {
+    this.tenantID = tenantID;
+    this.baseURL = baseURL;
+    this.enableLogging = enableLogging;
+  }
+
+  async getCredential({
+    username,
+  }: InAppGetCredentialInput): Promise<
+    AuthsignalResponse<AppCredential | undefined>
+  > {
+    await this.ensureModuleIsInitialized();
+
+    try {
+      const data = (await AuthsignalInAppModule.getCredential(
+        username ?? null
+      )) as AppCredential | undefined;
+
+      return { data };
+    } catch (ex) {
+      if (this.enableLogging) {
+        console.log(ex);
+      }
+
+      return handleErrorCodes(ex);
+    }
+  }
+
+  async addCredential({
+    token,
+    requireUserAuthentication = false,
+    keychainAccess,
+    username,
+    appAttestation,
+  }: InAppAddCredentialInput = {}): Promise<AuthsignalResponse<AppCredential>> {
+    await this.ensureModuleIsInitialized();
+
+    try {
+      const data = (await AuthsignalInAppModule.addCredential(
+        token ?? null,
+        requireUserAuthentication,
+        keychainAccess ?? null,
+        username ?? null,
+        appAttestation ?? null
+      )) as AppCredential;
+
+      return { data };
+    } catch (ex) {
+      if (this.enableLogging) {
+        console.log(ex);
+      }
+
+      return handleErrorCodes(ex);
+    }
+  }
+
+  async removeCredential({
+    username,
+  }: InAppRemoveCredentialInput): Promise<AuthsignalResponse<boolean>> {
+    await this.ensureModuleIsInitialized();
+
+    try {
+      const data = await AuthsignalInAppModule.removeCredential(
+        username ?? null
+      );
+      return { data };
+    } catch (ex) {
+      if (this.enableLogging) {
+        console.log(ex);
+      }
+
+      return handleErrorCodes(ex);
+    }
+  }
+
+  async verify({ action, username }: InAppVerifyInput = {}): Promise<
+    AuthsignalResponse<InAppVerifyResponse>
+  > {
+    await this.ensureModuleIsInitialized();
+
+    try {
+      const data = (await AuthsignalInAppModule.verify(
+        action ?? null,
+        username ?? null
+      )) as InAppVerifyResponse;
+
+      return { data };
+    } catch (ex) {
+      if (this.enableLogging) {
+        console.log(ex);
+      }
+
+      return handleErrorCodes(ex);
+    }
+  }
+
+  async createPin({
+    pin,
+    username,
+    token,
+  }: CreatePinInput): Promise<AuthsignalResponse<AppCredential>> {
+    await this.ensureModuleIsInitialized();
+
+    try {
+      const data = (await AuthsignalInAppModule.createPin(
+        pin,
+        username,
+        token ?? null
+      )) as AppCredential;
+      return { data };
+    } catch (ex) {
+      if (this.enableLogging) {
+        console.log(ex);
+      }
+
+      return handleErrorCodes(ex);
+    }
+  }
+
+  async verifyPin({
+    pin,
+    username,
+    action,
+  }: VerifyPinInput): Promise<AuthsignalResponse<VerifyPinResponse>> {
+    await this.ensureModuleIsInitialized();
+
+    try {
+      const data = (await AuthsignalInAppModule.verifyPin(
+        pin,
+        username,
+        action ?? null
+      )) as VerifyPinResponse;
+      return { data };
+    } catch (ex) {
+      if (this.enableLogging) {
+        console.log(ex);
+      }
+
+      return handleErrorCodes(ex);
+    }
+  }
+
+  async deletePin({
+    username,
+  }: DeletePinInput): Promise<AuthsignalResponse<boolean>> {
+    await this.ensureModuleIsInitialized();
+
+    try {
+      const data = await AuthsignalInAppModule.deletePin(username);
+      return { data };
+    } catch (ex) {
+      if (this.enableLogging) {
+        console.log(ex);
+      }
+
+      return handleErrorCodes(ex);
+    }
+  }
+
+  async getAllPinUsernames(): Promise<AuthsignalResponse<string[]>> {
+    await this.ensureModuleIsInitialized();
+
+    try {
+      const data = await AuthsignalInAppModule.getAllPinUsernames();
+      return { data };
+    } catch (ex) {
+      if (this.enableLogging) {
+        console.log(ex);
+      }
+
+      return handleErrorCodes(ex);
+    }
+  }
+
+  private async ensureModuleIsInitialized() {
+    if (this.initialized) {
+      return;
+    }
+
+    await AuthsignalInAppModule.initialize(this.tenantID, this.baseURL);
+
+    this.initialized = true;
+  }
+}

package/src/index.tsx

@@ -0,0 +1,80 @@
+import { getNativeModule } from './getNativeModule';
+import NativeAuthsignalModule, {
+  type Spec as AuthsignalModuleSpec,
+} from './NativeAuthsignalModule';
+import { AuthsignalEmail } from './email';
+import { AuthsignalPasskey } from './passkey';
+import { AuthsignalPush } from './push';
+import { AuthsignalSms } from './sms';
+import { AuthsignalTotp } from './totp';
+import { AuthsignalQrCode } from './qr';
+import { AuthsignalWhatsapp } from './whatsapp';
+import { AuthsignalInApp } from './inapp';
+import type { LaunchOptions } from './types';
+
+export * from './types';
+export { ErrorCode } from './error';
+
+const AuthsignalModule = getNativeModule<AuthsignalModuleSpec>(
+  'AuthsignalModule',
+  NativeAuthsignalModule
+);
+
+interface ConstructorArgs {
+  tenantID: string;
+  baseURL?: string;
+  deviceID?: string;
+  enableLogging?: boolean;
+}
+
+export class Authsignal {
+  tenantID: string;
+  baseURL: string;
+  enableLogging: boolean;
+
+  email: AuthsignalEmail;
+  passkey: AuthsignalPasskey;
+  push: AuthsignalPush;
+  qr: AuthsignalQrCode;
+  inapp: AuthsignalInApp;
+  sms: AuthsignalSms;
+  totp: AuthsignalTotp;
+  whatsapp: AuthsignalWhatsapp;
+
+  constructor({
+    tenantID,
+    baseURL = 'https://api.authsignal.com/v1',
+    deviceID,
+    enableLogging = __DEV__,
+  }: ConstructorArgs) {
+    this.tenantID = tenantID;
+    this.baseURL = baseURL;
+    this.enableLogging = enableLogging;
+
+    const input = { tenantID, baseURL, deviceID, enableLogging };
+
+    this.passkey = new AuthsignalPasskey(input);
+    this.email = new AuthsignalEmail(input);
+    this.push = new AuthsignalPush(input);
+    this.qr = new AuthsignalQrCode(input);
+    this.inapp = new AuthsignalInApp(input);
+    this.sms = new AuthsignalSms(input);
+    this.totp = new AuthsignalTotp(input);
+    this.whatsapp = new AuthsignalWhatsapp(input);
+  }
+
+  async setToken(token: string): Promise<void> {
+    await AuthsignalModule.setToken(token);
+  }
+
+  async launch(url: string, _options?: LaunchOptions): Promise<string | null> {
+    return await launch(url);
+  }
+}
+
+export function launch(
+  url: string,
+  _options?: LaunchOptions
+): Promise<string | null> {
+  return AuthsignalModule.launch(url);
+}

package/src/index.web.tsx

@@ -0,0 +1,99 @@
+import { getOrCreateWebClient } from './web-client';
+import { AuthsignalEmail } from './email';
+import { AuthsignalPasskey } from './passkey';
+import { AuthsignalSms } from './sms';
+import { AuthsignalTotp } from './totp';
+import { AuthsignalWhatsapp } from './whatsapp';
+import type { LaunchOptions } from './types';
+
+export * from './types';
+export { ErrorCode } from './error';
+
+interface ConstructorArgs {
+  tenantID: string;
+  baseURL?: string;
+  deviceID?: string;
+  enableLogging?: boolean;
+}
+
+let _lastClient: {
+  tenantID: string;
+  baseURL: string;
+  enableLogging: boolean;
+} | null = null;
+
+export class Authsignal {
+  tenantID: string;
+  baseURL: string;
+  enableLogging: boolean;
+
+  email: AuthsignalEmail;
+  passkey: AuthsignalPasskey;
+  sms: AuthsignalSms;
+  totp: AuthsignalTotp;
+  whatsapp: AuthsignalWhatsapp;
+
+  constructor({
+    tenantID,
+    baseURL = 'https://api.authsignal.com/v1',
+    deviceID,
+    enableLogging = false,
+  }: ConstructorArgs) {
+    this.tenantID = tenantID;
+    this.baseURL = baseURL;
+    this.enableLogging = enableLogging;
+
+    _lastClient = { tenantID, baseURL, enableLogging };
+
+    const input = { tenantID, baseURL, enableLogging };
+
+    this.passkey = new AuthsignalPasskey({ ...input, deviceID });
+    this.email = new AuthsignalEmail(input);
+    this.sms = new AuthsignalSms(input);
+    this.totp = new AuthsignalTotp(input);
+    this.whatsapp = new AuthsignalWhatsapp(input);
+  }
+
+  async setToken(token: string): Promise<void> {
+    const client = getOrCreateWebClient({
+      tenantID: this.tenantID,
+      baseURL: this.baseURL,
+      enableLogging: this.enableLogging,
+    });
+
+    client.setToken(token);
+  }
+
+  async launch(url: string, options?: LaunchOptions): Promise<string | null> {
+    return await launch(url, options);
+  }
+}
+
+export function launch(
+  url: string,
+  options?: LaunchOptions
+): Promise<string | null> {
+  if (_lastClient) {
+    const client = getOrCreateWebClient({
+      tenantID: _lastClient.tenantID,
+      baseURL: _lastClient.baseURL,
+      enableLogging: _lastClient.enableLogging,
+    });
+
+    if (options?.mode === 'redirect') {
+      client.launch(url, { mode: 'redirect' });
+      return Promise.resolve(null);
+    }
+
+    return client.launch(url, { mode: 'popup' }).then((result) => {
+      return result?.token ?? null;
+    });
+  }
+
+  // Fallback if no Authsignal instance has been created yet
+  if (typeof window !== 'undefined') {
+    window.open(url, '_blank');
+  }
+
+  return Promise.resolve(null);
+}