bff-store 0.1.0

package/dist/index.mjs

@@ -0,0 +1,430 @@
+// src/atomCreator.ts
+import { atom, getDefaultStore } from "jotai";
+
+// src/debouncer.ts
+function createDebouncer(ms) {
+  let timer = null;
+  return {
+    get ms() {
+      return ms;
+    },
+    run(fn) {
+      if (timer) clearTimeout(timer);
+      timer = setTimeout(() => {
+        fn();
+        timer = null;
+      }, ms);
+    },
+    cancel() {
+      if (timer) {
+        clearTimeout(timer);
+        timer = null;
+      }
+    }
+  };
+}
+var DebouncerMap = class {
+  constructor(defaultMs = 800) {
+    this.debouncers = /* @__PURE__ */ new Map();
+    this.defaultMs = defaultMs;
+  }
+  getDebouncer(key, ms) {
+    let debouncer = this.debouncers.get(key);
+    if (!debouncer) {
+      debouncer = createDebouncer(ms ?? this.defaultMs);
+      this.debouncers.set(key, debouncer);
+    }
+    return debouncer;
+  }
+  /**
+   * Execute a function with debounce for a given key.
+   * Subsequent calls for the same key reset the timer.
+   */
+  debounce(key, fn, ms) {
+    const debouncer = this.getDebouncer(key, ms);
+    debouncer.run(fn);
+  }
+  /**
+   * Cancel pending debounced call for a key
+   */
+  cancel(key) {
+    const debouncer = this.debouncers.get(key);
+    if (debouncer) {
+      debouncer.cancel();
+    }
+  }
+  /**
+   * Cancel all pending debounced calls
+   */
+  cancelAll() {
+    for (const debouncer of this.debouncers.values()) {
+      debouncer.cancel();
+    }
+  }
+};
+
+// src/atomCreator.ts
+var debouncerMap = new DebouncerMap();
+function createPersistedAtom(config, entityId, storage, options) {
+  const baseAtom = atom(config.defaultValue);
+  const loadingAtom = atom(true);
+  baseAtom.onMount = (setValue) => {
+    storage.get(config.key).then((value) => {
+      if (value !== null && value !== void 0) {
+        setValue(value);
+      }
+    }).catch(console.error).finally(() => {
+      setTimeout(() => {
+        const store = getDefaultStore();
+        store.set(loadingAtom, false);
+      }, 0);
+    });
+  };
+  const writeAtom = atom(
+    (get) => get(baseAtom),
+    (get, set, update) => {
+      const newValue = typeof update === "function" ? update(get(baseAtom)) : update;
+      set(baseAtom, newValue);
+      if (options?.immediate) {
+        storage.set(config.key, newValue).catch(console.error);
+      } else {
+        const debounceKey = `${entityId}:${config.key}`;
+        const debounceMs = options?.debounceMs ?? 800;
+        const saveFn = () => {
+          storage.set(config.key, newValue).catch(console.error);
+        };
+        debouncerMap.debounce(debounceKey, saveFn, debounceMs);
+      }
+    }
+  );
+  return {
+    atom: writeAtom,
+    loadingAtom
+  };
+}
+
+// src/createStore.ts
+function createStore(entityId, config, options) {
+  const adapter = options?.storage;
+  const debounceMs = options?.debounceMs ?? 800;
+  if (adapter?.name === "remote" && typeof window === "undefined" && typeof process !== "undefined") {
+    import("./server-V7WCW4ZB.mjs").then(({ startServer }) => {
+      startServer().catch((err) => {
+        console.error("[bff-store] Failed to auto-start server:", err);
+      });
+    });
+  }
+  if (!adapter) {
+    throw new Error("Storage adapter is required");
+  }
+  if ("setEntityId" in adapter && typeof adapter.setEntityId === "function") {
+    adapter.setEntityId(entityId);
+  }
+  const storage = adapter.storage;
+  const atoms = {};
+  const loadingAtoms = {};
+  for (const atomConfig of config) {
+    const result = createPersistedAtom(atomConfig, entityId, storage, {
+      immediate: atomConfig.immediate,
+      debounceMs
+    });
+    atoms[atomConfig.key] = result.atom;
+    loadingAtoms[atomConfig.key] = result.loadingAtom;
+  }
+  return {
+    entityId,
+    config,
+    atoms,
+    loadingAtoms
+  };
+}
+
+// src/useStore.ts
+import { useAtom } from "jotai";
+import { useEffect, useState } from "react";
+import { getDefaultStore as getDefaultStore2 } from "jotai";
+function useStore(store) {
+  const [isLoading, setIsLoading] = useState(true);
+  useEffect(() => {
+    const storeInstance = getDefaultStore2();
+    const loadingAtoms = Object.values(store.loadingAtoms);
+    if (loadingAtoms.length === 0) {
+      setIsLoading(false);
+      return;
+    }
+    const checkLoadingStatus = () => {
+      const loadingStates = loadingAtoms.map((atom2) => storeInstance.get(atom2));
+      const anyLoading = loadingStates.some((loading) => loading === true);
+      setIsLoading(anyLoading);
+    };
+    checkLoadingStatus();
+    const unsubscribers = loadingAtoms.map(
+      (atom2) => storeInstance.sub(atom2, checkLoadingStatus)
+    );
+    return () => {
+      unsubscribers.forEach((unsub) => unsub());
+    };
+  }, [store.loadingAtoms]);
+  const result = buildStoreResult(store, isLoading);
+  return result;
+}
+function buildStoreResult(store, isLoading) {
+  const result = { isLoading };
+  for (let i = 0; i < store.config.length; i++) {
+    const config = store.config[i];
+    const atom2 = store.atoms[config.key];
+    const [value, setter] = useAtom(atom2);
+    result[config.key] = value;
+    result[`set${capitalize(config.key)}`] = setter;
+  }
+  return result;
+}
+function capitalize(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+
+// src/storage/memory.ts
+function memoryStorage(_options) {
+  const store = /* @__PURE__ */ new Map();
+  const storage = {
+    async get(key) {
+      return store.get(key) ?? null;
+    },
+    async set(key, value) {
+      store.set(key, value);
+    },
+    async remove(key) {
+      store.delete(key);
+    },
+    async getMultiple(keys) {
+      const result = /* @__PURE__ */ new Map();
+      for (const key of keys) {
+        const value = store.get(key);
+        if (value !== void 0) {
+          result.set(key, value);
+        }
+      }
+      return result;
+    },
+    async setMultiple(entries) {
+      entries.forEach((value, key) => {
+        store.set(key, value);
+      });
+    }
+  };
+  return {
+    storage,
+    name: "memory"
+  };
+}
+var createMemoryStorage = memoryStorage;
+
+// src/storage/transport.ts
+var HttpTransport = class {
+  async get(url) {
+    const res = await fetch(url);
+    if (!res.ok) {
+      throw new Error(`GET ${url} failed: ${res.statusText}`);
+    }
+    return res.json();
+  }
+  async post(url, body) {
+    const res = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    });
+    if (!res.ok) {
+      throw new Error(`POST ${url} failed: ${res.statusText}`);
+    }
+    return res.json();
+  }
+  async delete(url) {
+    const res = await fetch(url, { method: "DELETE" });
+    if (!res.ok) {
+      throw new Error(`DELETE ${url} failed: ${res.statusText}`);
+    }
+  }
+};
+function createStorageFromTransport(transport, baseUrl) {
+  return {
+    async get(key) {
+      try {
+        const res = await transport.get(`${baseUrl}/storage/get/${encodeURIComponent(key)}`);
+        return res.value;
+      } catch (err) {
+        if (err.message.includes("failed")) {
+          return null;
+        }
+        throw err;
+      }
+    },
+    async set(key, value) {
+      await transport.post(`${baseUrl}/storage/set/${encodeURIComponent(key)}`, { value });
+    },
+    async remove(key) {
+      await transport.delete(`${baseUrl}/storage/delete/${encodeURIComponent(key)}`);
+    },
+    async getMultiple(keys) {
+      const res = await transport.post(
+        `${baseUrl}/storage/batch-get`,
+        { keys }
+      );
+      return new Map(Object.entries(res.entries));
+    },
+    async setMultiple(entries) {
+      const obj = {};
+      entries.forEach((value, key) => {
+        obj[key] = value;
+      });
+      await transport.post(`${baseUrl}/storage/batch-set`, { entries: obj });
+    }
+  };
+}
+
+// src/storage/protocol.ts
+var RestStorageProtocol = class _RestStorageProtocol {
+  constructor(baseUrl, entityId, backendConfig = {}) {
+    this.baseUrl = baseUrl;
+    this.entityId = entityId;
+    this.backendConfig = backendConfig;
+  }
+  getEntityId() {
+    return typeof this.entityId === "object" ? this.entityId.current : this.entityId;
+  }
+  appendBackendParams(params) {
+    if (this.backendConfig.backend) {
+      params.set("backend", this.backendConfig.backend);
+    }
+    if (this.backendConfig.mongoUrl) {
+      params.set("mongoUrl", this.backendConfig.mongoUrl);
+    }
+    if (this.backendConfig.mongoDb) {
+      params.set("mongoDb", this.backendConfig.mongoDb);
+    }
+    if (this.backendConfig.jsonlDir) {
+      params.set("jsonlDir", this.backendConfig.jsonlDir);
+    }
+  }
+  buildUrl(path, key) {
+    const url = `${this.baseUrl}${path}${encodeURIComponent(key)}`;
+    const params = new URLSearchParams();
+    const eid = this.getEntityId();
+    if (eid) {
+      params.set("entityId", eid);
+    }
+    this.appendBackendParams(params);
+    const queryString = params.toString();
+    return queryString ? `${url}?${queryString}` : url;
+  }
+  buildGetUrl(key) {
+    return this.buildUrl("/storage/get/", key);
+  }
+  buildSetUrl(key) {
+    return this.buildUrl("/storage/set/", key);
+  }
+  buildDeleteUrl(key) {
+    return this.buildUrl("/storage/delete/", key);
+  }
+  buildBatchGetUrl() {
+    const url = `${this.baseUrl}/storage/batch-get`;
+    const params = new URLSearchParams();
+    const eid = this.getEntityId();
+    if (eid) {
+      params.set("entityId", eid);
+    }
+    this.appendBackendParams(params);
+    const queryString = params.toString();
+    return queryString ? `${url}?${queryString}` : url;
+  }
+  buildBatchSetUrl() {
+    const url = `${this.baseUrl}/storage/batch-set`;
+    const params = new URLSearchParams();
+    const eid = this.getEntityId();
+    if (eid) {
+      params.set("entityId", eid);
+    }
+    this.appendBackendParams(params);
+    const queryString = params.toString();
+    return queryString ? `${url}?${queryString}` : url;
+  }
+  getBackendConfig() {
+    return this.backendConfig;
+  }
+  withEntityId(entityId) {
+    return new _RestStorageProtocol(this.baseUrl, entityId, this.backendConfig);
+  }
+};
+function createStorageWithProtocol(transport, protocol) {
+  const backendConfig = "getBackendConfig" in protocol ? protocol.getBackendConfig() : {};
+  return {
+    async get(key) {
+      try {
+        const res = await transport.get(protocol.buildGetUrl(key));
+        return res.value;
+      } catch (err) {
+        if (err.message.includes("failed")) {
+          return null;
+        }
+        throw err;
+      }
+    },
+    async set(key, value) {
+      const body = { value, ...backendConfig };
+      await transport.post(protocol.buildSetUrl(key), body);
+    },
+    async remove(key) {
+      await transport.delete(protocol.buildDeleteUrl(key));
+    },
+    async getMultiple(keys) {
+      const res = await transport.post(
+        protocol.buildBatchGetUrl(),
+        { keys, ...backendConfig }
+      );
+      return new Map(Object.entries(res.entries));
+    },
+    async setMultiple(entries) {
+      const obj = {};
+      entries.forEach((value, key) => {
+        obj[key] = value;
+      });
+      await transport.post(protocol.buildBatchSetUrl(), { entries: obj, ...backendConfig });
+    }
+  };
+}
+
+// src/storage/adapters/remoteStorage.ts
+function remoteStorage(options = {}) {
+  const baseUrl = options.baseUrl ?? "http://localhost:3847";
+  const transport = options.transport ?? new HttpTransport();
+  const entityId = { current: options.entityId };
+  const backendConfig = {
+    backend: options.backend,
+    mongoUrl: options.mongoUrl,
+    mongoDb: options.mongoDb,
+    jsonlDir: options.jsonlDir
+  };
+  const protocol = options.protocol ?? new RestStorageProtocol(baseUrl, entityId.current, backendConfig);
+  const storage = createStorageWithProtocol(transport, protocol);
+  const adapter = {
+    storage,
+    name: "remote",
+    setEntityId(id) {
+      entityId.current = id;
+    }
+  };
+  return adapter;
+}
+export {
+  HttpTransport,
+  RestStorageProtocol,
+  createMemoryStorage,
+  createPersistedAtom,
+  remoteStorage as createRemoteStorage,
+  createStorageFromTransport,
+  createStorageWithProtocol,
+  createStore,
+  memoryStorage,
+  remoteStorage,
+  useStore
+};

package/dist/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "bff-store",
+  "version": "0.1.0",
+  "description": "A jotai-based state management library with pluggable storage adapters",
+  "main": "index.js",
+  "module": "index.mjs",
+  "types": "index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./index.mjs",
+      "require": "./index.js"
+    },
+    "./jsonl": {
+      "types": "./storage/jsonl-entry.d.ts",
+      "import": "./storage/jsonl-entry.mjs",
+      "require": "./storage/jsonl-entry.js"
+    },
+    "./mongodb": {
+      "types": "./storage/mongodb-entry.d.ts",
+      "import": "./storage/mongodb-entry.mjs",
+      "require": "./storage/mongodb-entry.js"
+    },
+    "./server": {
+      "types": "./server/entry.d.ts",
+      "import": "./server/entry.mjs",
+      "require": "./server/entry.js"
+    }
+  },
+  "scripts": {
+    "build": "tsup && cp package.json dist/package.json && node scripts/adapt-dist-package.js && for f in dist/*.d.mts; do cp \"$f\" \"${f%.d.mts}.d.ts\"; done",
+    "dev": "tsup --watch",
+    "test": "vitest",
+    "start": "node dist/server/cli.js"
+  },
+  "keywords": [
+    "jotai",
+    "state-management",
+    "react",
+    "storage"
+  ],
+  "peerDependencies": {
+    "jotai": ">=2.0.0",
+    "react": ">=18.0.0"
+  },
+  "devDependencies": {
+    "@testing-library/dom": "^10.4.1",
+    "@testing-library/react": "^16.3.2",
+    "@types/node": "^20.0.0",
+    "@types/react": "^19.2.16",
+    "jotai": "^2.6.0",
+    "jsdom": "^29.1.1",
+    "react": "^18.2.0",
+    "react-dom": "^18.2.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.0.0",
+    "vitest": "^1.0.0"
+  },
+  "dependencies": {
+    "mongodb": "^6.21.0"
+  }
+}

package/dist/server/entry.d.mts

@@ -0,0 +1,94 @@
+import * as http from 'http';
+import { IncomingMessage, ServerResponse } from 'http';
+
+/**
+ * HTTP Router for Storage Server
+ *
+ * Simple pattern-based router for HTTP requests.
+ */
+
+type RequestHandler = (req: IncomingMessage, res: ServerResponse, params?: Record<string, string>) => Promise<void>;
+declare class Router {
+    private routes;
+    addRoute(method: string, path: string, handler: RequestHandler): void;
+    get(path: string, handler: RequestHandler): void;
+    post(path: string, handler: RequestHandler): void;
+    delete(path: string, handler: RequestHandler): void;
+    handle(req: IncomingMessage, res: ServerResponse): Promise<boolean>;
+}
+
+interface Storage {
+    get<T>(key: string): Promise<T | null>;
+    set<T>(key: string, value: T): Promise<void>;
+    remove(key: string): Promise<void>;
+    /** Optional: get multiple keys at once for batch loading */
+    getMultiple?<T>(keys: string[]): Promise<Map<string, T>>;
+    /** Optional: set multiple keys at once for batch saving */
+    setMultiple?<T>(entries: Map<string, T>): Promise<void>;
+}
+
+/**
+ * EntityId Cache for Multi-Tenant Storage
+ *
+ * Caches storage instances per entityId to avoid recreating them.
+ */
+
+interface EntityIdCacheOptions {
+    dir: string;
+}
+declare class EntityIdCache {
+    private cache;
+    private defaultStorage;
+    private dir;
+    constructor(options: EntityIdCacheOptions);
+    getStorage(entityId?: string): Storage;
+    getEntityIds(): string[];
+    clear(): void;
+    size(): number;
+}
+
+/**
+ * Storage Handlers
+ *
+ * Request handlers for storage operations with caching for dynamic storage adapters.
+ */
+
+interface StorageHandlersOptions {
+    getStorage: (entityId?: string) => Storage;
+}
+declare function createStorageHandlers(options: StorageHandlersOptions): {
+    handleGet: (req: IncomingMessage, res: ServerResponse, params?: Record<string, string>) => Promise<void>;
+    handleSet: (req: IncomingMessage, res: ServerResponse, params?: Record<string, string>) => Promise<void>;
+    handleDelete: (req: IncomingMessage, res: ServerResponse, params?: Record<string, string>) => Promise<void>;
+    handleBatchGet: (req: IncomingMessage, res: ServerResponse) => Promise<void>;
+    handleBatchSet: (req: IncomingMessage, res: ServerResponse) => Promise<void>;
+    handleHealth: (req: IncomingMessage, res: ServerResponse) => Promise<void>;
+};
+
+/**
+ * Embedded Sidecar API Server
+ *
+ * Lightweight HTTP server that proxies storage operations to JSONL or MongoDB.
+ * Auto-shuts down when parent process exits.
+ *
+ * Supports singleton mode: call startServer() multiple times, only one server starts.
+ */
+
+interface ServerOptions {
+    port?: number;
+    host?: string;
+    backend: 'jsonl' | 'mongodb';
+    jsonlDir?: string;
+    mongoUrl?: string;
+    mongoDb?: string;
+}
+/**
+ * Start the embedded API server (singleton).
+ *
+ * First call starts the server. Subsequent calls return the existing instance.
+ * If the existing server has been closed externally, a new one will be started.
+ * Use options to customize on first call only.
+ */
+declare function startServer(options?: Partial<ServerOptions>): Promise<http.Server>;
+
+export { EntityIdCache, Router, type ServerOptions, createStorageHandlers, startServer };

package/dist/server/entry.d.ts

@@ -0,0 +1,94 @@
+import * as http from 'http';
+import { IncomingMessage, ServerResponse } from 'http';
+
+/**
+ * HTTP Router for Storage Server
+ *
+ * Simple pattern-based router for HTTP requests.
+ */
+
+type RequestHandler = (req: IncomingMessage, res: ServerResponse, params?: Record<string, string>) => Promise<void>;
+declare class Router {
+    private routes;
+    addRoute(method: string, path: string, handler: RequestHandler): void;
+    get(path: string, handler: RequestHandler): void;
+    post(path: string, handler: RequestHandler): void;
+    delete(path: string, handler: RequestHandler): void;
+    handle(req: IncomingMessage, res: ServerResponse): Promise<boolean>;
+}
+
+interface Storage {
+    get<T>(key: string): Promise<T | null>;
+    set<T>(key: string, value: T): Promise<void>;
+    remove(key: string): Promise<void>;
+    /** Optional: get multiple keys at once for batch loading */
+    getMultiple?<T>(keys: string[]): Promise<Map<string, T>>;
+    /** Optional: set multiple keys at once for batch saving */
+    setMultiple?<T>(entries: Map<string, T>): Promise<void>;
+}
+
+/**
+ * EntityId Cache for Multi-Tenant Storage
+ *
+ * Caches storage instances per entityId to avoid recreating them.
+ */
+
+interface EntityIdCacheOptions {
+    dir: string;
+}
+declare class EntityIdCache {
+    private cache;
+    private defaultStorage;
+    private dir;
+    constructor(options: EntityIdCacheOptions);
+    getStorage(entityId?: string): Storage;
+    getEntityIds(): string[];
+    clear(): void;
+    size(): number;
+}
+
+/**
+ * Storage Handlers
+ *
+ * Request handlers for storage operations with caching for dynamic storage adapters.
+ */
+
+interface StorageHandlersOptions {
+    getStorage: (entityId?: string) => Storage;
+}
+declare function createStorageHandlers(options: StorageHandlersOptions): {
+    handleGet: (req: IncomingMessage, res: ServerResponse, params?: Record<string, string>) => Promise<void>;
+    handleSet: (req: IncomingMessage, res: ServerResponse, params?: Record<string, string>) => Promise<void>;
+    handleDelete: (req: IncomingMessage, res: ServerResponse, params?: Record<string, string>) => Promise<void>;
+    handleBatchGet: (req: IncomingMessage, res: ServerResponse) => Promise<void>;
+    handleBatchSet: (req: IncomingMessage, res: ServerResponse) => Promise<void>;
+    handleHealth: (req: IncomingMessage, res: ServerResponse) => Promise<void>;
+};
+
+/**
+ * Embedded Sidecar API Server
+ *
+ * Lightweight HTTP server that proxies storage operations to JSONL or MongoDB.
+ * Auto-shuts down when parent process exits.
+ *
+ * Supports singleton mode: call startServer() multiple times, only one server starts.
+ */
+
+interface ServerOptions {
+    port?: number;
+    host?: string;
+    backend: 'jsonl' | 'mongodb';
+    jsonlDir?: string;
+    mongoUrl?: string;
+    mongoDb?: string;
+}
+/**
+ * Start the embedded API server (singleton).
+ *
+ * First call starts the server. Subsequent calls return the existing instance.
+ * If the existing server has been closed externally, a new one will be started.
+ * Use options to customize on first call only.
+ */
+declare function startServer(options?: Partial<ServerOptions>): Promise<http.Server>;
+
+export { EntityIdCache, Router, type ServerOptions, createStorageHandlers, startServer };