trellis 3.1.35 → 3.2.0

package/dist/{index-wncptktd.js → chunk-276LKLZR.js}

@@ -1,39 +1,46 @@
-// @bun
-import {
-  readConfig
-} from "./index-xzym9w0m.js";
 import {
   TenantPool
-} from "./index-7pjz3tsy.js";
+} from "./chunk-AHMDVHBL.js";
 import {
-  __require
-} from "./index-a76rekgs.js";
+  readConfig
+} from "./chunk-JA7AIHRK.js";
 
 // src/client/sdk.ts
 function isRemote(opts) {
   return "url" in opts;
 }
-
-class TrellisDb {
+var TrellisDb = class _TrellisDb {
   opts;
   _pool = null;
   _ws = null;
-  _subCallbacks = new Map;
+  _subCallbacks = /* @__PURE__ */ new Map();
   constructor(opts) {
     this.opts = opts;
   }
+  /**
+   * Create a TrellisDb instance from `.trellis-db.json` in the given directory.
+   */
   static fromConfig(dir = ".") {
     const config = readConfig(dir);
     if (!config)
-      throw new Error("No .trellis-db.json found. Run `trellis db init` first.");
+      throw new Error(
+        "No .trellis-db.json found. Run `trellis db init` first."
+      );
     if (config.mode === "remote" && config.url) {
-      return new TrellisDb({ url: config.url, apiKey: config.apiKey });
+      return new _TrellisDb({ url: config.url, apiKey: config.apiKey });
     }
     if (config.dbPath) {
-      return new TrellisDb({ path: config.dbPath });
+      return new _TrellisDb({ path: config.dbPath });
     }
     throw new Error("Invalid .trellis-db.json: missing url or dbPath.");
   }
+  // -------------------------------------------------------------------------
+  // CRUD
+  // -------------------------------------------------------------------------
+  /**
+   * Create a new entity.
+   * Returns the generated entity ID.
+   */
   async create(type, attributes = {}, links) {
     if (isRemote(this.opts)) {
       const res = await this._fetch("POST", "/entities", {
@@ -50,13 +57,19 @@ class TrellisDb {
     await kernel.createEntity(entityId, type, attributes, links);
     return entityId;
   }
+  /**
+   * Read an entity by ID.
+   * Returns null if not found.
+   */
   async read(id) {
     if (isRemote(this.opts)) {
       try {
-        return await this._fetch("GET", `/entities/${encodeURIComponent(id)}`);
+        return await this._fetch(
+          "GET",
+          `/entities/${encodeURIComponent(id)}`
+        );
       } catch (err) {
-        if (err?.status === 404)
-          return null;
+        if (err?.status === 404) return null;
         throw err;
       }
     }
@@ -64,13 +77,19 @@ class TrellisDb {
     const tenantId = this.opts.tenantId ?? null;
     const kernel = pool.get(tenantId);
     const entity = kernel.getEntity(id);
-    if (!entity)
-      return null;
+    if (!entity) return null;
     return entityToPlain(entity);
   }
+  /**
+   * Update an entity's attributes (partial update).
+   */
   async update(id, attributes) {
     if (isRemote(this.opts)) {
-      await this._fetch("PUT", `/entities/${encodeURIComponent(id)}`, attributes);
+      await this._fetch(
+        "PUT",
+        `/entities/${encodeURIComponent(id)}`,
+        attributes
+      );
       return;
     }
     const pool = this._getPool();
@@ -78,6 +97,9 @@ class TrellisDb {
     const kernel = pool.get(tenantId);
     await kernel.updateEntity(id, attributes);
   }
+  /**
+   * Delete an entity by ID.
+   */
   async delete(id) {
     if (isRemote(this.opts)) {
       await this._fetch("DELETE", `/entities/${encodeURIComponent(id)}`);
@@ -88,15 +110,15 @@ class TrellisDb {
     const kernel = pool.get(tenantId);
     await kernel.deleteEntity(id);
   }
+  /**
+   * List entities of a given type.
+   */
   async list(type, opts = {}) {
     if (isRemote(this.opts)) {
-      const params = new URLSearchParams;
-      if (type)
-        params.set("type", type);
-      if (opts.limit)
-        params.set("limit", String(opts.limit));
-      if (opts.offset)
-        params.set("offset", String(opts.offset));
+      const params = new URLSearchParams();
+      if (type) params.set("type", type);
+      if (opts.limit) params.set("limit", String(opts.limit));
+      if (opts.offset) params.set("offset", String(opts.offset));
       const qs = params.toString() ? `?${params}` : "";
       return await this._fetch("GET", `/entities${qs}`);
     }
@@ -114,14 +136,20 @@ class TrellisDb {
       offset
     };
   }
+  // -------------------------------------------------------------------------
+  // Query
+  // -------------------------------------------------------------------------
+  /**
+   * Run an EQL-S query string.
+   */
   async query(eql) {
     if (isRemote(this.opts)) {
       return await this._fetch("POST", "/query", {
         query: eql
       });
     }
-    const { parseSimple } = await import("./index-2r4jxwnb.js");
-    const { QueryEngine } = await import("./engine-y0724kjq.js");
+    const { parseSimple } = await import("./query-TJHEVSKL.js");
+    const { QueryEngine } = await import("./engine-NSR6BIF7.js");
     const pool = this._getPool();
     const tenantId = this.opts.tenantId ?? null;
     const kernel = pool.get(tenantId);
@@ -129,9 +157,19 @@ class TrellisDb {
     const engine = new QueryEngine(kernel.getStore());
     return engine.execute(parsed);
   }
+  // -------------------------------------------------------------------------
+  // File upload
+  // -------------------------------------------------------------------------
+  /**
+   * Upload a file to the blob store.
+   * Returns a content-addressed hash.
+   */
   async upload(data, contentType = "application/octet-stream") {
     const raw = data instanceof ArrayBuffer ? new Uint8Array(data) : data;
-    const cleanBuf = raw.buffer.slice(raw.byteOffset, raw.byteOffset + raw.byteLength);
+    const cleanBuf = raw.buffer.slice(
+      raw.byteOffset,
+      raw.byteOffset + raw.byteLength
+    );
     const buffer = new Uint8Array(cleanBuf);
     if (isRemote(this.opts)) {
       const res = await fetch(`${this.opts.url}/upload`, {
@@ -142,8 +180,7 @@ class TrellisDb {
         },
         body: cleanBuf
       });
-      if (!res.ok)
-        throw new FetchError(res.status, await res.text());
+      if (!res.ok) throw new FetchError(res.status, await res.text());
       return await res.json();
     }
     const hashBuf = await crypto.subtle.digest("SHA-256", buffer);
@@ -152,19 +189,22 @@ class TrellisDb {
     const tenantId = this.opts.tenantId ?? null;
     const kernel = pool.get(tenantId);
     const backend = kernel.getBackend();
-    if (!backend.hasBlob(hash))
-      backend.putBlob(hash, buffer);
+    if (!backend.hasBlob(hash)) backend.putBlob(hash, buffer);
     return { hash, size: buffer.length, contentType };
   }
+  /**
+   * Download a file by its blob hash.
+   */
   async getFile(hash) {
     if (isRemote(this.opts)) {
-      const res = await fetch(`${this.opts.url}/files/${encodeURIComponent(hash)}`, {
-        headers: this.opts.apiKey ? { Authorization: `Bearer ${this.opts.apiKey}` } : {}
-      });
-      if (res.status === 404)
-        return null;
-      if (!res.ok)
-        throw new FetchError(res.status, await res.text());
+      const res = await fetch(
+        `${this.opts.url}/files/${encodeURIComponent(hash)}`,
+        {
+          headers: this.opts.apiKey ? { Authorization: `Bearer ${this.opts.apiKey}` } : {}
+        }
+      );
+      if (res.status === 404) return null;
+      if (!res.ok) throw new FetchError(res.status, await res.text());
       return new Uint8Array(await res.arrayBuffer());
     }
     const pool = this._getPool();
@@ -173,6 +213,9 @@ class TrellisDb {
     const backend = kernel.getBackend();
     return backend.getBlob(hash) ?? null;
   }
+  // -------------------------------------------------------------------------
+  // Auth helpers
+  // -------------------------------------------------------------------------
   async register(email, password, name) {
     if (!isRemote(this.opts))
       throw new Error("register() requires remote mode");
@@ -183,21 +226,33 @@ class TrellisDb {
     });
   }
   async login(email, password) {
-    if (!isRemote(this.opts))
-      throw new Error("login() requires remote mode");
+    if (!isRemote(this.opts)) throw new Error("login() requires remote mode");
     return await this._fetch("POST", "/auth/login", {
       email,
       password
     });
   }
+  /**
+   * Set the active API key / JWT token for subsequent requests.
+   */
   setToken(token) {
-    if (!isRemote(this.opts))
-      return;
+    if (!isRemote(this.opts)) return;
     this.opts.apiKey = token;
   }
+  // -------------------------------------------------------------------------
+  // Realtime
+  // -------------------------------------------------------------------------
+  /**
+   * Subscribe to a live EQL-S query.
+   * Callback is fired immediately with the initial result, then on every update.
+   *
+   * Requires remote mode (WebSocket to server).
+   */
   subscribe(eql, callback) {
     if (!isRemote(this.opts)) {
-      throw new Error("subscribe() requires remote mode (connect to a running server)");
+      throw new Error(
+        "subscribe() requires remote mode (connect to a running server)"
+      );
     }
     const subId = `sub_${crypto.randomUUID()}`;
     this._subCallbacks.set(subId, callback);
@@ -211,15 +266,24 @@ class TrellisDb {
       }
     };
   }
+  /**
+   * Close the WebSocket connection.
+   */
   disconnect() {
     this._ws?.close();
     this._ws = null;
   }
+  /**
+   * Close local kernel pool connections.
+   */
   close() {
     this._pool?.closeAll();
     this._pool = null;
     this.disconnect();
   }
+  // -------------------------------------------------------------------------
+  // Private
+  // -------------------------------------------------------------------------
   _getPool() {
     if (!this._pool) {
       const path = this.opts.path;
@@ -236,16 +300,19 @@ class TrellisDb {
         "Content-Type": "application/json",
         ...opts.apiKey ? { Authorization: `Bearer ${opts.apiKey}` } : {}
       },
-      body: body !== undefined ? JSON.stringify(body) : undefined
+      body: body !== void 0 ? JSON.stringify(body) : void 0
     });
     const data = await res.json();
     if (!res.ok)
-      throw new FetchError(res.status, data?.message ?? res.statusText, data);
+      throw new FetchError(
+        res.status,
+        data?.message ?? res.statusText,
+        data
+      );
     return data;
   }
   async _ensureWs() {
-    if (this._ws && this._ws.readyState === WebSocket.OPEN)
-      return this._ws;
+    if (this._ws && this._ws.readyState === WebSocket.OPEN) return this._ws;
     const opts = this.opts;
     const wsUrl = opts.url.replace(/^https?/, opts.url.startsWith("https") ? "wss" : "ws") + "/realtime";
     return new Promise((resolve, reject) => {
@@ -261,32 +328,32 @@ class TrellisDb {
           if (msg.type === "data" && this._subCallbacks.has(msg.id)) {
             this._subCallbacks.get(msg.id)(msg.result, msg.diff);
           }
-        } catch {}
+        } catch {
+        }
       };
       ws.onclose = () => {
         this._ws = null;
       };
     });
   }
-}
+};
 function entityToPlain(entity) {
   const obj = { id: entity.id, type: entity.type };
   for (const f of entity.facts) {
-    if (f.a !== "type")
-      obj[f.a] = f.v;
+    if (f.a !== "type") obj[f.a] = f.v;
   }
   return obj;
 }
-
-class FetchError extends Error {
-  status;
-  body;
+var FetchError = class extends Error {
   constructor(status, message, body) {
     super(`HTTP ${status}: ${message}`);
     this.status = status;
     this.body = body;
     this.name = "FetchError";
   }
-}
+};
 
-export { TrellisDb, FetchError };
+export {
+  TrellisDb,
+  FetchError
+};

package/dist/chunk-2BRTCEHB.js

@@ -0,0 +1,143 @@
+import {
+  RelayPersistence
+} from "./chunk-GFZCJ4EH.js";
+
+// src/realtime/relay-server.ts
+var REPLAY_GRACE_MS = 250;
+var DEFAULT_ROOM = "default";
+function roomFromPath(reqPath, basePath) {
+  const normalized = reqPath.replace(/\/+$/, "") || "/";
+  const base = basePath.replace(/\/+$/, "") || "/";
+  if (normalized === base) return DEFAULT_ROOM;
+  const prefix = base === "/" ? "/" : `${base}/`;
+  if (!reqPath.startsWith(prefix)) return null;
+  const rest = reqPath.slice(prefix.length).split("?")[0].replace(/\/+$/, "");
+  return rest ? decodeURIComponent(rest) : DEFAULT_ROOM;
+}
+async function attachRealtimeRelay(server, opts = {}) {
+  const path = opts.path ?? "/rt";
+  const graceMs = opts.replayGraceMs ?? REPLAY_GRACE_MS;
+  const makePersistence = opts.persistence === false ? null : opts.persistence ?? (() => new RelayPersistence());
+  const Wss = opts.WebSocketServerImpl ?? (await import("ws")).WebSocketServer;
+  const wss = new Wss({ noServer: true });
+  const rooms = /* @__PURE__ */ new Map();
+  const pendingRoom = /* @__PURE__ */ new WeakMap();
+  const roomState = (room) => {
+    let st = rooms.get(room);
+    if (!st) {
+      st = { clients: /* @__PURE__ */ new Set(), persistence: makePersistence?.() ?? null };
+      rooms.set(room, st);
+    }
+    return st;
+  };
+  const sendReplay = (ws, st) => {
+    if (!st.persistence) return;
+    const messages = st.persistence.buildReplay();
+    if (messages.length === 0) return;
+    const frame = { v: 1, t: "replay", from: "relay", messages };
+    ws.send(JSON.stringify(frame));
+  };
+  wss.on("connection", (ws) => {
+    const room = pendingRoom.get(ws) ?? DEFAULT_ROOM;
+    pendingRoom.delete(ws);
+    const st = roomState(room);
+    st.clients.add(ws);
+    const replaySent = { value: false };
+    const deliverReplay = () => {
+      if (replaySent.value) return;
+      replaySent.value = true;
+      sendReplay(ws, st);
+    };
+    const graceTimer = graceMs > 0 ? setTimeout(deliverReplay, graceMs) : null;
+    graceTimer?.unref?.();
+    ws.on("message", (data, isBinary) => {
+      const raw = isBinary ? data : String(data);
+      let message;
+      try {
+        message = JSON.parse(String(raw));
+      } catch {
+        return;
+      }
+      if (message?.v === 1) {
+        if (message.t === "hello") deliverReplay();
+        st.persistence?.record(message);
+      }
+      for (const peer of st.clients) {
+        if (peer === ws || peer.readyState !== peer.OPEN) continue;
+        peer.send(String(raw));
+      }
+    });
+    ws.on("close", () => {
+      if (graceTimer) clearTimeout(graceTimer);
+      st.clients.delete(ws);
+      if (st.clients.size === 0) rooms.delete(room);
+    });
+  });
+  const onUpgrade = (req, socket, head) => {
+    const reqPath = (req.url ?? "").split("?")[0];
+    const room = roomFromPath(reqPath, path);
+    if (room === null) return;
+    wss.handleUpgrade(req, socket, head, (ws) => {
+      pendingRoom.set(ws, room);
+      wss.emit("connection", ws, req);
+    });
+  };
+  server.on("upgrade", onUpgrade);
+  return {
+    clientCount: (room) => {
+      if (room !== void 0) return rooms.get(room)?.clients.size ?? 0;
+      let total = 0;
+      for (const st of rooms.values()) total += st.clients.size;
+      return total;
+    },
+    rooms: () => [...rooms.keys()],
+    persistenceFor: (room) => rooms.get(room)?.persistence ?? null,
+    close: () => new Promise((resolve) => {
+      server.off("upgrade", onUpgrade);
+      for (const st of rooms.values()) {
+        for (const ws of st.clients) {
+          try {
+            ws.close();
+          } catch {
+          }
+        }
+        st.clients.clear();
+      }
+      rooms.clear();
+      wss.close(() => resolve());
+    })
+  };
+}
+async function createRealtimeRelay(opts = {}) {
+  const { createServer } = await import("node:http");
+  const path = opts.path ?? "/rt";
+  const port = opts.port ?? 8231;
+  const hostname = opts.hostname ?? "0.0.0.0";
+  const server = createServer((req, res) => {
+    const reqPath = (req.url ?? "/").split("?")[0];
+    if (reqPath === "/" || reqPath === "/health") {
+      res.writeHead(200, { "content-type": "application/json" });
+      res.end(JSON.stringify({ ok: true, relay: path }));
+      return;
+    }
+    res.writeHead(404).end("not found");
+  });
+  const relay = await attachRealtimeRelay(server, opts);
+  await new Promise((resolve) => server.listen(port, hostname, resolve));
+  const addr = server.address();
+  const boundPort = typeof addr === "object" && addr ? addr.port : port;
+  return {
+    ...relay,
+    port: boundPort,
+    server,
+    close: async () => {
+      await relay.close();
+      await new Promise((resolve) => server.close(() => resolve()));
+    }
+  };
+}
+
+export {
+  attachRealtimeRelay,
+  createRealtimeRelay
+};

package/dist/chunk-2CX5UCRV.js

@@ -0,0 +1,111 @@
+import {
+  entitiesQuery,
+  resolveRelations
+} from "./chunk-7QQQNUB5.js";
+import {
+  Signal
+} from "./chunk-UBGUDMUV.js";
+
+// src/client/live.ts
+function liveQuery(client, eql) {
+  const signal = new Signal({
+    data: [],
+    loading: true,
+    error: null
+  });
+  let sub = null;
+  return {
+    signal,
+    start() {
+      if (sub) return () => stop();
+      try {
+        sub = client.subscribe(eql, (rows) => {
+          signal.value = { data: rows, loading: false, error: null };
+        });
+      } catch (err) {
+        signal.value = {
+          data: [],
+          loading: false,
+          error: err instanceof Error ? err : new Error(String(err))
+        };
+      }
+      return () => stop();
+    }
+  };
+  function stop() {
+    sub?.unsubscribe();
+    sub = null;
+  }
+}
+function normalizeLiveEntitiesOpts(whereOrOpts) {
+  if (!whereOrOpts) return {};
+  if ("resolve" in whereOrOpts) return whereOrOpts;
+  return { where: whereOrOpts };
+}
+function liveEntities(client, typeOrSchema, whereOrOpts) {
+  const schema = typeof typeOrSchema === "string" ? void 0 : typeOrSchema;
+  const type = typeof typeOrSchema === "string" ? typeOrSchema : typeOrSchema.type;
+  const { where, resolve } = normalizeLiveEntitiesOpts(whereOrOpts);
+  const signal = new Signal({
+    data: [],
+    loading: true,
+    error: null
+  });
+  let sub = null;
+  let token = 0;
+  return {
+    signal,
+    start() {
+      if (sub) return () => stop();
+      try {
+        sub = client.subscribe(
+          entitiesQuery(type, where),
+          (rows) => {
+            const turn = ++token;
+            const ids = rows.map((r) => r.e).filter(Boolean);
+            Promise.all(ids.map((id) => client.read(id))).then(async (entities) => {
+              if (turn !== token) return;
+              let data = entities.filter(
+                (e) => e != null
+              );
+              if (schema && resolve && Object.keys(resolve).length > 0) {
+                data = await resolveRelations(
+                  client,
+                  schema,
+                  data,
+                  resolve
+                );
+              }
+              if (turn !== token) return;
+              signal.value = { data, loading: false, error: null };
+            }).catch((err) => {
+              if (turn !== token) return;
+              signal.value = {
+                data: signal.peek().data,
+                loading: false,
+                error: err instanceof Error ? err : new Error(String(err))
+              };
+            });
+          }
+        );
+      } catch (err) {
+        signal.value = {
+          data: [],
+          loading: false,
+          error: err instanceof Error ? err : new Error(String(err))
+        };
+      }
+      return () => stop();
+    }
+  };
+  function stop() {
+    token++;
+    sub?.unsubscribe();
+    sub = null;
+  }
+}
+
+export {
+  liveQuery,
+  liveEntities
+};

package/dist/chunk-2ESYSVXG.js

@@ -0,0 +1,48 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+export {
+  __require,
+  __esm,
+  __commonJS,
+  __export,
+  __toESM,
+  __toCommonJS
+};