@fairfox/polly 0.72.0 → 0.73.0

package/dist/src/elysia/index.js

@@ -69,10 +69,464 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
 
+// node:path
+var exports_path = {};
+__export(exports_path, {
+  sep: () => sep,
+  resolve: () => resolve,
+  relative: () => relative,
+  posix: () => posix,
+  parse: () => parse,
+  normalize: () => normalize,
+  join: () => join,
+  isAbsolute: () => isAbsolute,
+  format: () => format,
+  extname: () => extname,
+  dirname: () => dirname,
+  delimiter: () => delimiter,
+  default: () => path_default,
+  basename: () => basename,
+  _makeLong: () => _makeLong
+});
+function assertPath(path) {
+  if (typeof path !== "string")
+    throw TypeError("Path must be a string. Received " + JSON.stringify(path));
+}
+function normalizeStringPosix(path, allowAboveRoot) {
+  var res = "", lastSegmentLength = 0, lastSlash = -1, dots = 0, code;
+  for (var i = 0;i <= path.length; ++i) {
+    if (i < path.length)
+      code = path.charCodeAt(i);
+    else if (code === 47)
+      break;
+    else
+      code = 47;
+    if (code === 47) {
+      if (lastSlash === i - 1 || dots === 1)
+        ;
+      else if (lastSlash !== i - 1 && dots === 2) {
+        if (res.length < 2 || lastSegmentLength !== 2 || res.charCodeAt(res.length - 1) !== 46 || res.charCodeAt(res.length - 2) !== 46) {
+          if (res.length > 2) {
+            var lastSlashIndex = res.lastIndexOf("/");
+            if (lastSlashIndex !== res.length - 1) {
+              if (lastSlashIndex === -1)
+                res = "", lastSegmentLength = 0;
+              else
+                res = res.slice(0, lastSlashIndex), lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
+              lastSlash = i, dots = 0;
+              continue;
+            }
+          } else if (res.length === 2 || res.length === 1) {
+            res = "", lastSegmentLength = 0, lastSlash = i, dots = 0;
+            continue;
+          }
+        }
+        if (allowAboveRoot) {
+          if (res.length > 0)
+            res += "/..";
+          else
+            res = "..";
+          lastSegmentLength = 2;
+        }
+      } else {
+        if (res.length > 0)
+          res += "/" + path.slice(lastSlash + 1, i);
+        else
+          res = path.slice(lastSlash + 1, i);
+        lastSegmentLength = i - lastSlash - 1;
+      }
+      lastSlash = i, dots = 0;
+    } else if (code === 46 && dots !== -1)
+      ++dots;
+    else
+      dots = -1;
+  }
+  return res;
+}
+function _format(sep, pathObject) {
+  var dir = pathObject.dir || pathObject.root, base = pathObject.base || (pathObject.name || "") + (pathObject.ext || "");
+  if (!dir)
+    return base;
+  if (dir === pathObject.root)
+    return dir + base;
+  return dir + sep + base;
+}
+function resolve() {
+  var resolvedPath = "", resolvedAbsolute = false, cwd;
+  for (var i = arguments.length - 1;i >= -1 && !resolvedAbsolute; i--) {
+    var path;
+    if (i >= 0)
+      path = arguments[i];
+    else {
+      if (cwd === undefined)
+        cwd = process.cwd();
+      path = cwd;
+    }
+    if (assertPath(path), path.length === 0)
+      continue;
+    resolvedPath = path + "/" + resolvedPath, resolvedAbsolute = path.charCodeAt(0) === 47;
+  }
+  if (resolvedPath = normalizeStringPosix(resolvedPath, !resolvedAbsolute), resolvedAbsolute)
+    if (resolvedPath.length > 0)
+      return "/" + resolvedPath;
+    else
+      return "/";
+  else if (resolvedPath.length > 0)
+    return resolvedPath;
+  else
+    return ".";
+}
+function normalize(path) {
+  if (assertPath(path), path.length === 0)
+    return ".";
+  var isAbsolute = path.charCodeAt(0) === 47, trailingSeparator = path.charCodeAt(path.length - 1) === 47;
+  if (path = normalizeStringPosix(path, !isAbsolute), path.length === 0 && !isAbsolute)
+    path = ".";
+  if (path.length > 0 && trailingSeparator)
+    path += "/";
+  if (isAbsolute)
+    return "/" + path;
+  return path;
+}
+function isAbsolute(path) {
+  return assertPath(path), path.length > 0 && path.charCodeAt(0) === 47;
+}
+function join() {
+  if (arguments.length === 0)
+    return ".";
+  var joined;
+  for (var i = 0;i < arguments.length; ++i) {
+    var arg = arguments[i];
+    if (assertPath(arg), arg.length > 0)
+      if (joined === undefined)
+        joined = arg;
+      else
+        joined += "/" + arg;
+  }
+  if (joined === undefined)
+    return ".";
+  return normalize(joined);
+}
+function relative(from, to) {
+  if (assertPath(from), assertPath(to), from === to)
+    return "";
+  if (from = resolve(from), to = resolve(to), from === to)
+    return "";
+  var fromStart = 1;
+  for (;fromStart < from.length; ++fromStart)
+    if (from.charCodeAt(fromStart) !== 47)
+      break;
+  var fromEnd = from.length, fromLen = fromEnd - fromStart, toStart = 1;
+  for (;toStart < to.length; ++toStart)
+    if (to.charCodeAt(toStart) !== 47)
+      break;
+  var toEnd = to.length, toLen = toEnd - toStart, length = fromLen < toLen ? fromLen : toLen, lastCommonSep = -1, i = 0;
+  for (;i <= length; ++i) {
+    if (i === length) {
+      if (toLen > length) {
+        if (to.charCodeAt(toStart + i) === 47)
+          return to.slice(toStart + i + 1);
+        else if (i === 0)
+          return to.slice(toStart + i);
+      } else if (fromLen > length) {
+        if (from.charCodeAt(fromStart + i) === 47)
+          lastCommonSep = i;
+        else if (i === 0)
+          lastCommonSep = 0;
+      }
+      break;
+    }
+    var fromCode = from.charCodeAt(fromStart + i), toCode = to.charCodeAt(toStart + i);
+    if (fromCode !== toCode)
+      break;
+    else if (fromCode === 47)
+      lastCommonSep = i;
+  }
+  var out = "";
+  for (i = fromStart + lastCommonSep + 1;i <= fromEnd; ++i)
+    if (i === fromEnd || from.charCodeAt(i) === 47)
+      if (out.length === 0)
+        out += "..";
+      else
+        out += "/..";
+  if (out.length > 0)
+    return out + to.slice(toStart + lastCommonSep);
+  else {
+    if (toStart += lastCommonSep, to.charCodeAt(toStart) === 47)
+      ++toStart;
+    return to.slice(toStart);
+  }
+}
+function _makeLong(path) {
+  return path;
+}
+function dirname(path) {
+  if (assertPath(path), path.length === 0)
+    return ".";
+  var code = path.charCodeAt(0), hasRoot = code === 47, end = -1, matchedSlash = true;
+  for (var i = path.length - 1;i >= 1; --i)
+    if (code = path.charCodeAt(i), code === 47) {
+      if (!matchedSlash) {
+        end = i;
+        break;
+      }
+    } else
+      matchedSlash = false;
+  if (end === -1)
+    return hasRoot ? "/" : ".";
+  if (hasRoot && end === 1)
+    return "//";
+  return path.slice(0, end);
+}
+function basename(path, ext) {
+  if (ext !== undefined && typeof ext !== "string")
+    throw TypeError('"ext" argument must be a string');
+  assertPath(path);
+  var start = 0, end = -1, matchedSlash = true, i;
+  if (ext !== undefined && ext.length > 0 && ext.length <= path.length) {
+    if (ext.length === path.length && ext === path)
+      return "";
+    var extIdx = ext.length - 1, firstNonSlashEnd = -1;
+    for (i = path.length - 1;i >= 0; --i) {
+      var code = path.charCodeAt(i);
+      if (code === 47) {
+        if (!matchedSlash) {
+          start = i + 1;
+          break;
+        }
+      } else {
+        if (firstNonSlashEnd === -1)
+          matchedSlash = false, firstNonSlashEnd = i + 1;
+        if (extIdx >= 0)
+          if (code === ext.charCodeAt(extIdx)) {
+            if (--extIdx === -1)
+              end = i;
+          } else
+            extIdx = -1, end = firstNonSlashEnd;
+      }
+    }
+    if (start === end)
+      end = firstNonSlashEnd;
+    else if (end === -1)
+      end = path.length;
+    return path.slice(start, end);
+  } else {
+    for (i = path.length - 1;i >= 0; --i)
+      if (path.charCodeAt(i) === 47) {
+        if (!matchedSlash) {
+          start = i + 1;
+          break;
+        }
+      } else if (end === -1)
+        matchedSlash = false, end = i + 1;
+    if (end === -1)
+      return "";
+    return path.slice(start, end);
+  }
+}
+function extname(path) {
+  assertPath(path);
+  var startDot = -1, startPart = 0, end = -1, matchedSlash = true, preDotState = 0;
+  for (var i = path.length - 1;i >= 0; --i) {
+    var code = path.charCodeAt(i);
+    if (code === 47) {
+      if (!matchedSlash) {
+        startPart = i + 1;
+        break;
+      }
+      continue;
+    }
+    if (end === -1)
+      matchedSlash = false, end = i + 1;
+    if (code === 46) {
+      if (startDot === -1)
+        startDot = i;
+      else if (preDotState !== 1)
+        preDotState = 1;
+    } else if (startDot !== -1)
+      preDotState = -1;
+  }
+  if (startDot === -1 || end === -1 || preDotState === 0 || preDotState === 1 && startDot === end - 1 && startDot === startPart + 1)
+    return "";
+  return path.slice(startDot, end);
+}
+function format(pathObject) {
+  if (pathObject === null || typeof pathObject !== "object")
+    throw TypeError('The "pathObject" argument must be of type Object. Received type ' + typeof pathObject);
+  return _format("/", pathObject);
+}
+function parse(path) {
+  assertPath(path);
+  var ret = { root: "", dir: "", base: "", ext: "", name: "" };
+  if (path.length === 0)
+    return ret;
+  var code = path.charCodeAt(0), isAbsolute2 = code === 47, start;
+  if (isAbsolute2)
+    ret.root = "/", start = 1;
+  else
+    start = 0;
+  var startDot = -1, startPart = 0, end = -1, matchedSlash = true, i = path.length - 1, preDotState = 0;
+  for (;i >= start; --i) {
+    if (code = path.charCodeAt(i), code === 47) {
+      if (!matchedSlash) {
+        startPart = i + 1;
+        break;
+      }
+      continue;
+    }
+    if (end === -1)
+      matchedSlash = false, end = i + 1;
+    if (code === 46) {
+      if (startDot === -1)
+        startDot = i;
+      else if (preDotState !== 1)
+        preDotState = 1;
+    } else if (startDot !== -1)
+      preDotState = -1;
+  }
+  if (startDot === -1 || end === -1 || preDotState === 0 || preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
+    if (end !== -1)
+      if (startPart === 0 && isAbsolute2)
+        ret.base = ret.name = path.slice(1, end);
+      else
+        ret.base = ret.name = path.slice(startPart, end);
+  } else {
+    if (startPart === 0 && isAbsolute2)
+      ret.name = path.slice(1, startDot), ret.base = path.slice(1, end);
+    else
+      ret.name = path.slice(startPart, startDot), ret.base = path.slice(startPart, end);
+    ret.ext = path.slice(startDot, end);
+  }
+  if (startPart > 0)
+    ret.dir = path.slice(0, startPart - 1);
+  else if (isAbsolute2)
+    ret.dir = "/";
+  return ret;
+}
+var sep = "/", delimiter = ":", posix, path_default;
+var init_path = __esm(() => {
+  posix = ((p) => (p.posix = p, p))({ resolve, normalize, isAbsolute, join, relative, _makeLong, dirname, basename, extname, format, parse, sep, delimiter, win32: null, posix: null });
+  path_default = posix;
+});
+
+// src/shared/lib/sweep-sealed.ts
+var exports_sweep_sealed = {};
+__export(exports_sweep_sealed, {
+  sweepSealed: () => sweepSealed
+});
+import { Automerge } from "@automerge/automerge-repo/slim";
+function concat(parts) {
+  let total = 0;
+  for (const part of parts)
+    total += part.byteLength;
+  const out = new Uint8Array(total);
+  let offset = 0;
+  for (const part of parts) {
+    out.set(part, offset);
+    offset += part.byteLength;
+  }
+  return out;
+}
+function materialise(chunks) {
+  const content = chunks.filter((chunk) => chunk.key[1] !== "sync-state" && chunk.data !== undefined).sort((a, b) => (a.key[1] === "snapshot" ? 0 : 1) - (b.key[1] === "snapshot" ? 0 : 1));
+  if (content.length === 0)
+    return;
+  try {
+    return Automerge.loadIncremental(Automerge.init(), concat(content.map((chunk) => chunk.data)));
+  } catch {
+    return;
+  }
+}
+async function collectChunksByDocument(storage, documentIds) {
+  const chunks = [];
+  if (documentIds === undefined) {
+    chunks.push(...await storage.loadRange([]));
+  } else {
+    for (const documentId of documentIds) {
+      chunks.push(...await storage.loadRange([documentId]));
+    }
+  }
+  const byDocument = new Map;
+  for (const chunk of chunks) {
+    const documentId = chunk.key[0];
+    if (documentId === undefined)
+      continue;
+    const existing = byDocument.get(documentId);
+    if (existing)
+      existing.push(chunk);
+    else
+      byDocument.set(documentId, [chunk]);
+  }
+  return byDocument;
+}
+function classifyDocument(documentId, chunks, context) {
+  const doc = materialise(chunks);
+  if (doc === undefined)
+    return { action: "ignore" };
+  const sealedAt = context.isSealed(doc);
+  if (sealedAt === undefined)
+    return { action: "ignore" };
+  const id = documentId;
+  if (context.repo.handles[id] !== undefined) {
+    return { action: "keep", entry: { documentId: id, reason: "open-handle" } };
+  }
+  if (context.at - sealedAt < context.olderThan) {
+    return { action: "keep", entry: { documentId: id, reason: "too-recent" } };
+  }
+  const byteSize = chunks.reduce((sum, chunk) => sum + (chunk.data?.byteLength ?? 0), 0);
+  return { action: "sweep", entry: { documentId: id, sealedAt, byteSize } };
+}
+async function sweepSealed(options) {
+  const { repo, storage, isSealed, olderThan } = options;
+  const dryRun = options.dryRun ?? false;
+  const now = options.now ?? Date.now;
+  const byDocument = await collectChunksByDocument(storage, options.documentIds);
+  const swept = [];
+  const kept = [];
+  const at = now();
+  for (const [documentId, chunks] of byDocument) {
+    const verdict = classifyDocument(documentId, chunks, { repo, isSealed, olderThan, at });
+    if (verdict.action === "keep") {
+      kept.push(verdict.entry);
+    } else if (verdict.action === "sweep") {
+      swept.push(verdict.entry);
+      if (!dryRun)
+        await storage.removeRange([documentId]);
+    }
+  }
+  return { swept, kept, dryRun };
+}
+var init_sweep_sealed = () => {};
+
 // src/elysia/peer-repo-plugin.ts
 import { Elysia } from "elysia";
 
 // src/shared/lib/peer-repo-server.ts
+async function listNodeFSDocumentIds(baseDirectory) {
+  const [{ readdir }, { join: join2 }] = await Promise.all([
+    import("node:fs/promises"),
+    Promise.resolve().then(() => (init_path(), exports_path))
+  ]);
+  let shards;
+  try {
+    shards = await readdir(baseDirectory);
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return [];
+    throw error;
+  }
+  const documentIds = [];
+  for (const shard of shards) {
+    const entries = await readdir(join2(baseDirectory, shard), {
+      withFileTypes: true
+    }).catch(() => []);
+    for (const entry of entries) {
+      if (entry.isDirectory())
+        documentIds.push(shard + entry.name);
+    }
+  }
+  return documentIds;
+}
 async function createPeerRepoServer(options) {
   const [{ Repo }, { WebSocketServerAdapter }, { NodeFSStorageAdapter }, ws] = await Promise.all([
     import("@automerge/automerge-repo/slim"),
@@ -80,15 +534,16 @@ async function createPeerRepoServer(options) {
     import("@automerge/automerge-repo-storage-nodefs"),
     import("ws")
   ]);
-  const wss = await (options.webSocketServer ? Promise.resolve(options.webSocketServer) : new Promise((resolve, reject) => {
+  const wss = await (options.webSocketServer ? Promise.resolve(options.webSocketServer) : new Promise((resolve2, reject) => {
     const created = new ws.WebSocketServer({
       port: options.port,
       ...options.host !== undefined && { host: options.host }
-    }, () => resolve(created));
+    }, () => resolve2(created));
     created.once("error", reject);
   }));
   const adapter = new WebSocketServerAdapter(wss);
-  const storage = new NodeFSStorageAdapter(options.storagePath);
+  const storagePath = options.storagePath ?? "automerge-repo-data";
+  const storage = new NodeFSStorageAdapter(storagePath);
   const repo = new Repo({
     network: [adapter],
     storage
@@ -99,6 +554,11 @@ async function createPeerRepoServer(options) {
     webSocketServer: wss,
     adapter,
     storage,
+    sweepSealed: async (sweepOptions) => {
+      const documentIds = await listNodeFSDocumentIds(storagePath);
+      const { sweepSealed: sweepSealed2 } = await Promise.resolve().then(() => (init_sweep_sealed(), exports_sweep_sealed));
+      return sweepSealed2({ repo, storage, documentIds, ...sweepOptions });
+    },
     close: async () => {
       for (const client of wss.clients) {
         try {
@@ -436,4 +896,4 @@ export {
   peerRepo
 };
 
-//# debugId=EDAD4E57925183E464756E2164756E21
+//# debugId=77B9B7B157F0E2A364756E2164756E21