@openfort/react-native 0.1.17 → 0.1.18

package/dist/constants/config.js

@@ -3,7 +3,7 @@
  */
 export const SDK_INFO = {
     name: '@openfort/react-native',
-    version: '0.1.15',
+    version: '0.1.18',
     description: 'React Native client for Openfort',
     homepage: 'https://openfort.io/docs',
 };

package/dist/core/client.js

@@ -49,7 +49,7 @@ export function createOpenfortClient({ baseConfiguration, overrides, shieldConfi
                 // eslint-disable-next-line @typescript-eslint/no-explicit-any
                 digest: digest,
             },
-            storage: createNormalizedStorage(SecureStorageAdapter),
+            storage: createNormalizedStorage(baseConfiguration.publishableKey, SecureStorageAdapter),
         },
         shieldConfiguration,
     });

package/dist/core/storage.js

@@ -2,6 +2,25 @@
 import * as SecureStore from 'expo-secure-store';
 import { logger } from '../lib/logger';
 import { NativeStorageUtils } from '../native';
+/**
+ * Tracks pending write operations per key.
+ * This ensures `get` waits for any in-flight `save` to complete,
+ * providing read-after-write consistency while keeping `save` synchronous.
+ */
+const pendingWrites = new Map();
+/**
+ * Creates a scope prefix from the publishable key.
+ * Extracts the unique project identifier after the "pk_test_" or "pk_live_" prefix.
+ * Uses the first 8 characters of that unique part to keep keys readable.
+ *
+ * e.g., "pk_test_abc123xyz789" -> "abc123xy"
+ */
+function createScope(publishableKey) {
+    // Remove the "pk_test_" or "pk_live_" prefix (8 characters)
+    const uniquePart = publishableKey.substring(8);
+    // Use first 8 characters of the unique part as scope
+    return uniquePart.substring(0, 8);
+}
 // Define the StorageKeys enum values that match the Openfort SDK
 var StorageKeys;
 (function (StorageKeys) {
@@ -24,6 +43,11 @@ export const SecureStorageAdapter = {
     async get(key) {
         try {
             const normalizedKey = normalizeKey(key);
+            // Wait for any pending write to complete before reading
+            const pendingWrite = pendingWrites.get(normalizedKey);
+            if (pendingWrite) {
+                await pendingWrite;
+            }
             const result = await SecureStore.getItemAsync(normalizedKey, NativeStorageUtils.getStorageOptions());
             // If result is a string (as expected), return it
             if (typeof result === 'string' || result === null) {
@@ -45,14 +69,21 @@ export const SecureStorageAdapter = {
         }
     },
     async save(key, value) {
-        try {
-            const normalizedKey = normalizeKey(key);
-            await SecureStore.setItemAsync(normalizedKey, value, NativeStorageUtils.getStorageOptions());
-        }
-        catch (error) {
-            logger.warn('Failed to set item in secure store', error);
-            throw error;
-        }
+        const normalizedKey = normalizeKey(key);
+        const writePromise = (async () => {
+            try {
+                await SecureStore.setItemAsync(normalizedKey, value, NativeStorageUtils.getStorageOptions());
+            }
+            catch (error) {
+                logger.warn('Failed to set item in secure store', error);
+                throw error;
+            }
+            finally {
+                pendingWrites.delete(normalizedKey);
+            }
+        })();
+        pendingWrites.set(normalizedKey, writePromise);
+        return writePromise;
     },
     async remove(key) {
         try {
@@ -78,7 +109,7 @@ export const SecureStorageAdapter = {
     },
 };
 /**
- * Normalises an Openfort storage key for use with Expo Secure Store.
+ * Normalizes an Openfort storage key for use with Expo Secure Store.
  *
  * @param key - The key provided by the Openfort SDK.
  * @returns A key that is safe to use with Expo Secure Store.
@@ -88,38 +119,57 @@ function normalizeKey(key) {
 }
 /**
  * Creates a type-safe storage adapter that bridges the Openfort SDK storage API with the React Native implementation.
+ * Storage keys are scoped by publishable key to isolate data between different projects.
  *
+ * @param publishableKey - The publishable key used to scope storage keys.
  * @param customStorage - Optional custom storage implementation. When omitted the {@link SecureStorageAdapter} is used.
  * @returns An object that satisfies the {@link Storage} interface expected by `@openfort/openfort-js`.
  */
-export function createNormalizedStorage(customStorage) {
+export function createNormalizedStorage(publishableKey, customStorage) {
     const baseStorage = customStorage || SecureStorageAdapter;
+    const scope = createScope(publishableKey);
+    /**
+     * Prefixes a storage key with the scope.
+     * e.g., "openfort.authentication" -> "abc123xy.openfort.authentication"
+     */
+    function scopeKey(key) {
+        return `${scope}.${key}`;
+    }
     return {
         async get(key) {
             // Convert the unknown key to our StorageKeys enum
             const storageKey = keyToStorageKeys(key);
-            const result = await baseStorage.get(storageKey);
+            const scopedKey = scopeKey(storageKey);
+            const result = await baseStorage.get(scopedKey);
             return result;
         },
         save(key, value) {
             logger.info(`Saving to storage key: ${key}, value: ${value}`);
             const storageKey = keyToStorageKeys(key);
+            const scopedKey = scopeKey(storageKey);
             // Fire and forget - don't await as the SDK expects synchronous behavior
-            baseStorage.save(storageKey, value).catch((error) => {
+            baseStorage.save(scopedKey, value).catch((error) => {
                 logger.error('Failed to save to storage', error);
             });
         },
         remove(key) {
             logger.info(`Removing from storage key: ${key}`);
             const storageKey = keyToStorageKeys(key);
+            const scopedKey = scopeKey(storageKey);
             // Fire and forget - don't await as the SDK expects synchronous behavior
-            baseStorage.remove(storageKey).catch((error) => {
+            baseStorage.remove(scopedKey).catch((error) => {
                 logger.error('Failed to remove from storage', error);
             });
         },
         flush() {
             logger.info('Flushing storage');
-            baseStorage.flush();
+            // Remove all scoped keys for this project
+            for (const key of Object.values(StorageKeys)) {
+                const scopedKey = scopeKey(key);
+                baseStorage.remove(scopedKey).catch((error) => {
+                    logger.error('Failed to remove from storage during flush', error);
+                });
+            }
         },
     };
 }

package/dist/types/constants/config.d.ts

@@ -3,7 +3,7 @@
  */
 export declare const SDK_INFO: {
     readonly name: "@openfort/react-native";
-    readonly version: "0.1.15";
+    readonly version: "0.1.18";
     readonly description: "React Native client for Openfort";
     readonly homepage: "https://openfort.io/docs";
 };

package/dist/types/core/storage.d.ts

@@ -1,21 +1,10 @@
 import type { Storage } from '@openfort/openfort-js';
-declare enum StorageKeys {
-    AUTHENTICATION = "openfort.authentication",
-    SIGNER = "openfort.signer",
-    CONFIGURATION = "openfort.configuration",
-    ACCOUNT = "openfort.account",
-    TEST = "openfort.test",
-    RECOVERY = "openfort.recovery",
-    SESSION = "openfort.session",
-    PKCE_STATE = "openfort.pkce_state",
-    PKCE_VERIFIER = "openfort.pkce_verifier"
-}
 interface OpenfortStorage {
-    get(key: StorageKeys): Promise<string | null>;
-    save(key: StorageKeys, value: string): Promise<void>;
-    remove(key: StorageKeys): Promise<void>;
+    get(key: string): Promise<string | null>;
+    save(key: string, value: string): Promise<void>;
+    remove(key: string): Promise<void>;
     flush(): void;
-    keyExists(key: StorageKeys): Promise<boolean>;
+    keyExists(key: string): Promise<boolean>;
     getStorageInfo(): Promise<{
         isAvailable: boolean;
         platform: string;
@@ -30,9 +19,11 @@ interface OpenfortStorage {
 export declare const SecureStorageAdapter: OpenfortStorage;
 /**
  * Creates a type-safe storage adapter that bridges the Openfort SDK storage API with the React Native implementation.
+ * Storage keys are scoped by publishable key to isolate data between different projects.
  *
+ * @param publishableKey - The publishable key used to scope storage keys.
  * @param customStorage - Optional custom storage implementation. When omitted the {@link SecureStorageAdapter} is used.
  * @returns An object that satisfies the {@link Storage} interface expected by `@openfort/openfort-js`.
  */
-export declare function createNormalizedStorage(customStorage?: OpenfortStorage): Storage;
+export declare function createNormalizedStorage(publishableKey: string, customStorage?: OpenfortStorage): Storage;
 export {};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@openfort/react-native",
   "main": "dist/index.js",
-  "version": "0.1.17",
+  "version": "0.1.18",
   "license": "MIT",
   "description": "React Native SDK for Openfort platform integration",
   "types": "dist/types/index.d.ts",
@@ -16,7 +16,7 @@
     }
   },
   "dependencies": {
-    "@openfort/openfort-js": "^0.10.38"
+    "@openfort/openfort-js": "^0.10.39"
   },
   "peerDependencies": {
     "expo-apple-authentication": "*",