react-native-nitro-storage 0.9.0 → 0.10.1

package/src/internal.ts

@@ -1,8 +1,6 @@
 import { StorageScope } from "./Storage.types";
 
 export const MIGRATION_VERSION_KEY = "__nitro_storage_migration_version__";
-export const NATIVE_BATCH_MISSING_SENTINEL =
-  "__nitro_storage_batch_missing__::v1";
 const PRIMITIVE_FAST_PATH_PREFIX = "__nitro_storage_primitive__:";
 const PRIM_NULL = "__nitro_storage_primitive__:l";
 const PRIM_UNDEFINED = "__nitro_storage_primitive__:u";
@@ -26,7 +24,6 @@ const RESERVED_RAW_TOKENS = new Set<string>([
   PRIM_INFINITY,
   PRIM_NEG_INFINITY,
   PRIM_NAN,
-  NATIVE_BATCH_MISSING_SENTINEL,
 ]);
 
 export function escapeCollidingRawValue(value: string): string {
@@ -98,16 +95,6 @@ export function assertBatchScope(
   );
 }
 
-export function decodeNativeBatchValue(
-  value: string | undefined,
-): string | undefined {
-  if (value === undefined || value === NATIVE_BATCH_MISSING_SENTINEL) {
-    return undefined;
-  }
-
-  return value;
-}
-
 export function prefixKey(namespace: string | undefined, key: string): string {
   if (!namespace) return key;
   return `${namespace}${NAMESPACE_SEPARATOR}${key}`;
@@ -126,7 +113,6 @@ export function serializeWithPrimitiveFastPath<T>(value: T): string {
     case "string": {
       const stringValue = value as string;
       if (
-        stringValue === NATIVE_BATCH_MISSING_SENTINEL ||
         stringValue.startsWith(PRIMITIVE_FAST_PATH_PREFIX) ||
         stringValue.startsWith(ESCAPE_PREFIX)
       ) {

package/src/shared.ts

@@ -75,6 +75,7 @@ export type KeyListenerRegistry = Map<string, Set<() => void>>;
 export type RawBatchPathItem = {
   _hasValidation?: boolean;
   _hasExpiration?: boolean;
+  _hasRenameFrom?: boolean;
   _isBiometric?: boolean;
   _biometricLevel?: BiometricLevel;
   _secureAccessControl?: AccessControl;
@@ -84,6 +85,7 @@ export type RollbackRecord =
   | {
       kind: "memory";
       value: unknown;
+      expiresAt?: number;
     }
   | {
       kind: "raw";
@@ -96,6 +98,81 @@ export type RollbackRecord =
       level: BiometricLevel;
     };
 
+export type StorageCompositeError = Error & {
+  readonly cause: unknown;
+  readonly errors: readonly unknown[];
+  readonly code: "storage_compensation_failed";
+};
+
+export type StorageCompensationError = StorageCompositeError;
+
+export function createStorageCompositeError(
+  operation: string,
+  primary: unknown,
+  contexts: readonly { label: string; error: unknown }[],
+): StorageCompositeError {
+  const primaryMessage =
+    primary instanceof Error ? primary.message : String(primary);
+  const contextMessage = contexts
+    .map(({ label, error }) => {
+      const message = error instanceof Error ? error.message : String(error);
+      return `${label}: ${message}`;
+    })
+    .join("; ");
+  const composite = new Error(
+    `[nitro-error:storage_compensation_failed] NitroStorage: ${operation} failed; primary error: ${primaryMessage}${
+      contextMessage.length > 0 ? `; ${contextMessage}` : ""
+    }`,
+  ) as StorageCompositeError;
+  Object.defineProperties(composite, {
+    cause: {
+      configurable: true,
+      enumerable: false,
+      value: primary,
+      writable: false,
+    },
+    errors: {
+      configurable: true,
+      enumerable: false,
+      value: Object.freeze([primary, ...contexts.map(({ error }) => error)]),
+      writable: false,
+    },
+    code: {
+      configurable: false,
+      enumerable: false,
+      value: "storage_compensation_failed",
+      writable: false,
+    },
+  });
+  return composite;
+}
+
+export function normalizeStorageError(error: unknown): unknown {
+  if (!(error instanceof Error)) {
+    return error;
+  }
+
+  const code = getStorageErrorCode(error);
+  if (
+    code !== "storage_compensation_failed" ||
+    ("cause" in error && "errors" in error && "code" in error)
+  ) {
+    return error;
+  }
+
+  const operationMatch = error.message.match(
+    /NitroStorage: ([^;]+?) failed(?:;|$)/,
+  );
+  const countMatch = error.message.match(/rollback_error_count=(\d+)/);
+  const rollbackErrorCount = countMatch ? Number(countMatch[1]) : 0;
+  const operation = operationMatch?.[1] ?? "native storage compensation";
+  const contexts = Array.from({ length: rollbackErrorCount }, (_, index) => ({
+    label: `native rollback ${index + 1}`,
+    error: new Error("Native storage rollback failed"),
+  }));
+  return createStorageCompositeError(operation, error, contexts);
+}
+
 export function isUpdater<T>(
   valueOrFn: T | ((prev: T) => T),
 ): valueOrFn is (prev: T) => T {
@@ -133,12 +210,14 @@ export type NonMemoryScope = StorageScope.Disk | StorageScope.Secure;
 export type PendingDiskWrite = {
   key: string;
   value: string | undefined;
+  generation: number;
 };
 
 export type PendingSecureWrite = {
   key: string;
   value: string | undefined;
   accessControl?: AccessControl;
+  generation: number;
 };
 
 export const runMicrotask =
@@ -214,6 +293,7 @@ export function canUseRawBatchPath(item: RawBatchPathItem): boolean {
   return (
     item._hasExpiration === false &&
     item._hasValidation === false &&
+    item._hasRenameFrom !== true &&
     item._isBiometric !== true &&
     item._secureAccessControl === undefined
   );
@@ -223,6 +303,7 @@ export function canUseSecureRawBatchPath(item: RawBatchPathItem): boolean {
   return (
     item._hasExpiration === false &&
     item._hasValidation === false &&
+    item._hasRenameFrom !== true &&
     item._isBiometric !== true
   );
 }
@@ -246,6 +327,10 @@ export type SecureAuthStorageConfig<K extends string = string> = Record<
   }
 >;
 
+/**
+ * @deprecated Use isStorageError(error, code) to distinguish temporary lock,
+ * authentication, and invalidated-key recovery paths.
+ */
 export function isKeychainLockedError(err: unknown): boolean {
   return isLockedStorageErrorCode(getStorageErrorCode(err));
 }