Storage adapters

interface StorageAdapter {
  getItem(key: string): Promise<string | null>;
  setItem(key: string, value: string): Promise<void>;
  removeItem(key: string): Promise<void>;
  /**
   * Optional. Subscription to external changes of `key` (another tab,
   * background context). Returns an unsubscribe function.
   *
   * - `value`: new value or `null` (deleted / absent).
   * - Fires ONLY for cross-context changes; calling `cb` for your own
   *   setItem/removeItem is NOT required.
   */
  watch?(key: string, cb: (value: string | null) => void): () => void;
}

import { STORAGE_KEYS } from '@monetize.software/sdk/core';

import { AuthClient, BillingClient, type StorageAdapter } from '@monetize.software/sdk/core';
 
const memoryStorage: StorageAdapter = (() => {
  const m = new Map<string, string>();
  return {
    async getItem(k) { return m.get(k) ?? null; },
    async setItem(k, v) { m.set(k, v); },
    async removeItem(k) { m.delete(k); }
  };
})();
 
// One shared adapter across both clients — otherwise visitor_id will desync.
const auth = new AuthClient({ paywallId: 'pw_123', apiOrigin: '...', storage: memoryStorage });
const billing = new BillingClient({ paywallId: 'pw_123', apiOrigin: '...', auth, storage: memoryStorage });

const sessionAdapter: StorageAdapter = {
  async getItem(k) { return window.sessionStorage.getItem(k); },
  async setItem(k, v) { window.sessionStorage.setItem(k, v); },
  async removeItem(k) { window.sessionStorage.removeItem(k); }
  // No watch — sessionStorage isn't shared across tabs, so there's nothing to watch.
};

async function encrypt(plaintext: string, key: CryptoKey): Promise<string> {
  const iv = crypto.getRandomValues(new Uint8Array(12));
  const data = new TextEncoder().encode(plaintext);
  const ciphertext = await crypto.subtle.encrypt({ name: 'AES-GCM', iv }, key, data);
  const combined = new Uint8Array(iv.length + ciphertext.byteLength);
  combined.set(iv);
  combined.set(new Uint8Array(ciphertext), iv.length);
  return btoa(String.fromCharCode(...combined));
}
 
async function decrypt(encrypted: string, key: CryptoKey): Promise<string> {
  const combined = Uint8Array.from(atob(encrypted), (c) => c.charCodeAt(0));
  const iv = combined.slice(0, 12);
  const ciphertext = combined.slice(12);
  const data = await crypto.subtle.decrypt({ name: 'AES-GCM', iv }, key, ciphertext);
  return new TextDecoder().decode(data);
}
 
function makeEncryptedAdapter(key: CryptoKey): StorageAdapter {
  return {
    async getItem(k) {
      const raw = window.localStorage.getItem(k);
      if (!raw) return null;
      try { return await decrypt(raw, key); } catch { return null; }
    },
    async setItem(k, v) {
      window.localStorage.setItem(k, await encrypt(v, key));
    },
    async removeItem(k) {
      window.localStorage.removeItem(k);
    },
    watch(k, cb) {
      const handler = async (e: StorageEvent) => {
        if (e.key !== k || e.storageArea !== window.localStorage) return;
        if (e.newValue == null) return cb(null);
        try { cb(await decrypt(e.newValue, key)); } catch { cb(null); }
      };
      window.addEventListener('storage', handler);
      return () => window.removeEventListener('storage', handler);
    }
  };
}

import type { StorageAdapter } from '@monetize.software/sdk/core';
import { Redis } from 'ioredis';
 
const redis = new Redis(process.env.REDIS_URL);
 
function makeUserStorage(userId: string): StorageAdapter {
  const prefix = `monetize:${userId}:`;
  return {
    async getItem(k) {
      return (await redis.get(prefix + k)) ?? null;
    },
    async setItem(k, v) {
      // 30 day TTL — aligned with refresh-token expiry. The SDK updates
      // expires_at in the payload itself; redis TTL guarantees cleanup of
      // orphaned keys.
      await redis.set(prefix + k, v, 'EX', 30 * 24 * 3600);
    },
    async removeItem(k) {
      await redis.del(prefix + k);
    }
    // watch is usually unnecessary on the server — every worker has its own instance.
  };
}
 
// On a handler call:
const storage = makeUserStorage(req.user.id);
const auth = new AuthClient({ paywallId, apiOrigin, storage });

// web/localStorage:
watch(key, cb) {
  const handler = (e: StorageEvent) => {
    if (e.storageArea !== window.localStorage) return;
    if (e.key !== key) return;
    cb(e.newValue); // null when another tab removeItem'd
  };
  window.addEventListener('storage', handler);
  return () => window.removeEventListener('storage', handler);
}

// chrome.storage.local:
watch(key, cb) {
  const handler = (changes, area) => {
    if (area !== 'local') return;
    const ch = changes[key];
    if (!ch) return;
    cb(typeof ch.newValue === 'string' ? ch.newValue : null);
  };
  chrome.storage.onChanged.addListener(handler);
  return () => chrome.storage.onChanged.removeListener(handler);
}

import { createStorage, ensureVisitorId, generateVisitorId, STORAGE_KEYS } from '@monetize.software/sdk/core';
 
// Build an adapter with auto-detection (or return what you pass in):
const storage = createStorage(/* override?: StorageAdapter */);
 
// Resolve visitor_id (reads from storage, generates and saves if missing):
const visitorId = await ensureVisitorId(storage);
 
// Generate a fresh UUID v4 (for tests):
const id = generateVisitorId();

console.log(STORAGE_KEYS.authSession('pw_123'));     // 'pw-pw_123-auth-v1'
console.log(STORAGE_KEYS.userState('pw_123', '<identity_hash>'));