@fitzzero/quickdraw-core 5.1.2 → 5.1.3

package/dist/server/index.js

@@ -49,9 +49,10 @@ import {
   orderByOf,
   resolver,
   rowlessProblem,
+  seedRoomHosts,
   selectWith,
   watchAdapterClients
-} from "../chunk-6K5BY47X.js";
+} from "../chunk-JVTONQFI.js";
 import {
   DevWarningError,
   N_PLUS_ONE_STATEMENTS,
@@ -59,14 +60,14 @@ import {
   currentRev,
   formatDevWarning,
   runBeforeAnyDispatcher
-} from "../chunk-Z5ILULF2.js";
+} from "../chunk-SQ5VUG77.js";
 import {
   crud,
   crudSpecOf,
   sharing,
   sharingSpecOf
-} from "../chunk-NMXYENH4.js";
-import "../chunk-RL4VKLBX.js";
+} from "../chunk-VZFJTKIW.js";
+import "../chunk-KKQANRLG.js";
 import {
   SUBSCRIBER_LEVELS,
   abortError,
@@ -92,27 +93,42 @@ import {
   schemaOutputOf,
   serviceGrant,
   strip
-} from "../chunk-MBH6IDSM.js";
-import "../chunk-LCC7HNFP.js";
+} from "../chunk-OCZJ4EYV.js";
+import "../chunk-RZXJTDH5.js";
 import {
   recordSocketSession,
   toCallReply,
   unreadable
-} from "../chunk-RJ5I2VO3.js";
+} from "../chunk-PHCURHC7.js";
 import {
   ANY_FIELD,
   modelKey,
   storageOf
 } from "../chunk-DUBU3BB3.js";
+import {
+  search,
+  searchSpecOf
+} from "../chunk-XD7SRDUY.js";
+import "../chunk-4D2DOGAW.js";
+import {
+  ACCESS_LEVELS,
+  isAccessLevel
+} from "../chunk-AK23XSWD.js";
+import {
+  consoleLogger,
+  errorText
+} from "../chunk-DKE6QO26.js";
+import "../chunk-7473HK24.js";
+import "../chunk-2FDSKLBO.js";
 import {
   ADMIN_FIELD_TYPES,
   ADMIN_NEVER_WRITABLE,
   MAX_CURSOR_LENGTH,
   admin,
   adminSpecOf,
-  search,
-  searchSpecOf
-} from "../chunk-GKH3LJ7N.js";
+  writtenData
+} from "../chunk-MPQAT55F.js";
+import "../chunk-A2RBQD66.js";
 import {
   MAX_ENTITY_IDS_PER_SOCKET,
   MAX_SCOPES_PER_SOCKET,
@@ -120,25 +136,19 @@ import {
   entityRoom,
   reservedRoomPrefix,
   socketIdShaped
-} from "../chunk-753VJIUP.js";
+} from "../chunk-X4ZU4QH5.js";
 import {
   CHANNEL_DEFAULT_RATE,
+  isHostServed,
   isScopedStream
-} from "../chunk-5CGO426C.js";
-import "../chunk-4D2DOGAW.js";
-import {
-  ACCESS_LEVELS,
-  isAccessLevel
-} from "../chunk-AK23XSWD.js";
+} from "../chunk-GYLWEJHW.js";
 import "../chunk-47AEXVDM.js";
-import "../chunk-Z2LZ7IZ7.js";
-import {
-  consoleLogger,
-  errorText
-} from "../chunk-DKE6QO26.js";
+import "../chunk-SN3OZVEQ.js";
+import "../chunk-7Y5ROPXL.js";
 import {
   QuickdrawError
-} from "../chunk-4YO5H5ON.js";
+} from "../chunk-Q4OGQM5I.js";
+import "../chunk-QSU47XEX.js";
 
 // src/server/realtime/define.ts
 function isRecord(value) {
@@ -224,7 +234,7 @@ function checkChannel(service, name, def, entry, kinds, fail5) {
   });
 }
 function compileChannels(contract, value, kinds, fail5) {
-  const declared = Object.entries(contract.channels);
+  const declared = Object.entries(contract.channels).filter(([, def]) => !isHostServed(def));
   if (value === void 0 && declared.length === 0) {
     return /* @__PURE__ */ new Map();
   }
@@ -242,6 +252,11 @@ function compileChannels(contract, value, kinds, fail5) {
     if (def === void 0) {
       fail5(`"${name}" is not a channel of the contract`);
     }
+    if (isHostServed(def)) {
+      fail5(
+        `channel "${name}" is served by the room's host (serve: "host"): its messages never reach the server, so it takes no handler`
+      );
+    }
     channels.set(name, checkChannel(contract.name, name, def, entry, admitted, fail5));
   }
   return channels;
@@ -310,6 +325,11 @@ function checkStreamOptions(name, def, entry, fail5) {
   return { computeSeed: seed, validate };
 }
 function checkStream(name, def, needs, options, fail5) {
+  if (isHostServed(def) && options !== void 0) {
+    fail5(
+      `streams.${name}: the stream is served by the room's host (serve: "host"), whose client pushes its items and keeps its seed: the server takes no options for it`
+    );
+  }
   const access = engineForm(def.access);
   if (typeof access === "object" && "entry" in access && !needs.hasPolicy) {
     fail5(
@@ -329,7 +349,8 @@ function checkStream(name, def, needs, options, fail5) {
     ...checkStreamOptions(name, def, options, fail5),
     volatile: def.volatile === true,
     access,
-    room: roomAccess(def.access)
+    room: roomAccess(def.access),
+    host: isHostServed(def)
   });
 }
 function compileStreams(contract, needs, value, fail5) {
@@ -506,6 +527,7 @@ var DEFINITION_KEYS = /* @__PURE__ */ new Set([
   "channels",
   "streams",
   "onRoomLeave",
+  "onHostLeave",
   "adminBypass",
   "kinds"
 ]);
@@ -724,13 +746,16 @@ function buildService(runtime, contract, definition) {
     fail5("the definition must be an object");
   }
   checkKeys(definition, DEFINITION_KEYS, "the definition", fail5);
-  const { adminBypass = true, onRoomLeave } = definition;
+  const { adminBypass = true, onRoomLeave, onHostLeave } = definition;
   if (typeof adminBypass !== "boolean") {
     fail5("adminBypass must be a boolean");
   }
   if (onRoomLeave !== void 0 && typeof onRoomLeave !== "function") {
     fail5("onRoomLeave must be a function of the leave and a run context");
   }
+  if (onHostLeave !== void 0 && typeof onHostLeave !== "function") {
+    fail5("onHostLeave must be a function of the leave and a run context");
+  }
   const data = checkServiceData(definition, runtime.kinds, fail5);
   const projections = compileProjections(checked2, definition.project, fail5);
   const collections = compileCollections(
@@ -760,7 +785,8 @@ function buildService(runtime, contract, definition) {
       definition.streams,
       fail5
     ),
-    onRoomLeave
+    onRoomLeave,
+    onHostLeave
   });
   checkHandlers(service, fail5);
   registerRuntime(service, runtime);
@@ -801,6 +827,10 @@ function streamOf(current, contract, name) {
     },
     pushMany(...args) {
       handle().pushMany(...args);
+    },
+    // Async, so every refusal (no dispatcher, a host-served stream, a bad scope) rejects.
+    async subscribers(...args) {
+      return await handle().subscribers(...args);
     }
   });
 }
@@ -2133,7 +2163,8 @@ async function authorizeScope(run, collection, scope) {
   const rule = {
     service: runtime.service,
     anchor: collection.anchor?.name,
-    access: collection.access
+    access: collection.access,
+    requires: collection.requires
   };
   const allowed = await allowedScopes(runtime.access, rule, principal, [scope]);
   if (!allowed.has(scope)) {
@@ -3558,6 +3589,45 @@ async function checkWrite(call, context, data) {
     ["data"]
   );
 }
+function preparedIssues(call, columns) {
+  const never = Object.keys(columns).filter((name) => ADMIN_NEVER_WRITABLE.includes(name)).map((name) => ({
+    path: ["data", name],
+    message: `"${name}" is not writable; the database sets it`
+  }));
+  return [...never, ...columnValueIssues(call.runtime.service, columns, ["data"])];
+}
+async function prepareWrite(call, context, write, ctx, db) {
+  const { prepare } = context;
+  const data = write.method === "adminDelete" ? {} : write.data;
+  if (prepare === void 0) {
+    return data;
+  }
+  const returned = await checked(() => prepare(write, ctx, db));
+  if (write.method === "adminDelete" || returned === void 0) {
+    return data;
+  }
+  const { name } = call.runtime.service;
+  if (!isPlainObject(returned)) {
+    throw new QuickdrawError(
+      "INTERNAL",
+      `The admin kit's prepare for ${name} must return column values, or nothing`
+    );
+  }
+  const columns = writtenData(returned);
+  const issues = preparedIssues(call, columns);
+  if (issues.length > 0) {
+    throw new QuickdrawError(
+      "VALIDATION",
+      `The admin kit's prepare for ${name} returned data the kit does not write`,
+      { issues }
+    );
+  }
+  const level = rowLevel(context.form, "Moderate");
+  await checkAnchorColumns(call.runtime, call.principal, columns, level, {
+    creating: write.method === "adminCreate"
+  });
+  return { ...data, ...columns };
+}
 function isValueRefusal(error) {
   if (!(error instanceof Error)) {
     return false;
@@ -3608,37 +3678,65 @@ function committed(context, args, write) {
     failed(error);
   }
 }
-async function written(context, call, args, method, perform) {
-  const { onWrite, onCommitted } = context;
-  const attempt = async (table, before) => {
+async function rowBefore(context, call, table, write) {
+  const readsAsItDeletes = write.method === "adminDelete" && context.prepare === void 0;
+  if (write.method === "adminCreate" || readsAsItDeletes) {
+    return void 0;
+  }
+  const row = await table.findUnique({ where: { id: write.id }, select: call.projection.select });
+  return requireRow(row, `No such ${call.model}`);
+}
+function prepareCall(write, before) {
+  if (write.method === "adminCreate") {
+    return Object.freeze({ method: write.method, data: Object.freeze({ ...write.data }) });
+  }
+  if (write.method === "adminUpdate") {
+    const data = Object.freeze({ ...write.data });
+    return Object.freeze({ method: write.method, id: write.id, data, before });
+  }
+  return Object.freeze({ method: write.method, id: write.id, before });
+}
+async function written(context, call, args, write, perform) {
+  const { prepare, onWrite, onCommitted } = context;
+  const data = write.method === "adminDelete" ? {} : write.data;
+  const attempt = async (table, values, before) => {
     try {
-      return await perform(table, before);
+      return await perform({ table, values, before });
     } catch (error) {
       throw writeRefusal(error);
     }
   };
-  if (onWrite === void 0 && onCommitted === void 0) {
-    return (await attempt(call.table, false)).reply;
+  if (prepare === void 0 && onWrite === void 0 && onCommitted === void 0) {
+    return (await attempt(call.table, data, false)).reply;
   }
-  let write;
+  const ctx = args.ctx;
+  let heard;
   const reply = await inKitTransaction(
     args.db,
     async (tx) => {
-      const done = await attempt(tableOf2(tx, call.model), method !== "adminCreate");
+      const table = tableOf2(tx, call.model);
       const whole = (row) => row ? rowWhole(call, row) : null;
-      write = {
-        method,
+      const first = await rowBefore(context, call, table, write);
+      const before = first === void 0 ? void 0 : whole(first);
+      const values = await prepareWrite(call, context, prepareCall(write, before), ctx, tx);
+      const done = await attempt(
+        table,
+        values,
+        write.method === "adminDelete" && first === void 0
+      );
+      heard = {
+        method: write.method,
         id: done.id,
-        ...method === "adminCreate" ? {} : { before: whole(done.before) },
+        ...write.method === "adminCreate" ? {} : { before: before ?? whole(done.before) },
         after: whole(done.after)
       };
-      await onWrite?.(write, args.ctx, tx);
+      await onWrite?.(heard, ctx, tx);
       return done.reply;
     },
-    { owner: "The admin kit's writes with onWrite or onCommitted" }
+    { owner: "The admin kit's writes with prepare, onWrite or onCommitted" }
   );
-  if (write !== void 0) {
-    committed(context, args, write);
+  if (heard !== void 0) {
+    committed(context, args, heard);
   }
   return reply;
 }
@@ -3657,8 +3755,10 @@ function adminCreateHandler(context) {
     const call = adminCall(args.ctx, args.db, context.fieldsFor);
     const { data } = args.input;
     await checkWrite(call, context, data);
-    return await written(context, call, args, "adminCreate", async (table) => {
-      const after = await table.create({ data, select: call.projection.select });
+    const { select } = call.projection;
+    const write = { method: "adminCreate", data };
+    return await written(context, call, args, write, async ({ table, values }) => {
+      const after = await table.create({ data: values, select });
       return { id: idOf(after), after, reply: rowOut(call, after) };
     });
   };
@@ -3673,10 +3773,10 @@ function adminUpdateHandler(context) {
       return await readRow(call, id);
     }
     const { select } = call.projection;
-    return await written(context, call, args, "adminUpdate", async (table, withBefore) => {
-      const before = withBefore ? await table.findUnique({ where: { id }, select }) : void 0;
-      const after = await table.update({ where: { id }, data, select });
-      return { id, before, after, reply: rowOut(call, after) };
+    const write = { method: "adminUpdate", id, data };
+    return await written(context, call, args, write, async ({ table, values }) => {
+      const after = await table.update({ where: { id }, data: values, select });
+      return { id, after, reply: rowOut(call, after) };
     });
   };
   return handler;
@@ -3685,10 +3785,11 @@ function adminDeleteHandler(context) {
   const handler = async (args) => {
     const call = adminCall(args.ctx, args.db, context.fieldsFor);
     const { id } = args.input;
-    return await written(context, call, args, "adminDelete", async (table, withBefore) => {
-      const select = withBefore ? call.projection.select : { id: true };
-      const before = await table.delete({ where: { id }, select });
-      return { id, ...withBefore ? { before } : {}, after: null, reply: null };
+    const write = { method: "adminDelete", id };
+    return await written(context, call, args, write, async ({ table, before }) => {
+      const select = before ? call.projection.select : { id: true };
+      const row = await table.delete({ where: { id }, select });
+      return { id, ...before ? { before: row } : {}, after: null, reply: null };
     });
   };
   return handler;
@@ -3739,6 +3840,7 @@ var OPTION_KEYS3 = [
   "fieldOverrides",
   "rowless",
   "grants",
+  "prepare",
   "onWrite",
   "onCommitted"
 ];
@@ -3776,7 +3878,7 @@ function checkOptions3(options) {
   }
   if (!isRecord11(options)) {
     fail4(
-      "options must be { access?, displayName?, hiddenFields?, editable?, fieldOverrides?, rowless?, grants?, onWrite?, onCommitted? }"
+      "options must be { access?, displayName?, hiddenFields?, editable?, fieldOverrides?, rowless?, grants?, prepare?, onWrite?, onCommitted? }"
     );
   }
   const unknownKey = Object.keys(options).find((key) => !OPTION_KEYS3.includes(key));
@@ -3884,7 +3986,10 @@ function handlers4(contract, options) {
   const rowless = rowlessMethods(checked2.rowless, names, fail4);
   const fieldsFor = fieldsByColumn(contract, kit, checked2);
   const fields = fieldsFor(void 0);
-  const { onWrite, onCommitted } = checked2;
+  const { prepare, onWrite, onCommitted } = checked2;
+  if (prepare !== void 0 && typeof prepare !== "function") {
+    fail4("prepare must be a function of (call, ctx, db)");
+  }
   if (onWrite !== void 0 && typeof onWrite !== "function") {
     fail4("onWrite must be a function of (write, ctx, db)");
   }
@@ -3892,6 +3997,7 @@ function handlers4(contract, options) {
     fail4("onCommitted must be a function of (write, ctx)");
   }
   const hooks = {
+    prepare,
     onWrite,
     onCommitted
   };
@@ -3970,6 +4076,7 @@ async function setupRedisAdapter(io, options = {}) {
     await Promise.all([pubClient.connect(), subClient.connect()]);
     io.adapter(createAdapter(pubClient, subClient, { key }));
     watchAdapterClients(io, logger);
+    seedRoomHosts(io);
     logger.info(`Redis adapter connected to ${host}:${port}`);
     const cleanup = async () => {
       try {