@egintegrations/auth-services 0.1.0

package/src/SecureKeyStore.ts

@@ -0,0 +1,58 @@
+import * as SecureStore from 'expo-secure-store';
+
+export interface SecureKeyStoreConfig {
+  keyPrefix?: string;
+}
+
+export class SecureKeyStore {
+  private keyPrefix: string;
+
+  constructor(config: SecureKeyStoreConfig = {}) {
+    this.keyPrefix = config.keyPrefix || 'secure_key_';
+  }
+
+  private getFullKey(key: string): string {
+    return `${this.keyPrefix}${key}`;
+  }
+
+  async get(key: string): Promise<string | null> {
+    return await SecureStore.getItemAsync(this.getFullKey(key));
+  }
+
+  async set(key: string, value: string): Promise<void> {
+    await SecureStore.setItemAsync(this.getFullKey(key), value);
+  }
+
+  async delete(key: string): Promise<void> {
+    await SecureStore.deleteItemAsync(this.getFullKey(key));
+  }
+
+  async has(key: string): Promise<boolean> {
+    const value = await this.get(key);
+    return !!value;
+  }
+
+  async clear(keys?: string[]): Promise<void> {
+    if (keys) {
+      await Promise.all(keys.map((key) => this.delete(key)));
+    }
+  }
+}
+
+// Convenience functions for simple use cases
+export async function getSecureKey(key: string): Promise<string | null> {
+  return await SecureStore.getItemAsync(key);
+}
+
+export async function setSecureKey(key: string, value: string): Promise<void> {
+  await SecureStore.setItemAsync(key, value);
+}
+
+export async function deleteSecureKey(key: string): Promise<void> {
+  await SecureStore.deleteItemAsync(key);
+}
+
+export async function hasSecureKey(key: string): Promise<boolean> {
+  const value = await getSecureKey(key);
+  return !!value;
+}

package/src/TokenManager.ts

@@ -0,0 +1,61 @@
+import * as SecureStore from 'expo-secure-store';
+
+export interface TokenManagerConfig {
+  storageKey?: string;
+}
+
+export class TokenManager {
+  private storageKey: string;
+
+  constructor(config: TokenManagerConfig = {}) {
+    this.storageKey = config.storageKey || 'auth_token';
+  }
+
+  async getToken(): Promise<string | null> {
+    return await SecureStore.getItemAsync(this.storageKey);
+  }
+
+  async saveToken(token: string): Promise<void> {
+    await SecureStore.setItemAsync(this.storageKey, token);
+  }
+
+  async clearToken(): Promise<void> {
+    await SecureStore.deleteItemAsync(this.storageKey);
+  }
+
+  async hasToken(): Promise<boolean> {
+    const token = await this.getToken();
+    return !!token;
+  }
+}
+
+// Convenience class for single token use case
+export class SingletonTokenManager {
+  private static instance: TokenManager | null = null;
+  private static defaultKey = 'auth_token';
+
+  private constructor() {}
+
+  static getInstance(storageKey?: string): TokenManager {
+    if (!this.instance) {
+      this.instance = new TokenManager({ storageKey: storageKey || this.defaultKey });
+    }
+    return this.instance;
+  }
+
+  static async getToken(): Promise<string | null> {
+    return this.getInstance().getToken();
+  }
+
+  static async saveToken(token: string): Promise<void> {
+    return this.getInstance().saveToken(token);
+  }
+
+  static async clearToken(): Promise<void> {
+    return this.getInstance().clearToken();
+  }
+
+  static async hasToken(): Promise<boolean> {
+    return this.getInstance().hasToken();
+  }
+}

package/src/index.ts

@@ -0,0 +1,20 @@
+export {
+  TokenManager,
+  SingletonTokenManager,
+  TokenManagerConfig,
+} from './TokenManager';
+
+export {
+  BiometricAuth,
+  BiometricAuthConfig,
+  BiometricType,
+} from './BiometricAuth';
+
+export {
+  SecureKeyStore,
+  SecureKeyStoreConfig,
+  getSecureKey,
+  setSecureKey,
+  deleteSecureKey,
+  hasSecureKey,
+} from './SecureKeyStore';