@kehto/services 0.5.0 → 0.6.0

package/dist/index.js

@@ -1854,6 +1854,430 @@ function createResourceService(options) {
   return handler;
 }
 
+// src/outbox-service.ts
+var OUTBOX_SERVICE_VERSION = "1.0.0";
+var OUTBOX_DESCRIPTOR = {
+  name: "outbox",
+  version: OUTBOX_SERVICE_VERSION,
+  description: "NAP-OUTBOX outbox-aware relay routing \u2014 query/subscribe/publish/resolveRelays"
+};
+function normalizeFilters(raw) {
+  if (Array.isArray(raw)) {
+    const filters = raw.filter((f) => typeof f === "object" && f !== null);
+    return filters.length > 0 ? filters : null;
+  }
+  if (typeof raw === "object" && raw !== null) return [raw];
+  return null;
+}
+function createOutboxService(options) {
+  if (!options || typeof options.router !== "object" || options.router === null) {
+    throw new Error("createOutboxService: options.router is required");
+  }
+  const { router } = options;
+  const subscriptions = /* @__PURE__ */ new Map();
+  function handleQuery(msg, send) {
+    const m = msg;
+    const id = m.id ?? "";
+    const filters = normalizeFilters(m.filters);
+    if (!filters) {
+      send({ type: "outbox.query.result", id, events: [], relays: {}, error: "invalid filter" });
+      return;
+    }
+    void router.query(filters, m.options).then(
+      (result) => send({
+        type: "outbox.query.result",
+        id,
+        events: result.events,
+        relays: result.relays,
+        ...result.incomplete === void 0 ? {} : { incomplete: result.incomplete },
+        ...result.error === void 0 ? {} : { error: result.error }
+      })
+    ).catch(
+      (err) => send({ type: "outbox.query.result", id, events: [], relays: {}, error: toErrorMessage(err) })
+    );
+  }
+  function handleSubscribe(windowId, msg, send) {
+    const m = msg;
+    const subId = m.subId;
+    if (typeof subId !== "string" || subId.length === 0) return;
+    const subKey = `${windowId}:${subId}`;
+    subscriptions.get(subKey)?.close();
+    subscriptions.delete(subKey);
+    const filters = normalizeFilters(m.filters);
+    if (!filters) {
+      send({ type: "outbox.closed", subId, reason: "invalid filter" });
+      return;
+    }
+    const sink = {
+      event: (event, relay) => send({ type: "outbox.event", subId, event, ...relay === void 0 ? {} : { relay } }),
+      eose: () => send({ type: "outbox.eose", subId }),
+      closed: (reason) => {
+        subscriptions.delete(subKey);
+        send({ type: "outbox.closed", subId, ...reason === void 0 ? {} : { reason } });
+      }
+    };
+    subscriptions.set(subKey, router.subscribe(filters, m.options, sink));
+  }
+  function handleClose(windowId, msg, send) {
+    const m = msg;
+    const subId = m.subId;
+    if (typeof subId !== "string") return;
+    const subKey = `${windowId}:${subId}`;
+    subscriptions.get(subKey)?.close();
+    subscriptions.delete(subKey);
+    send({ type: "outbox.closed", subId });
+  }
+  function handlePublish(msg, send) {
+    const m = msg;
+    const id = m.id ?? "";
+    if (!m.event || typeof m.event !== "object") {
+      send({ type: "outbox.publish.result", id, ok: false, error: "invalid filter" });
+      return;
+    }
+    void router.publish(m.event, m.options).then(
+      (result) => send({
+        type: "outbox.publish.result",
+        id,
+        ok: result.ok,
+        ...result.event === void 0 ? {} : { event: result.event },
+        ...result.eventId === void 0 ? {} : { eventId: result.eventId },
+        ...result.relays === void 0 ? {} : { relays: result.relays },
+        ...result.error === void 0 ? {} : { error: result.error }
+      })
+    ).catch(
+      (err) => send({ type: "outbox.publish.result", id, ok: false, error: toErrorMessage(err) })
+    );
+  }
+  function handleResolveRelays(msg, send) {
+    const m = msg;
+    const id = m.id ?? "";
+    if (!m.target || typeof m.target !== "object") {
+      send({ type: "outbox.resolveRelays.result", id, error: "invalid filter" });
+      return;
+    }
+    void router.resolveRelays(m.target).then((plan) => send({ type: "outbox.resolveRelays.result", id, plan })).catch(
+      (err) => send({ type: "outbox.resolveRelays.result", id, error: toErrorMessage(err) })
+    );
+  }
+  return {
+    descriptor: OUTBOX_DESCRIPTOR,
+    handleMessage(windowId, message, send) {
+      switch (message.type) {
+        case "outbox.query":
+          handleQuery(message, send);
+          return;
+        case "outbox.subscribe":
+          handleSubscribe(windowId, message, send);
+          return;
+        case "outbox.close":
+          handleClose(windowId, message, send);
+          return;
+        case "outbox.publish":
+          handlePublish(message, send);
+          return;
+        case "outbox.resolveRelays":
+          handleResolveRelays(message, send);
+          return;
+        default:
+          return;
+      }
+    },
+    onWindowDestroyed(windowId) {
+      const prefix = `${windowId}:`;
+      for (const [key, sub] of subscriptions) {
+        if (key.startsWith(prefix)) {
+          sub.close();
+          subscriptions.delete(key);
+        }
+      }
+    }
+  };
+}
+function toErrorMessage(err) {
+  if (err instanceof Error) return err.message;
+  if (typeof err === "string") return err;
+  return "outbox request failed";
+}
+
+// src/relay-pool-outbox-router.ts
+var DEFAULT_QUERY_TIMEOUT_MS = 4e3;
+function defaultRelayAllowed(url) {
+  return typeof url === "string" && (url.startsWith("wss://") || url.startsWith("ws://"));
+}
+function deriveAuthors(filters, optionAuthors) {
+  const authors = /* @__PURE__ */ new Set();
+  for (const filter of filters) {
+    for (const author of filter.authors ?? []) authors.add(author);
+  }
+  for (const author of optionAuthors ?? []) authors.add(author);
+  return [...authors];
+}
+function wantsWriteRelays(direction, strategy) {
+  if (strategy === "outbox") return true;
+  if (strategy === "inbox") return false;
+  return direction === "read";
+}
+function allowed(ctx, urls) {
+  const out = /* @__PURE__ */ new Set();
+  for (const url of urls) {
+    if (ctx.isRelayAllowed(url)) out.add(url);
+  }
+  return [...out];
+}
+async function resolvePlan(ctx, pubkeys, direction, strategy, relayHints) {
+  const useWrite = wantsWriteRelays(direction, strategy);
+  const collected = /* @__PURE__ */ new Set();
+  const missingAuthors = [];
+  let sawNip65 = false;
+  if (pubkeys.length > 0) {
+    const lists = await ctx.loadRelayLists(pubkeys);
+    for (const pubkey of pubkeys) {
+      const entry = lists.get(pubkey);
+      const relays2 = entry ? useWrite ? entry.write : entry.read : void 0;
+      if (relays2 && relays2.length > 0) {
+        sawNip65 = true;
+        for (const url of relays2) collected.add(url);
+      } else {
+        missingAuthors.push(pubkey);
+      }
+    }
+  }
+  for (const url of relayHints ?? []) collected.add(url);
+  let relays = allowed(ctx, collected);
+  let source;
+  if (relays.length === 0) {
+    relays = allowed(ctx, ctx.fallbackRelays);
+    source = "fallback";
+  } else {
+    source = sawNip65 ? "nip65" : "policy";
+  }
+  const plan = { relays, source };
+  if (missingAuthors.length > 0) plan.missingAuthors = missingAuthors;
+  return plan;
+}
+function recordRelay(collector, id, relayUrl) {
+  let set = collector.relayMap.get(id);
+  if (!set) {
+    set = /* @__PURE__ */ new Set();
+    collector.relayMap.set(id, set);
+  }
+  set.add(relayUrl);
+}
+function admitEvent(ctx, collector, event) {
+  if (collector.seen.has(event.id)) return;
+  collector.verifications.push(
+    ctx.verify(event).then((ok) => {
+      if (ok && !collector.seen.has(event.id)) collector.seen.set(event.id, event);
+      else if (!ok) collector.relayMap.delete(event.id);
+    })
+  );
+}
+function buildCollectResult(collector, timedOut) {
+  const events = [...collector.seen.values()];
+  const relayObj = {};
+  for (const event of events) relayObj[event.id] = [...collector.relayMap.get(event.id) ?? []];
+  return { events, relayMap: relayObj, incomplete: timedOut };
+}
+function collectFromRelays(ctx, filters, relayUrls, timeoutMs) {
+  return new Promise((resolve) => {
+    const collector = { seen: /* @__PURE__ */ new Map(), relayMap: /* @__PURE__ */ new Map(), verifications: [] };
+    const handles = [];
+    let eoseCount = 0;
+    let finished = false;
+    let timedOut = false;
+    function finalize() {
+      if (finished) return;
+      finished = true;
+      clearTimeout(timer);
+      for (const handle of handles) {
+        try {
+          handle.unsubscribe();
+        } catch {
+        }
+      }
+      void Promise.all(collector.verifications).then(() => resolve(buildCollectResult(collector, timedOut)));
+    }
+    const timer = setTimeout(() => {
+      timedOut = true;
+      finalize();
+    }, timeoutMs);
+    for (const relayUrl of relayUrls) {
+      handles.push(relayPoolSubscribe(ctx, filters, relayUrl, (item) => {
+        if (finished) return;
+        if (item === "EOSE") {
+          eoseCount += 1;
+          if (eoseCount >= relayUrls.length) finalize();
+          return;
+        }
+        recordRelay(collector, item.id, relayUrl);
+        admitEvent(ctx, collector, item);
+      }));
+    }
+    if (relayUrls.length === 0) finalize();
+  });
+}
+function relayPoolSubscribe(ctx, filters, relayUrl, cb) {
+  return ctx.relayPool.subscribe(filters, [relayUrl], cb);
+}
+async function queryImpl(ctx, filters, options) {
+  if (!ctx.relayPool.isAvailable()) {
+    return { events: [], relays: {}, incomplete: true, error: "relay list unavailable" };
+  }
+  const strategy = options?.strategy ?? "auto";
+  const authors = deriveAuthors(filters, options?.authors);
+  const plan = await resolvePlan(ctx, authors, "read", strategy, options?.relays);
+  if (plan.relays.length === 0) {
+    return { events: [], relays: {}, incomplete: true, error: "relay list unavailable" };
+  }
+  const timeoutMs = options?.timeoutMs ?? ctx.defaultTimeoutMs;
+  const collected = await collectFromRelays(ctx, filters, plan.relays, timeoutMs);
+  const incomplete = collected.incomplete || (plan.missingAuthors?.length ?? 0) > 0;
+  let events = collected.events;
+  if (options?.limit !== void 0 && events.length > options.limit) {
+    events = [...events].sort((a, b) => b.created_at - a.created_at).slice(0, options.limit);
+  }
+  const result = { events, relays: collected.relayMap };
+  if (incomplete) result.incomplete = true;
+  return result;
+}
+function closeLiveSub(sub) {
+  for (const handle of sub.handles) {
+    try {
+      handle.unsubscribe();
+    } catch {
+    }
+  }
+  sub.handles.length = 0;
+}
+function attachLiveRelay(ctx, sub, filters, relayUrl, live, sink) {
+  sub.handles.push(relayPoolSubscribe(ctx, filters, relayUrl, (item) => {
+    if (sub.closed) return;
+    if (item === "EOSE") {
+      sub.eoseCount += 1;
+      if (!sub.eoseSent && sub.eoseCount >= sub.relayCount) {
+        sub.eoseSent = true;
+        sink.eose();
+        if (!live) {
+          sub.closed = true;
+          closeLiveSub(sub);
+          sink.closed();
+        }
+      }
+      return;
+    }
+    if (sub.seen.has(item.id)) return;
+    void ctx.verify(item).then((ok) => {
+      if (!ok || sub.closed || sub.seen.has(item.id)) return;
+      sub.seen.add(item.id);
+      sink.event(item, relayUrl);
+    });
+  }));
+}
+function startSubscription(ctx, filters, options, sink) {
+  const live = options?.live ?? true;
+  const strategy = options?.strategy ?? "auto";
+  const authors = deriveAuthors(filters, options?.authors);
+  const sub = { handles: [], seen: /* @__PURE__ */ new Set(), closed: false, eoseCount: 0, relayCount: 0, eoseSent: false };
+  void resolvePlan(ctx, authors, "read", strategy, options?.relays).then((plan) => {
+    if (sub.closed) return;
+    if (plan.relays.length === 0) {
+      sink.closed("relay list unavailable");
+      return;
+    }
+    sub.relayCount = plan.relays.length;
+    for (const relayUrl of plan.relays) attachLiveRelay(ctx, sub, filters, relayUrl, live, sink);
+  }).catch((err) => {
+    if (!sub.closed) sink.closed(err instanceof Error ? err.message : "subscribe failed");
+  });
+  return {
+    close() {
+      if (sub.closed) return;
+      sub.closed = true;
+      closeLiveSub(sub);
+    }
+  };
+}
+async function resolvePublishTargets(ctx, signed, options) {
+  const strategy = options?.strategy ?? "auto";
+  const targets = /* @__PURE__ */ new Set();
+  const authorPlan = await resolvePlan(ctx, [signed.pubkey], "read", strategy === "inbox" ? "auto" : "outbox");
+  for (const url of authorPlan.relays) targets.add(url);
+  if (options?.targetAuthors && options.targetAuthors.length > 0) {
+    const inboxPlan = await resolvePlan(ctx, options.targetAuthors, "write", "inbox");
+    for (const url of inboxPlan.relays) targets.add(url);
+  }
+  for (const url of options?.relays ?? []) targets.add(url);
+  return allowed(ctx, targets);
+}
+async function publishImpl(ctx, template, options) {
+  if (!ctx.signEvent) return { ok: false, error: "publish denied" };
+  if (!ctx.relayPool.isAvailable()) return { ok: false, error: "relay list unavailable" };
+  let signed;
+  try {
+    signed = await ctx.signEvent(template);
+  } catch (err) {
+    return { ok: false, error: err instanceof Error ? err.message : "sign failed" };
+  }
+  const relayUrls = await resolvePublishTargets(ctx, signed, options);
+  if (relayUrls.length === 0) return { ok: false, event: signed, eventId: signed.id, error: "relay list unavailable" };
+  let relays;
+  try {
+    relays = normalizePublishResult(await ctx.relayPool.publish(signed, relayUrls), relayUrls);
+  } catch (err) {
+    return { ok: false, event: signed, eventId: signed.id, error: err instanceof Error ? err.message : "publish failed" };
+  }
+  const ok = Object.values(relays).some(Boolean);
+  const result = { ok, event: signed, eventId: signed.id, relays };
+  if (!ok) result.error = "publish denied";
+  return result;
+}
+function createRelayPoolOutboxRouter(options) {
+  if (!options || typeof options.relayPool !== "object" || options.relayPool === null) {
+    throw new Error("createRelayPoolOutboxRouter: options.relayPool is required");
+  }
+  if (typeof options.loadRelayLists !== "function") {
+    throw new Error("createRelayPoolOutboxRouter: options.loadRelayLists is required");
+  }
+  if (!Array.isArray(options.fallbackRelays)) {
+    throw new Error("createRelayPoolOutboxRouter: options.fallbackRelays is required");
+  }
+  const verifyEvent = options.verifyEvent;
+  const ctx = {
+    relayPool: options.relayPool,
+    loadRelayLists: options.loadRelayLists,
+    fallbackRelays: options.fallbackRelays,
+    signEvent: options.signEvent,
+    isRelayAllowed: options.isRelayAllowed ?? defaultRelayAllowed,
+    defaultTimeoutMs: options.defaultTimeoutMs ?? DEFAULT_QUERY_TIMEOUT_MS,
+    async verify(event) {
+      if (!verifyEvent) return true;
+      try {
+        return await verifyEvent(event);
+      } catch {
+        return false;
+      }
+    }
+  };
+  return {
+    query: (filters, queryOptions) => queryImpl(ctx, filters, queryOptions),
+    subscribe: (filters, subscribeOptions, sink) => startSubscription(ctx, filters, subscribeOptions, sink),
+    publish: (template, publishOptions) => publishImpl(ctx, template, publishOptions),
+    resolveRelays: (target) => {
+      const pubkeys = target.authors ?? (target.pubkey ? [target.pubkey] : []);
+      return resolvePlan(ctx, pubkeys, target.direction ?? "read", target.strategy ?? "auto");
+    }
+  };
+}
+function normalizePublishResult(res, relayUrls) {
+  const out = {};
+  if (res && typeof res === "object") {
+    for (const url of relayUrls) out[url] = res[url] ?? false;
+  } else {
+    for (const url of relayUrls) out[url] = true;
+  }
+  return out;
+}
+
 // src/cvm-service.ts
 var CVM_SERVICE_VERSION = "1.0.0";
 var CVM_DESCRIPTOR = {
@@ -1896,7 +2320,7 @@ function createCvmService(options) {
     const m = msg;
     const id = m.id ?? "";
     void transport.discover(m.query).then((servers) => send({ type: "cvm.discover.result", id, servers })).catch(
-      (err) => send({ type: "cvm.discover.result", id, servers: [], error: toErrorMessage(err) })
+      (err) => send({ type: "cvm.discover.result", id, servers: [], error: toErrorMessage2(err) })
     );
   }
   function handleRequest(windowId, msg, send) {
@@ -1912,7 +2336,7 @@ function createCvmService(options) {
     }
     openSession(windowId, m.server, send);
     void transport.request(m.server, m.message, m.options).then((message) => send({ type: "cvm.request.result", id, message })).catch(
-      (err) => send({ type: "cvm.request.result", id, error: toErrorMessage(err) })
+      (err) => send({ type: "cvm.request.result", id, error: toErrorMessage2(err) })
     );
   }
   function handleClose(windowId, msg, send) {
@@ -1923,7 +2347,7 @@ function createCvmService(options) {
       return;
     }
     closeSession(windowId, m.server.pubkey);
-    void transport.close(m.server).then(() => send({ type: "cvm.close.result", id })).catch((err) => send({ type: "cvm.close.result", id, error: toErrorMessage(err) }));
+    void transport.close(m.server).then(() => send({ type: "cvm.close.result", id })).catch((err) => send({ type: "cvm.close.result", id, error: toErrorMessage2(err) }));
   }
   return {
     descriptor: CVM_DESCRIPTOR,
@@ -1954,7 +2378,7 @@ function createCvmService(options) {
     }
   };
 }
-function toErrorMessage(err) {
+function toErrorMessage2(err) {
   if (err instanceof Error) return err.message;
   if (typeof err === "string") return err;
   return "cvm request failed";
@@ -1971,6 +2395,8 @@ export {
   createMediaService,
   createNotificationService,
   createNotifyService,
+  createOutboxService,
+  createRelayPoolOutboxRouter,
   createRelayPoolService,
   createResourceService,
   createThemeService