bff-store 0.1.0

package/dist/server/entry.mjs

@@ -0,0 +1,533 @@
+// src/server/index.ts
+import * as http from "http";
+
+// src/storage/mongodb.ts
+import { MongoClient } from "mongodb";
+async function mongodbStorage(options) {
+  const {
+    url,
+    database = "jotai_state_store"
+  } = options;
+  const client = new MongoClient(url);
+  await client.connect();
+  const db = client.db(database);
+  let currentEntityId = "default";
+  function getCollectionName(eId) {
+    return `state_${eId}`;
+  }
+  function getCollection(eId) {
+    return db.collection(getCollectionName(eId));
+  }
+  const storage = {
+    async get(key) {
+      const collection = getCollection(currentEntityId);
+      const entry = await collection.findOne(
+        { key },
+        { sort: { timestamp: -1 } }
+      );
+      return entry ? entry.value : null;
+    },
+    async set(key, value) {
+      const collection = getCollection(currentEntityId);
+      await collection.insertOne({
+        key,
+        value,
+        timestamp: Date.now(),
+        entityId: currentEntityId
+      });
+    },
+    async remove(key) {
+      const collection = getCollection(currentEntityId);
+      await collection.deleteMany({ key });
+    },
+    async getMultiple(keys) {
+      const collection = getCollection(currentEntityId);
+      const entries = await collection.find({ key: { $in: keys } }).sort({ timestamp: -1 }).toArray();
+      const result = /* @__PURE__ */ new Map();
+      const seen = /* @__PURE__ */ new Set();
+      for (const entry of entries) {
+        if (!seen.has(entry.key)) {
+          result.set(entry.key, entry.value);
+          seen.add(entry.key);
+        }
+      }
+      return result;
+    },
+    async setMultiple(entries) {
+      const collection = getCollection(currentEntityId);
+      const docs = [];
+      entries.forEach((value, key) => {
+        docs.push({
+          key,
+          value,
+          timestamp: Date.now(),
+          entityId: currentEntityId
+        });
+      });
+      if (docs.length > 0) {
+        await collection.insertMany(docs);
+      }
+    }
+  };
+  const adapter = {
+    storage,
+    name: "mongodb",
+    client,
+    setEntityId(id) {
+      currentEntityId = id;
+    },
+    async close() {
+      await client.close();
+    }
+  };
+  return adapter;
+}
+
+// src/server/router.ts
+var Router = class {
+  constructor() {
+    this.routes = [];
+  }
+  addRoute(method, path2, handler) {
+    const paramNames = [];
+    const regexPattern = path2.replace(/:([^/]+)/g, (_, name) => {
+      paramNames.push(name);
+      return "([^/]+)";
+    });
+    const pattern = new RegExp(`^${regexPattern}$`);
+    this.routes.push({
+      method: method.toUpperCase(),
+      pattern,
+      paramNames,
+      handler: (req, res, params) => handler(req, res, params)
+    });
+  }
+  get(path2, handler) {
+    this.addRoute("GET", path2, handler);
+  }
+  post(path2, handler) {
+    this.addRoute("POST", path2, handler);
+  }
+  delete(path2, handler) {
+    this.addRoute("DELETE", path2, handler);
+  }
+  async handle(req, res) {
+    const method = req.method?.toUpperCase() ?? "GET";
+    const url = new URL(req.url ?? "/", "http://localhost");
+    for (const route of this.routes) {
+      if (route.method !== method) continue;
+      const match = url.pathname.match(route.pattern);
+      if (match) {
+        const params = {};
+        route.paramNames.forEach((name, index) => {
+          params[name] = decodeURIComponent(match[index + 1]);
+        });
+        await route.handler(req, res, params);
+        return true;
+      }
+    }
+    return false;
+  }
+};
+
+// src/storage/jsonl.ts
+import * as fs from "fs";
+import * as path from "path";
+function jsonlStorage(options) {
+  const baseDir = options?.dir ?? "./sessions";
+  let entityId = "default";
+  function getFilePath(eId, key) {
+    const safeKey = key.replace(/[^a-zA-Z0-9_]/g, "_");
+    return path.join(baseDir, eId, `${safeKey}.jsonl`);
+  }
+  const storage = {
+    async get(key) {
+      if (!entityId) return null;
+      const filePath = getFilePath(entityId, key);
+      if (!fs.existsSync(filePath)) {
+        return null;
+      }
+      try {
+        const content = fs.readFileSync(filePath, "utf-8");
+        const lines = content.trim().split("\n").filter(Boolean);
+        if (lines.length === 0) return null;
+        const lastLine = lines[lines.length - 1];
+        const entry = JSON.parse(lastLine);
+        return entry.value;
+      } catch {
+        return null;
+      }
+    },
+    async set(key, value) {
+      if (!entityId) return;
+      const filePath = getFilePath(entityId, key);
+      const dir = path.dirname(filePath);
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+      const entry = {
+        key,
+        value,
+        timestamp: Date.now()
+      };
+      const line = JSON.stringify(entry) + "\n";
+      fs.appendFileSync(filePath, line, "utf-8");
+    },
+    async remove(key) {
+      if (!entityId) return;
+      const filePath = getFilePath(entityId, key);
+      if (fs.existsSync(filePath)) {
+        fs.unlinkSync(filePath);
+      }
+    },
+    async getMultiple(keys) {
+      const result = /* @__PURE__ */ new Map();
+      for (const key of keys) {
+        const value = await this.get(key);
+        if (value !== null) {
+          result.set(key, value);
+        }
+      }
+      return result;
+    }
+  };
+  return {
+    storage,
+    name: "jsonl",
+    setEntityId(id) {
+      entityId = id;
+    }
+  };
+}
+
+// src/server/entityIdCache.ts
+var EntityIdCache = class {
+  constructor(options) {
+    this.cache = /* @__PURE__ */ new Map();
+    this.dir = options.dir;
+    const adapter = jsonlStorage({ dir: options.dir });
+    adapter.setEntityId("default");
+    this.defaultStorage = adapter.storage;
+  }
+  getStorage(entityId) {
+    if (!entityId || entityId === "default") {
+      return this.defaultStorage;
+    }
+    let storage = this.cache.get(entityId);
+    if (storage) {
+      return storage;
+    }
+    const adapter = jsonlStorage({ dir: this.dir });
+    adapter.setEntityId(entityId);
+    storage = adapter.storage;
+    this.cache.set(entityId, storage);
+    return storage;
+  }
+  getEntityIds() {
+    return Array.from(this.cache.keys());
+  }
+  clear() {
+    this.cache.clear();
+  }
+  size() {
+    return this.cache.size;
+  }
+};
+
+// src/server/handlers.ts
+var storageCache = /* @__PURE__ */ new Map();
+var MAX_CACHE_SIZE = 10;
+var CACHE_TTL_MS = 5 * 60 * 1e3;
+function getCacheKey(config) {
+  if (config.backend === "mongodb") {
+    return `mongodb:${config.mongoUrl}:${config.mongoDb ?? "default"}`;
+  }
+  if (config.backend === "jsonl") {
+    return `jsonl:${config.jsonlDir ?? "./data"}`;
+  }
+  return "default";
+}
+function getBackendConfig(req) {
+  const url = new URL(req.url ?? "/", "http://localhost");
+  return {
+    backend: url.searchParams.get("backend") ?? void 0,
+    mongoUrl: url.searchParams.get("mongoUrl") ?? void 0,
+    mongoDb: url.searchParams.get("mongoDb") ?? void 0,
+    jsonlDir: url.searchParams.get("jsonlDir") ?? void 0
+  };
+}
+function getEntityId(req) {
+  const url = new URL(req.url ?? "/", "http://localhost");
+  return url.searchParams.get("entityId") ?? void 0;
+}
+async function parseBody(req) {
+  let body = "";
+  for await (const chunk of req) {
+    body += chunk;
+  }
+  return JSON.parse(body);
+}
+function cleanExpiredCache() {
+  const now = Date.now();
+  for (const [key, entry] of storageCache.entries()) {
+    if (now - entry.lastUsed > CACHE_TTL_MS) {
+      storageCache.delete(key);
+    }
+  }
+}
+async function getCachedStorage(config, entityId) {
+  const key = getCacheKey(config);
+  if (storageCache.has(key)) {
+    const entry = storageCache.get(key);
+    entry.lastUsed = Date.now();
+    if (entityId && "setEntityId" in entry.adapter && typeof entry.adapter.setEntityId === "function") {
+      entry.adapter.setEntityId(entityId);
+    }
+    return entry.adapter.storage;
+  }
+  if (storageCache.size >= MAX_CACHE_SIZE) {
+    let oldestKey = null;
+    let oldestTime = Infinity;
+    for (const [k, entry] of storageCache.entries()) {
+      if (entry.lastUsed < oldestTime) {
+        oldestTime = entry.lastUsed;
+        oldestKey = k;
+      }
+    }
+    if (oldestKey) {
+      storageCache.delete(oldestKey);
+    }
+  }
+  let adapter;
+  if (config.backend === "mongodb") {
+    if (!config.mongoUrl) {
+      throw new Error("mongoUrl is required for mongodb backend");
+    }
+    adapter = await mongodbStorage({
+      url: config.mongoUrl,
+      database: config.mongoDb ?? "jotai_state_store"
+    });
+  } else if (config.backend === "jsonl") {
+    adapter = jsonlStorage({ dir: config.jsonlDir ?? "./data" });
+  } else {
+    throw new Error("Unknown backend type");
+  }
+  if (entityId && "setEntityId" in adapter && typeof adapter.setEntityId === "function") {
+    adapter.setEntityId(entityId);
+  }
+  storageCache.set(key, { adapter, lastUsed: Date.now() });
+  return adapter.storage;
+}
+function createStorageHandlers(options) {
+  const { getStorage } = options;
+  async function resolveStorage(req) {
+    const entityId = getEntityId(req);
+    const urlConfig = getBackendConfig(req);
+    let body = null;
+    if (req.method === "POST" || req.method === "PUT" || req.method === "PATCH") {
+      try {
+        body = await parseBody(req);
+      } catch {
+      }
+    }
+    const config = body ? {
+      backend: body.backend ?? urlConfig.backend,
+      mongoUrl: body.mongoUrl ?? urlConfig.mongoUrl,
+      mongoDb: body.mongoDb ?? urlConfig.mongoDb,
+      jsonlDir: body.jsonlDir ?? urlConfig.jsonlDir
+    } : urlConfig;
+    if (config.backend) {
+      cleanExpiredCache();
+      const storage = await getCachedStorage(config, entityId);
+      return { storage, body };
+    }
+    return { storage: getStorage(entityId), body };
+  }
+  async function handleGet(req, res, params) {
+    const { storage } = await resolveStorage(req);
+    const value = await storage.get(params?.key ?? "");
+    res.setHeader("Content-Type", "application/json");
+    res.writeHead(200);
+    res.end(JSON.stringify({ value }));
+  }
+  async function handleSet(req, res, params) {
+    const { storage, body } = await resolveStorage(req);
+    const value = body?.value;
+    await storage.set(params?.key ?? "", value);
+    res.setHeader("Content-Type", "application/json");
+    res.writeHead(200);
+    res.end(JSON.stringify({ success: true }));
+  }
+  async function handleDelete(req, res, params) {
+    const { storage } = await resolveStorage(req);
+    await storage.remove(params?.key ?? "");
+    res.setHeader("Content-Type", "application/json");
+    res.writeHead(200);
+    res.end(JSON.stringify({ success: true }));
+  }
+  async function handleBatchGet(req, res) {
+    const { storage, body } = await resolveStorage(req);
+    const keys = body?.keys ?? [];
+    let result;
+    if (storage.getMultiple) {
+      result = await storage.getMultiple(keys);
+    } else {
+      result = /* @__PURE__ */ new Map();
+      for (const key of keys) {
+        const value = await storage.get(key);
+        if (value !== null) {
+          result.set(key, value);
+        }
+      }
+    }
+    const entries = {};
+    result.forEach((value, key) => {
+      entries[key] = value;
+    });
+    res.setHeader("Content-Type", "application/json");
+    res.writeHead(200);
+    res.end(JSON.stringify({ entries }));
+  }
+  async function handleBatchSet(req, res) {
+    const { storage, body } = await resolveStorage(req);
+    const entries = body?.entries ?? {};
+    if (storage.setMultiple) {
+      const map = new Map(Object.entries(entries));
+      await storage.setMultiple(map);
+    } else {
+      for (const [key, value] of Object.entries(entries)) {
+        await storage.set(key, value);
+      }
+    }
+    res.setHeader("Content-Type", "application/json");
+    res.writeHead(200);
+    res.end(JSON.stringify({ success: true }));
+  }
+  async function handleHealth(req, res) {
+    res.setHeader("Content-Type", "application/json");
+    res.writeHead(200);
+    res.end(JSON.stringify({ status: "ok" }));
+  }
+  return {
+    handleGet,
+    handleSet,
+    handleDelete,
+    handleBatchGet,
+    handleBatchSet,
+    handleHealth
+  };
+}
+
+// src/server/index.ts
+var serverInstance = null;
+var serverPromise = null;
+var defaultOptions = {
+  backend: "jsonl",
+  port: 3847,
+  host: "localhost",
+  jsonlDir: "./data"
+};
+async function startServer(options) {
+  if (serverInstance && serverInstance.listening) {
+    return serverInstance;
+  }
+  if (serverPromise) {
+    return serverPromise;
+  }
+  if (serverInstance) {
+    serverInstance = null;
+  }
+  const opts = {
+    backend: options?.mongoUrl ? "mongodb" : options?.backend ?? defaultOptions.backend,
+    port: options?.port ?? defaultOptions.port,
+    host: options?.host ?? defaultOptions.host,
+    jsonlDir: options?.jsonlDir ?? defaultOptions.jsonlDir,
+    mongoUrl: options?.mongoUrl,
+    mongoDb: options?.mongoDb
+  };
+  serverPromise = _startServer(opts);
+  try {
+    serverInstance = await serverPromise;
+    return serverInstance;
+  } finally {
+    serverPromise = null;
+  }
+}
+async function _startServer(options) {
+  const port = options.port ?? 3847;
+  const host = options.host ?? "localhost";
+  let storage;
+  let entityIdCache;
+  if (options.backend === "jsonl") {
+    entityIdCache = new EntityIdCache({ dir: options.jsonlDir ?? "./data" });
+    storage = entityIdCache.getStorage();
+  } else if (options.backend === "mongodb") {
+    const adapter = await mongodbStorage({
+      url: options.mongoUrl,
+      database: options.mongoDb ?? "jotai_state_store"
+    });
+    storage = adapter.storage;
+  } else {
+    throw new Error(`Unsupported backend: ${options.backend}`);
+  }
+  const handlers = createStorageHandlers({
+    getStorage: (entityId) => entityIdCache ? entityIdCache.getStorage(entityId) : storage
+  });
+  const router = new Router();
+  router.get("/storage/get/:key", handlers.handleGet);
+  router.post("/storage/set/:key", handlers.handleSet);
+  router.delete("/storage/delete/:key", handlers.handleDelete);
+  router.post("/storage/batch-get", handlers.handleBatchGet);
+  router.post("/storage/batch-set", handlers.handleBatchSet);
+  router.get("/health", handlers.handleHealth);
+  const server = http.createServer(async (req, res) => {
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.setHeader("Access-Control-Allow-Methods", "GET, POST, DELETE, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+    res.setHeader("Content-Type", "application/json");
+    if (req.method === "OPTIONS") {
+      res.writeHead(204);
+      res.end();
+      return;
+    }
+    try {
+      const matched = await router.handle(req, res);
+      if (!matched) {
+        res.writeHead(404);
+        res.end(JSON.stringify({ error: "Not found" }));
+      }
+    } catch (err) {
+      console.error("[bff-store] Error:", err);
+      res.writeHead(500);
+      res.end(JSON.stringify({ error: String(err) }));
+    }
+  });
+  return new Promise((resolve, reject) => {
+    server.on("error", reject);
+    server.listen(port, host, () => {
+      console.log(`[bff-store] Server running on http://${host}:${port}`);
+      console.log(`[bff-store] Backend: ${options.backend}`);
+      resolve(server);
+    });
+    const shutdown = (signal) => {
+      console.log(`
+[bff-store] Received ${signal}, shutting down...`);
+      server.close(() => {
+        console.log("[bff-store] Server closed");
+        process.exit(0);
+      });
+      setTimeout(() => {
+        console.error("[bff-store] Forced shutdown");
+        process.exit(1);
+      }, 5e3);
+    };
+    process.on("SIGINT", () => shutdown("SIGINT"));
+    process.on("SIGTERM", () => shutdown("SIGTERM"));
+  });
+}
+export {
+  EntityIdCache,
+  Router,
+  createStorageHandlers,
+  startServer
+};