@egintegrations/auth-services 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,68 @@
+interface TokenManagerConfig {
+    storageKey?: string;
+}
+declare class TokenManager {
+    private storageKey;
+    constructor(config?: TokenManagerConfig);
+    getToken(): Promise<string | null>;
+    saveToken(token: string): Promise<void>;
+    clearToken(): Promise<void>;
+    hasToken(): Promise<boolean>;
+}
+declare class SingletonTokenManager {
+    private static instance;
+    private static defaultKey;
+    private constructor();
+    static getInstance(storageKey?: string): TokenManager;
+    static getToken(): Promise<string | null>;
+    static saveToken(token: string): Promise<void>;
+    static clearToken(): Promise<void>;
+    static hasToken(): Promise<boolean>;
+}
+
+interface BiometricAuthConfig {
+    savedUsernameKey?: string;
+    enabledKey?: string;
+    promptMessages?: {
+        enable?: string;
+        authenticate?: string;
+    };
+    fallbackLabel?: string;
+}
+type BiometricType = 'faceId' | 'touchId' | 'fingerprint' | 'none';
+declare class BiometricAuth {
+    private savedUsernameKey;
+    private enabledKey;
+    private promptMessages;
+    private fallbackLabel;
+    constructor(config?: BiometricAuthConfig);
+    canAuthenticate(): Promise<boolean>;
+    isEnabled(): Promise<boolean>;
+    enable(username: string): Promise<void>;
+    disable(): Promise<void>;
+    getBiometricType(): Promise<BiometricType>;
+    authenticate(): Promise<string>;
+    saveUsername(username: string): Promise<void>;
+    clearSavedUsername(): Promise<void>;
+    getSavedUsername(): Promise<string | null>;
+}
+
+interface SecureKeyStoreConfig {
+    keyPrefix?: string;
+}
+declare class SecureKeyStore {
+    private keyPrefix;
+    constructor(config?: SecureKeyStoreConfig);
+    private getFullKey;
+    get(key: string): Promise<string | null>;
+    set(key: string, value: string): Promise<void>;
+    delete(key: string): Promise<void>;
+    has(key: string): Promise<boolean>;
+    clear(keys?: string[]): Promise<void>;
+}
+declare function getSecureKey(key: string): Promise<string | null>;
+declare function setSecureKey(key: string, value: string): Promise<void>;
+declare function deleteSecureKey(key: string): Promise<void>;
+declare function hasSecureKey(key: string): Promise<boolean>;
+
+export { BiometricAuth, type BiometricAuthConfig, type BiometricType, SecureKeyStore, type SecureKeyStoreConfig, SingletonTokenManager, TokenManager, type TokenManagerConfig, deleteSecureKey, getSecureKey, hasSecureKey, setSecureKey };

package/dist/index.js

@@ -0,0 +1,223 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  BiometricAuth: () => BiometricAuth,
+  SecureKeyStore: () => SecureKeyStore,
+  SingletonTokenManager: () => SingletonTokenManager,
+  TokenManager: () => TokenManager,
+  deleteSecureKey: () => deleteSecureKey,
+  getSecureKey: () => getSecureKey,
+  hasSecureKey: () => hasSecureKey,
+  setSecureKey: () => setSecureKey
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/TokenManager.ts
+var SecureStore = __toESM(require("expo-secure-store"));
+var TokenManager = class {
+  constructor(config = {}) {
+    this.storageKey = config.storageKey || "auth_token";
+  }
+  async getToken() {
+    return await SecureStore.getItemAsync(this.storageKey);
+  }
+  async saveToken(token) {
+    await SecureStore.setItemAsync(this.storageKey, token);
+  }
+  async clearToken() {
+    await SecureStore.deleteItemAsync(this.storageKey);
+  }
+  async hasToken() {
+    const token = await this.getToken();
+    return !!token;
+  }
+};
+var SingletonTokenManager = class {
+  constructor() {
+  }
+  static getInstance(storageKey) {
+    if (!this.instance) {
+      this.instance = new TokenManager({ storageKey: storageKey || this.defaultKey });
+    }
+    return this.instance;
+  }
+  static async getToken() {
+    return this.getInstance().getToken();
+  }
+  static async saveToken(token) {
+    return this.getInstance().saveToken(token);
+  }
+  static async clearToken() {
+    return this.getInstance().clearToken();
+  }
+  static async hasToken() {
+    return this.getInstance().hasToken();
+  }
+};
+SingletonTokenManager.instance = null;
+SingletonTokenManager.defaultKey = "auth_token";
+
+// src/BiometricAuth.ts
+var LocalAuthentication = __toESM(require("expo-local-authentication"));
+var SecureStore2 = __toESM(require("expo-secure-store"));
+var BiometricAuth = class {
+  constructor(config = {}) {
+    this.savedUsernameKey = config.savedUsernameKey || "biometric_username";
+    this.enabledKey = config.enabledKey || "biometric_enabled";
+    this.promptMessages = {
+      enable: config.promptMessages?.enable || "Enable biometric login",
+      authenticate: config.promptMessages?.authenticate || "Authenticate to continue"
+    };
+    this.fallbackLabel = config.fallbackLabel || "Use password";
+  }
+  async canAuthenticate() {
+    const hasHardware = await LocalAuthentication.hasHardwareAsync();
+    const isEnrolled = await LocalAuthentication.isEnrolledAsync();
+    return hasHardware && isEnrolled;
+  }
+  async isEnabled() {
+    const value = await SecureStore2.getItemAsync(this.enabledKey);
+    return value === "true";
+  }
+  async enable(username) {
+    const canAuth = await this.canAuthenticate();
+    if (!canAuth) {
+      throw new Error("Biometric authentication is not available on this device");
+    }
+    const result = await LocalAuthentication.authenticateAsync({
+      promptMessage: this.promptMessages.enable,
+      fallbackLabel: this.fallbackLabel,
+      disableDeviceFallback: false
+    });
+    if (!result.success) {
+      throw new Error("Biometric authentication failed");
+    }
+    await SecureStore2.setItemAsync(this.enabledKey, "true");
+    await SecureStore2.setItemAsync(this.savedUsernameKey, username);
+  }
+  async disable() {
+    await SecureStore2.deleteItemAsync(this.enabledKey);
+    await SecureStore2.deleteItemAsync(this.savedUsernameKey);
+  }
+  async getBiometricType() {
+    const types = await LocalAuthentication.supportedAuthenticationTypesAsync();
+    if (types.includes(LocalAuthentication.AuthenticationType.FACIAL_RECOGNITION)) {
+      return "faceId";
+    } else if (types.includes(LocalAuthentication.AuthenticationType.FINGERPRINT)) {
+      return "touchId";
+    }
+    return "none";
+  }
+  async authenticate() {
+    const result = await LocalAuthentication.authenticateAsync({
+      promptMessage: this.promptMessages.authenticate,
+      fallbackLabel: this.fallbackLabel,
+      disableDeviceFallback: false
+    });
+    if (!result.success) {
+      throw new Error("Biometric authentication failed");
+    }
+    const enabled = await this.isEnabled();
+    if (!enabled) {
+      throw new Error("Biometric login is disabled");
+    }
+    const username = await SecureStore2.getItemAsync(this.savedUsernameKey);
+    if (!username) {
+      throw new Error("No saved username for biometric authentication");
+    }
+    return username;
+  }
+  async saveUsername(username) {
+    await SecureStore2.setItemAsync(this.savedUsernameKey, username);
+  }
+  async clearSavedUsername() {
+    await SecureStore2.deleteItemAsync(this.savedUsernameKey);
+  }
+  async getSavedUsername() {
+    const enabled = await this.isEnabled();
+    if (!enabled) return null;
+    return await SecureStore2.getItemAsync(this.savedUsernameKey);
+  }
+};
+
+// src/SecureKeyStore.ts
+var SecureStore3 = __toESM(require("expo-secure-store"));
+var SecureKeyStore = class {
+  constructor(config = {}) {
+    this.keyPrefix = config.keyPrefix || "secure_key_";
+  }
+  getFullKey(key) {
+    return `${this.keyPrefix}${key}`;
+  }
+  async get(key) {
+    return await SecureStore3.getItemAsync(this.getFullKey(key));
+  }
+  async set(key, value) {
+    await SecureStore3.setItemAsync(this.getFullKey(key), value);
+  }
+  async delete(key) {
+    await SecureStore3.deleteItemAsync(this.getFullKey(key));
+  }
+  async has(key) {
+    const value = await this.get(key);
+    return !!value;
+  }
+  async clear(keys) {
+    if (keys) {
+      await Promise.all(keys.map((key) => this.delete(key)));
+    }
+  }
+};
+async function getSecureKey(key) {
+  return await SecureStore3.getItemAsync(key);
+}
+async function setSecureKey(key, value) {
+  await SecureStore3.setItemAsync(key, value);
+}
+async function deleteSecureKey(key) {
+  await SecureStore3.deleteItemAsync(key);
+}
+async function hasSecureKey(key) {
+  const value = await getSecureKey(key);
+  return !!value;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BiometricAuth,
+  SecureKeyStore,
+  SingletonTokenManager,
+  TokenManager,
+  deleteSecureKey,
+  getSecureKey,
+  hasSecureKey,
+  setSecureKey
+});

package/dist/index.mjs

@@ -0,0 +1,179 @@
+// src/TokenManager.ts
+import * as SecureStore from "expo-secure-store";
+var TokenManager = class {
+  constructor(config = {}) {
+    this.storageKey = config.storageKey || "auth_token";
+  }
+  async getToken() {
+    return await SecureStore.getItemAsync(this.storageKey);
+  }
+  async saveToken(token) {
+    await SecureStore.setItemAsync(this.storageKey, token);
+  }
+  async clearToken() {
+    await SecureStore.deleteItemAsync(this.storageKey);
+  }
+  async hasToken() {
+    const token = await this.getToken();
+    return !!token;
+  }
+};
+var SingletonTokenManager = class {
+  constructor() {
+  }
+  static getInstance(storageKey) {
+    if (!this.instance) {
+      this.instance = new TokenManager({ storageKey: storageKey || this.defaultKey });
+    }
+    return this.instance;
+  }
+  static async getToken() {
+    return this.getInstance().getToken();
+  }
+  static async saveToken(token) {
+    return this.getInstance().saveToken(token);
+  }
+  static async clearToken() {
+    return this.getInstance().clearToken();
+  }
+  static async hasToken() {
+    return this.getInstance().hasToken();
+  }
+};
+SingletonTokenManager.instance = null;
+SingletonTokenManager.defaultKey = "auth_token";
+
+// src/BiometricAuth.ts
+import * as LocalAuthentication from "expo-local-authentication";
+import * as SecureStore2 from "expo-secure-store";
+var BiometricAuth = class {
+  constructor(config = {}) {
+    this.savedUsernameKey = config.savedUsernameKey || "biometric_username";
+    this.enabledKey = config.enabledKey || "biometric_enabled";
+    this.promptMessages = {
+      enable: config.promptMessages?.enable || "Enable biometric login",
+      authenticate: config.promptMessages?.authenticate || "Authenticate to continue"
+    };
+    this.fallbackLabel = config.fallbackLabel || "Use password";
+  }
+  async canAuthenticate() {
+    const hasHardware = await LocalAuthentication.hasHardwareAsync();
+    const isEnrolled = await LocalAuthentication.isEnrolledAsync();
+    return hasHardware && isEnrolled;
+  }
+  async isEnabled() {
+    const value = await SecureStore2.getItemAsync(this.enabledKey);
+    return value === "true";
+  }
+  async enable(username) {
+    const canAuth = await this.canAuthenticate();
+    if (!canAuth) {
+      throw new Error("Biometric authentication is not available on this device");
+    }
+    const result = await LocalAuthentication.authenticateAsync({
+      promptMessage: this.promptMessages.enable,
+      fallbackLabel: this.fallbackLabel,
+      disableDeviceFallback: false
+    });
+    if (!result.success) {
+      throw new Error("Biometric authentication failed");
+    }
+    await SecureStore2.setItemAsync(this.enabledKey, "true");
+    await SecureStore2.setItemAsync(this.savedUsernameKey, username);
+  }
+  async disable() {
+    await SecureStore2.deleteItemAsync(this.enabledKey);
+    await SecureStore2.deleteItemAsync(this.savedUsernameKey);
+  }
+  async getBiometricType() {
+    const types = await LocalAuthentication.supportedAuthenticationTypesAsync();
+    if (types.includes(LocalAuthentication.AuthenticationType.FACIAL_RECOGNITION)) {
+      return "faceId";
+    } else if (types.includes(LocalAuthentication.AuthenticationType.FINGERPRINT)) {
+      return "touchId";
+    }
+    return "none";
+  }
+  async authenticate() {
+    const result = await LocalAuthentication.authenticateAsync({
+      promptMessage: this.promptMessages.authenticate,
+      fallbackLabel: this.fallbackLabel,
+      disableDeviceFallback: false
+    });
+    if (!result.success) {
+      throw new Error("Biometric authentication failed");
+    }
+    const enabled = await this.isEnabled();
+    if (!enabled) {
+      throw new Error("Biometric login is disabled");
+    }
+    const username = await SecureStore2.getItemAsync(this.savedUsernameKey);
+    if (!username) {
+      throw new Error("No saved username for biometric authentication");
+    }
+    return username;
+  }
+  async saveUsername(username) {
+    await SecureStore2.setItemAsync(this.savedUsernameKey, username);
+  }
+  async clearSavedUsername() {
+    await SecureStore2.deleteItemAsync(this.savedUsernameKey);
+  }
+  async getSavedUsername() {
+    const enabled = await this.isEnabled();
+    if (!enabled) return null;
+    return await SecureStore2.getItemAsync(this.savedUsernameKey);
+  }
+};
+
+// src/SecureKeyStore.ts
+import * as SecureStore3 from "expo-secure-store";
+var SecureKeyStore = class {
+  constructor(config = {}) {
+    this.keyPrefix = config.keyPrefix || "secure_key_";
+  }
+  getFullKey(key) {
+    return `${this.keyPrefix}${key}`;
+  }
+  async get(key) {
+    return await SecureStore3.getItemAsync(this.getFullKey(key));
+  }
+  async set(key, value) {
+    await SecureStore3.setItemAsync(this.getFullKey(key), value);
+  }
+  async delete(key) {
+    await SecureStore3.deleteItemAsync(this.getFullKey(key));
+  }
+  async has(key) {
+    const value = await this.get(key);
+    return !!value;
+  }
+  async clear(keys) {
+    if (keys) {
+      await Promise.all(keys.map((key) => this.delete(key)));
+    }
+  }
+};
+async function getSecureKey(key) {
+  return await SecureStore3.getItemAsync(key);
+}
+async function setSecureKey(key, value) {
+  await SecureStore3.setItemAsync(key, value);
+}
+async function deleteSecureKey(key) {
+  await SecureStore3.deleteItemAsync(key);
+}
+async function hasSecureKey(key) {
+  const value = await getSecureKey(key);
+  return !!value;
+}
+export {
+  BiometricAuth,
+  SecureKeyStore,
+  SingletonTokenManager,
+  TokenManager,
+  deleteSecureKey,
+  getSecureKey,
+  hasSecureKey,
+  setSecureKey
+};

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "@egintegrations/auth-services",
+  "version": "0.1.0",
+  "description": "React Native authentication utilities for token management, biometric authentication, and secure key storage. Works with Expo and bare React Native.",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts --clean",
+    "dev": "tsup src/index.ts --format cjs,esm --dts --watch",
+    "test": "jest",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint src --ext .ts,.tsx",
+    "prepublishOnly": "npm run lint && npm run typecheck && npm run build && npm run test"
+  },
+  "keywords": [
+    "typescript",
+    "react-native",
+    "authentication",
+    "biometric",
+    "token-management",
+    "secure-storage",
+    "expo",
+    "mobile",
+    "egintegrations"
+  ],
+  "author": "EGI Integrations",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/EGIntegrations/egi-comp-library.git",
+    "directory": "packages/typescript/auth-services"
+  },
+  "peerDependencies": {
+    "expo-local-authentication": ">=13.0.0",
+    "expo-secure-store": ">=12.0.0",
+    "react-native": ">=0.70.0"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.11",
+    "@types/node": "^20.10.6",
+    "@types/react-native": "^0.72.0",
+    "@typescript-eslint/eslint-plugin": "^6.17.0",
+    "@typescript-eslint/parser": "^6.17.0",
+    "eslint": "^8.56.0",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.1.1",
+    "tsup": "^8.0.1",
+    "typescript": "^5.3.3"
+  }
+}

package/src/BiometricAuth.ts

@@ -0,0 +1,119 @@
+import * as LocalAuthentication from 'expo-local-authentication';
+import * as SecureStore from 'expo-secure-store';
+
+export interface BiometricAuthConfig {
+  savedUsernameKey?: string;
+  enabledKey?: string;
+  promptMessages?: {
+    enable?: string;
+    authenticate?: string;
+  };
+  fallbackLabel?: string;
+}
+
+export type BiometricType = 'faceId' | 'touchId' | 'fingerprint' | 'none';
+
+export class BiometricAuth {
+  private savedUsernameKey: string;
+  private enabledKey: string;
+  private promptMessages: {
+    enable: string;
+    authenticate: string;
+  };
+  private fallbackLabel: string;
+
+  constructor(config: BiometricAuthConfig = {}) {
+    this.savedUsernameKey = config.savedUsernameKey || 'biometric_username';
+    this.enabledKey = config.enabledKey || 'biometric_enabled';
+    this.promptMessages = {
+      enable: config.promptMessages?.enable || 'Enable biometric login',
+      authenticate: config.promptMessages?.authenticate || 'Authenticate to continue',
+    };
+    this.fallbackLabel = config.fallbackLabel || 'Use password';
+  }
+
+  async canAuthenticate(): Promise<boolean> {
+    const hasHardware = await LocalAuthentication.hasHardwareAsync();
+    const isEnrolled = await LocalAuthentication.isEnrolledAsync();
+    return hasHardware && isEnrolled;
+  }
+
+  async isEnabled(): Promise<boolean> {
+    const value = await SecureStore.getItemAsync(this.enabledKey);
+    return value === 'true';
+  }
+
+  async enable(username: string): Promise<void> {
+    const canAuth = await this.canAuthenticate();
+    if (!canAuth) {
+      throw new Error('Biometric authentication is not available on this device');
+    }
+
+    const result = await LocalAuthentication.authenticateAsync({
+      promptMessage: this.promptMessages.enable,
+      fallbackLabel: this.fallbackLabel,
+      disableDeviceFallback: false,
+    });
+
+    if (!result.success) {
+      throw new Error('Biometric authentication failed');
+    }
+
+    await SecureStore.setItemAsync(this.enabledKey, 'true');
+    await SecureStore.setItemAsync(this.savedUsernameKey, username);
+  }
+
+  async disable(): Promise<void> {
+    await SecureStore.deleteItemAsync(this.enabledKey);
+    await SecureStore.deleteItemAsync(this.savedUsernameKey);
+  }
+
+  async getBiometricType(): Promise<BiometricType> {
+    const types = await LocalAuthentication.supportedAuthenticationTypesAsync();
+
+    if (types.includes(LocalAuthentication.AuthenticationType.FACIAL_RECOGNITION)) {
+      return 'faceId';
+    } else if (types.includes(LocalAuthentication.AuthenticationType.FINGERPRINT)) {
+      return 'touchId';
+    }
+    return 'none';
+  }
+
+  async authenticate(): Promise<string> {
+    const result = await LocalAuthentication.authenticateAsync({
+      promptMessage: this.promptMessages.authenticate,
+      fallbackLabel: this.fallbackLabel,
+      disableDeviceFallback: false,
+    });
+
+    if (!result.success) {
+      throw new Error('Biometric authentication failed');
+    }
+
+    const enabled = await this.isEnabled();
+    if (!enabled) {
+      throw new Error('Biometric login is disabled');
+    }
+
+    const username = await SecureStore.getItemAsync(this.savedUsernameKey);
+    if (!username) {
+      throw new Error('No saved username for biometric authentication');
+    }
+
+    return username;
+  }
+
+  async saveUsername(username: string): Promise<void> {
+    await SecureStore.setItemAsync(this.savedUsernameKey, username);
+  }
+
+  async clearSavedUsername(): Promise<void> {
+    await SecureStore.deleteItemAsync(this.savedUsernameKey);
+  }
+
+  async getSavedUsername(): Promise<string | null> {
+    const enabled = await this.isEnabled();
+    if (!enabled) return null;
+    return await SecureStore.getItemAsync(this.savedUsernameKey);
+  }
+}