reflectdb 0.1.3 → 0.2.0

package/dist/htmx/index.js

@@ -0,0 +1,297 @@
+import {
+  createSync
+} from "../shared/esm-dcs8qa5n.js";
+import"../shared/esm-8qbr4y0d.js";
+import"../shared/esm-rw7jjtrv.js";
+import"../shared/esm-3tkwvysa.js";
+import"../shared/esm-g5h4a88j.js";
+
+// src/htmx/router.ts
+var REFLECT_SCHEME = "reflect:";
+function parseReflectAction(action) {
+  if (!action.startsWith(REFLECT_SCHEME))
+    return null;
+  const rest = action.slice(REFLECT_SCHEME.length);
+  const queryAt = rest.indexOf("?");
+  const path = queryAt === -1 ? rest : rest.slice(0, queryAt);
+  const query = queryAt === -1 ? "" : rest.slice(queryAt + 1);
+  const segments = path.split("/").filter((s) => s.length > 0);
+  if (segments.length === 0 || segments.length > 2)
+    return null;
+  const table = safeDecode(segments[0]);
+  if (!table)
+    return null;
+  const rawRowId = segments[1];
+  const rowId = rawRowId === undefined ? undefined : safeDecode(rawRowId);
+  if (rawRowId !== undefined && !rowId)
+    return null;
+  return { table, rowId, params: new URLSearchParams(query) };
+}
+function safeDecode(segment) {
+  try {
+    return decodeURIComponent(segment);
+  } catch {
+    return "";
+  }
+}
+var WRITE_METHODS = new Set(["POST", "PUT", "PATCH", "DELETE"]);
+function resolveOperation(action, method, body, options = {}) {
+  const parsed = parseReflectAction(action);
+  if (!parsed)
+    return null;
+  const verb = method.toUpperCase();
+  const { table, rowId, params } = parsed;
+  if (verb === "GET") {
+    return { kind: "read", table, rowId, params };
+  }
+  if (!WRITE_METHODS.has(verb)) {
+    return { kind: "error", status: 405, message: `${verb} is not supported by reflect: actions` };
+  }
+  if (verb === "DELETE") {
+    if (!rowId) {
+      return {
+        kind: "error",
+        status: 400,
+        message: `DELETE needs a row id: reflect:${table}/<rowId>`
+      };
+    }
+    return { kind: "remove", table, rowId };
+  }
+  const payload = collectPayload(body);
+  if (verb === "POST") {
+    if (rowId) {
+      return {
+        kind: "error",
+        status: 400,
+        message: `POST targets the collection: reflect:${table}, not reflect:${table}/${rowId}`
+      };
+    }
+    const bodyRowId = typeof payload.id === "string" && payload.id ? payload.id : undefined;
+    const generated = options.generateRowId?.() ?? crypto.randomUUID();
+    return { kind: "insert", table, rowId: bodyRowId ?? generated, payload };
+  }
+  if (!rowId) {
+    return {
+      kind: "error",
+      status: 400,
+      message: `${verb} needs a row id: reflect:${table}/<rowId>`
+    };
+  }
+  return { kind: "update", table, rowId, payload };
+}
+function collectPayload(body) {
+  const payload = {};
+  if (!body)
+    return payload;
+  for (const [key, value] of body) {
+    if (typeof value !== "string")
+      continue;
+    const existing = payload[key];
+    if (existing === undefined) {
+      payload[key] = value;
+    } else if (Array.isArray(existing)) {
+      existing.push(value);
+    } else {
+      payload[key] = [existing, value];
+    }
+  }
+  return payload;
+}
+
+// src/htmx/sync.ts
+var HTML_HEADERS = { "Content-Type": "text/html; charset=utf-8" };
+function createHtmxSync(config) {
+  const { htmx, ...syncConfig } = config;
+  const sync = createSync(syncConfig);
+  const configRequestEvent = "htmx:config:request".replace(/:/g, htmx.config?.metaCharacter || ":");
+  const views = new Map;
+  const parsers = new Map;
+  const bindings = new Map;
+  const unsubscribes = new Map;
+  const bound = new Map;
+  const dirty = new Set;
+  let flushHandle = null;
+  let installed = false;
+  let closed = false;
+  function bindingFor(table) {
+    let binding = bindings.get(table);
+    if (!binding) {
+      binding = sync.sync(table);
+      bindings.set(table, binding);
+      unsubscribes.set(table, binding.onChange(() => {
+        scheduleRender(table);
+      }));
+    }
+    return binding;
+  }
+  function scheduleRender(table) {
+    if (closed)
+      return;
+    dirty.add(table);
+    if (flushHandle !== null)
+      return;
+    flushHandle = setTimeout(() => {
+      flushHandle = null;
+      const tables = [...dirty];
+      dirty.clear();
+      for (const t of tables)
+        renderTable(t);
+    }, 0);
+  }
+  function renderTable(table) {
+    for (const [target, entry] of bound) {
+      if (!target.isConnected) {
+        bound.delete(target);
+        continue;
+      }
+      if (entry.table !== table)
+        continue;
+      htmx.ajax("GET", entry.action, {
+        source: entry.source.isConnected ? entry.source : target,
+        target,
+        swap: entry.swap,
+        confirm: null
+      });
+    }
+  }
+  function refresh(table) {
+    if (table === undefined) {
+      for (const t of new Set([...bound.values()].map((e) => e.table)))
+        renderTable(t);
+      return;
+    }
+    renderTable(table);
+  }
+  function serve(ctx, action, request) {
+    const method = request?.method ?? ctx.request.method;
+    const body = request?.body ?? ctx.request.body;
+    const op = resolveOperation(action, method, body);
+    if (!op) {
+      return respond(500, `reflectdb: could not parse action "${action}"`);
+    }
+    if (op.kind === "error") {
+      return respond(op.status, `reflectdb: ${op.message}`);
+    }
+    const binding = bindingFor(op.table);
+    if (op.kind === "read") {
+      const target = ctx.target ?? ctx.sourceElement;
+      bound.set(target, {
+        table: op.table,
+        action,
+        source: ctx.sourceElement,
+        target,
+        swap: ctx.swap
+      });
+      const view = views.get(op.table);
+      if (!view) {
+        return respond(500, `reflectdb: no view registered for "${op.table}" — call .view("${op.table}", …)`);
+      }
+      if (op.rowId !== undefined) {
+        const row = sync.getRow(op.table, op.rowId);
+        if (!row)
+          return respond(204);
+        return html(view({
+          rows: [row],
+          table: op.table,
+          rowId: op.rowId,
+          params: op.params
+        }));
+      }
+      return html(view({
+        rows: binding.getRows(),
+        table: op.table,
+        params: op.params
+      }));
+    }
+    if (op.kind === "remove") {
+      binding.remove(op.rowId);
+      return respond(204);
+    }
+    const parse = parsers.get(op.table);
+    const payload = parse ? parse(op.payload) : op.payload;
+    if (op.kind === "insert") {
+      binding.insert(op.rowId, payload);
+    } else {
+      binding.update(op.rowId, payload);
+    }
+    return respond(204);
+  }
+  function onConfigRequest(event) {
+    const ctx = event.detail?.ctx;
+    if (!ctx || !parseReflectAction(ctx.request.action))
+      return;
+    ctx.fetch = (action, request) => serve(ctx, action, request);
+  }
+  const api = {
+    sync,
+    view(table, view) {
+      views.set(table, view);
+      return api;
+    },
+    parse(table, parse) {
+      parsers.set(table, parse);
+      return api;
+    },
+    install() {
+      if (!installed) {
+        document.addEventListener(configRequestEvent, onConfigRequest);
+        installed = true;
+      }
+      return api;
+    },
+    uninstall() {
+      if (installed) {
+        document.removeEventListener(configRequestEvent, onConfigRequest);
+        installed = false;
+      }
+      bound.clear();
+    },
+    refresh,
+    async connect() {
+      api.install();
+      await sync.connect();
+    },
+    async close() {
+      closed = true;
+      if (flushHandle !== null) {
+        clearTimeout(flushHandle);
+        flushHandle = null;
+      }
+      api.uninstall();
+      for (const unsub of unsubscribes.values())
+        unsub();
+      unsubscribes.clear();
+      for (const binding of bindings.values())
+        binding.destroy();
+      bindings.clear();
+      await sync.close();
+    },
+    getState: () => sync.getState(),
+    onStateChange: (cb) => sync.onStateChange(cb),
+    getPendingCount: () => sync.getPendingCount(),
+    onPendingChange: (cb) => sync.onPendingChange(cb)
+  };
+  return api;
+}
+function html(markup) {
+  return Promise.resolve(new Response(markup, { status: 200, headers: HTML_HEADERS }));
+}
+function respond(status, message = "") {
+  return Promise.resolve(new Response(status === 204 ? null : message, { status, headers: HTML_HEADERS }));
+}
+// src/htmx/typed.ts
+function createSyncHtmx() {
+  return {
+    createHtmxSync(config) {
+      return createHtmxSync(config);
+    }
+  };
+}
+export {
+  REFLECT_SCHEME,
+  collectPayload,
+  createHtmxSync,
+  createSyncHtmx,
+  parseReflectAction,
+  resolveOperation
+};

package/dist/server/drizzle.js

@@ -1,7 +1,8 @@
 import {
   drizzleTable,
   drizzleTxAtomic
-} from "../shared/esm-77ndhmpv.js";
+} from "../shared/esm-5ahpq25j.js";
+import"../shared/esm-f11s9zpb.js";
 import"../shared/esm-g5h4a88j.js";
 export {
   drizzleTable,

package/dist/server/index.d.ts

@@ -769,6 +769,20 @@ declare class MessageHandler<TAuth extends AuthContext = AuthContext> {
 	private storage;
 	private minSchemaVersion;
 	private messageQueues;
+	/**
+	* Resolves once every message queued for `clientId` has finished processing.
+	*
+	* Messages are handled on a per-client serial queue, and `onMessage` returns
+	* before that work settles — fine for a long-lived connection, where replies
+	* stream out whenever they are ready. A serverless HTTP handler has no such
+	* luxury: it must know when the replies to the request it is holding exist,
+	* or it returns an empty body and the client hangs. See the SSE transport's
+	* `serverless` mode.
+	*
+	* Never rejects: a failed message is the caller's concern via its own reply,
+	* not this barrier's.
+	*/
+	whenIdle(clientId: string): Promise<void>;
 	private resultCache;
 	private broadcast;
 	private ops;

package/dist/server/index.js

@@ -12,9 +12,11 @@ import {
 import {
   defineTable,
   drizzleTable,
-  drizzleTxAtomic,
+  drizzleTxAtomic
+} from "../shared/esm-5ahpq25j.js";
+import {
   nodeRequire
-} from "../shared/esm-77ndhmpv.js";
+} from "../shared/esm-f11s9zpb.js";
 import {
   MAX_BATCH_SIZE,
   MAX_CLOCK_DRIFT_MS,
@@ -1838,6 +1840,18 @@ class MessageHandler {
   storage = null;
   minSchemaVersion = 0;
   messageQueues = new Map;
+  async whenIdle(clientId) {
+    for (let i = 0;i < 100; i++) {
+      const queue = this.messageQueues.get(clientId);
+      if (!queue)
+        return;
+      await queue.catch(() => {
+        return;
+      });
+      if (this.messageQueues.get(clientId) === queue)
+        return;
+    }
+  }
   resultCache = new ResultCache;
   broadcast;
   ops;