spacetimedb 2.0.2 → 2.0.4

package/dist/sdk/index.mjs

@@ -581,6 +581,9 @@ var BinaryWriter = class {
   constructor(init) {
     this.buffer = typeof init === "number" ? new ResizableBuffer(init) : init;
   }
+  clear() {
+    this.offset = 0;
+  }
   reset(buffer) {
     this.buffer = buffer;
     this.offset = 0;
@@ -718,12 +721,6 @@ var BinaryWriter = class {
 };
 
 // src/lib/util.ts
-function toPascalCase(s) {
-  const str = s.replace(/([-_][a-z])/gi, ($1) => {
-    return $1.toUpperCase().replace("-", "").replace("_", "");
-  });
-  return str.charAt(0).toUpperCase() + str.slice(1);
-}
 function deepEqual(obj1, obj2) {
   if (obj1 === obj2) return true;
   if (typeof obj1 !== "object" || obj1 === null || typeof obj2 !== "object" || obj2 === null) {
@@ -786,8 +783,13 @@ function u256ToUint8Array(data) {
 function u256ToHexString(data) {
   return uint8ArrayToHexString(u256ToUint8Array(data));
 }
-function toCamelCase(str) {
-  return str.replace(/[-_]+/g, "_").replace(/_([a-zA-Z0-9])/g, (_, c) => c.toUpperCase());
+function toPascalCase(s) {
+  const str = toCamelCase(s);
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+function toCamelCase(s) {
+  const str = s.replace(/[-_]+/g, "_").replace(/_([a-zA-Z0-9])/g, (_, c) => c.toUpperCase());
+  return str.charAt(0).toLowerCase() + str.slice(1);
 }
 function coerceParams(params) {
   return Object.fromEntries(
@@ -1576,7 +1578,7 @@ var FromBuilder = class _FromBuilder {
   }
   [QueryBrand] = true;
   where(predicate) {
-    const newCondition = predicate(this.table.cols);
+    const newCondition = normalizePredicateExpr(predicate(this.table.cols));
     const nextWhere = this.whereClause ? this.whereClause.and(newCondition) : newCondition;
     return new _FromBuilder(this.table, nextWhere);
   }
@@ -1753,6 +1755,21 @@ function normalizeValue(val) {
   }
   return literal(val);
 }
+function normalizePredicateExpr(value) {
+  if (value instanceof BooleanExpr) return value;
+  if (typeof value === "boolean") {
+    return new BooleanExpr({
+      type: "eq",
+      left: literal(value),
+      right: literal(true)
+    });
+  }
+  return new BooleanExpr({
+    type: "eq",
+    left: value,
+    right: literal(true)
+  });
+}
 var BooleanExpr = class _BooleanExpr {
   constructor(data) {
     this.data = data;
@@ -4314,9 +4331,7 @@ var TableCacheImpl = class {
     this.tableDef = tableDef;
     this.rows = /* @__PURE__ */ new Map();
     this.emitter = new EventEmitter();
-    const indexesDef = this.tableDef.indexes || [];
-    for (const idx of indexesDef) {
-      const idxDef = idx;
+    for (const idxDef of this.tableDef.resolvedIndexes) {
       const index = this.#makeReadonlyIndex(this.tableDef, idxDef);
       this[idxDef.name] = index;
     }
@@ -4873,37 +4888,39 @@ async function resolveWS() {
 
 // src/sdk/websocket_decompress_adapter.ts
 var WebsocketDecompressAdapter = class _WebsocketDecompressAdapter {
-  onclose;
-  onopen;
-  onmessage;
-  onerror;
-  #ws;
-  async #handleOnMessage(msg) {
-    const buffer = new Uint8Array(msg.data);
-    let decompressed;
-    if (buffer[0] === 0) {
-      decompressed = buffer.slice(1);
-    } else if (buffer[0] === 1) {
-      throw new Error(
-        "Brotli Compression not supported. Please use gzip or none compression in withCompression method on DbConnection."
-      );
-    } else if (buffer[0] === 2) {
-      decompressed = await decompress(buffer.slice(1), "gzip");
-    } else {
-      throw new Error(
-        "Unexpected Compression Algorithm. Please use `gzip` or `none`"
-      );
-    }
-    this.onmessage?.({ data: decompressed });
+  set onclose(handler) {
+    this.#ws.onclose = handler;
   }
-  #handleOnOpen(msg) {
-    this.onopen?.(msg);
+  set onopen(handler) {
+    this.#ws.onopen = handler;
   }
-  #handleOnError(msg) {
-    this.onerror?.(msg);
+  set onmessage(handler) {
+    this.#ws.onmessage = async (msg) => {
+      const data = await this.#decompress(new Uint8Array(msg.data));
+      handler({ data });
+    };
   }
-  #handleOnClose(msg) {
-    this.onclose?.(msg);
+  set onerror(handler) {
+    this.#ws.onerror = handler;
+  }
+  #ws;
+  async #decompress(buffer) {
+    const tag = buffer[0];
+    const data = buffer.subarray(1);
+    switch (tag) {
+      case 0:
+        return data;
+      case 1:
+        throw new Error(
+          "Brotli Compression not supported. Please use gzip or none compression in withCompression method on DbConnection."
+        );
+      case 2:
+        return await decompress(data, "gzip");
+      default:
+        throw new Error(
+          "Unexpected Compression Algorithm. Please use `gzip` or `none`"
+        );
+    }
   }
   send(msg) {
     this.#ws.send(msg);
@@ -4912,14 +4929,6 @@ var WebsocketDecompressAdapter = class _WebsocketDecompressAdapter {
     this.#ws.close();
   }
   constructor(ws) {
-    this.onmessage = void 0;
-    this.onopen = void 0;
-    this.onmessage = void 0;
-    this.onerror = void 0;
-    ws.onmessage = this.#handleOnMessage.bind(this);
-    ws.onerror = this.#handleOnError.bind(this);
-    ws.onclose = this.#handleOnClose.bind(this);
-    ws.onopen = this.#handleOnOpen.bind(this);
     ws.binaryType = "arraybuffer";
     this.#ws = ws;
   }
@@ -5556,12 +5565,13 @@ var DbConnectionImpl = class {
   }
   #makeReducers(def) {
     const out = {};
+    const writer = new BinaryWriter(1024);
     for (const reducer of def.reducers) {
       const reducerName = reducer.name;
       const key = reducer.accessorName;
       const { serialize: serializeArgs } = this.#reducerArgsSerializers[reducerName];
       out[key] = (params) => {
-        const writer = new BinaryWriter(1024);
+        writer.clear();
         serializeArgs(writer, params);
         const argsBuffer = writer.getBuffer();
         return this.callReducer(reducerName, argsBuffer, params);
@@ -5571,12 +5581,13 @@ var DbConnectionImpl = class {
   }
   #makeProcedures(def) {
     const out = {};
+    const writer = new BinaryWriter(1024);
     for (const procedure of def.procedures) {
       const procedureName = procedure.name;
       const key = procedure.accessorName;
       const { serializeArgs, deserializeReturn } = this.#procedureSerializers[procedureName];
       out[key] = (params) => {
-        const writer = new BinaryWriter(1024);
+        writer.clear();
         serializeArgs(writer, params);
         const argsBuffer = writer.getBuffer();
         return this.callProcedure(procedureName, argsBuffer).then((returnBuf) => {
@@ -5731,34 +5742,32 @@ var DbConnectionImpl = class {
     }
     return this.#mergeTableUpdates(updates);
   }
-  #sendEncoded(wsResolved, message) {
-    stdbLogger(
-      "trace",
-      () => `Sending message to server: ${stringify(message)}`
-    );
-    const writer = new BinaryWriter(1024);
-    ClientMessage.serialize(writer, message);
-    const encoded = writer.getBuffer();
-    wsResolved.send(encoded);
-  }
   #flushOutboundQueue(wsResolved) {
-    if (!this.isActive || this.#outboundQueue.length === 0) {
-      return;
-    }
     const pending = this.#outboundQueue.splice(0);
     for (const message of pending) {
-      this.#sendEncoded(wsResolved, message);
+      wsResolved.send(message);
     }
   }
+  #clientMessageEncoder = new BinaryWriter(1024);
   #sendMessage(message) {
-    this.wsPromise.then((wsResolved) => {
-      if (!wsResolved || !this.isActive) {
-        this.#outboundQueue.push(message);
-        return;
-      }
-      this.#flushOutboundQueue(wsResolved);
-      this.#sendEncoded(wsResolved, message);
-    });
+    const writer = this.#clientMessageEncoder;
+    writer.clear();
+    ClientMessage.serialize(writer, message);
+    const encoded = writer.getBuffer();
+    if (this.ws && this.isActive) {
+      if (this.#outboundQueue.length) this.#flushOutboundQueue(this.ws);
+      stdbLogger(
+        "trace",
+        () => `Sending message to server: ${stringify(message)}`
+      );
+      this.ws.send(encoded);
+    } else {
+      stdbLogger(
+        "trace",
+        () => `Queuing message to server: ${stringify(message)}`
+      );
+      this.#outboundQueue.push(encoded.slice());
+    }
   }
   #nextEventId() {
     this.#eventId += 1;
@@ -6100,11 +6109,7 @@ var DbConnectionImpl = class {
    * ```
    */
   disconnect() {
-    this.wsPromise.then((wsResolved) => {
-      if (wsResolved) {
-        wsResolved.close();
-      }
-    });
+    this.wsPromise.then((ws) => ws?.close());
   }
   on(eventName, callback) {
     this.#emitter.on(eventName, callback);
@@ -6134,17 +6139,45 @@ var DbConnectionImpl = class {
 
 // src/lib/schema.ts
 function tablesToSchema(ctx, tables) {
+  const tableDefs = /* @__PURE__ */ Object.create(null);
+  for (const [accName, schema2] of Object.entries(tables)) {
+    tableDefs[accName] = tableToSchema(
+      accName,
+      schema2,
+      schema2.tableDef(ctx, accName)
+    );
+  }
   return {
-    tables: Object.fromEntries(
-      Object.entries(tables).map(([accName, schema2]) => [
-        accName,
-        tableToSchema(accName, schema2, schema2.tableDef(ctx, accName))
-      ])
-    )
+    tables: tableDefs
   };
 }
 function tableToSchema(accName, schema2, tableDef) {
   const getColName = (i) => schema2.rowType.algebraicType.value.elements[i].name;
+  const resolvedIndexes = tableDef.indexes.map(
+    (idx) => {
+      const accessorName = idx.accessorName;
+      if (typeof accessorName !== "string" || accessorName.length === 0) {
+        throw new TypeError(
+          `Index '${idx.sourceName ?? "<unknown>"}' on table '${tableDef.sourceName}' is missing accessor name`
+        );
+      }
+      const columnIds = idx.algorithm.tag === "Direct" ? [idx.algorithm.value] : idx.algorithm.value;
+      const unique = tableDef.constraints.some(
+        (c) => c.data.tag === "Unique" && c.data.value.columns.every((col) => columnIds.includes(col))
+      );
+      const algorithm = {
+        BTree: "btree",
+        Hash: "hash",
+        Direct: "direct"
+      }[idx.algorithm.tag];
+      return {
+        name: accessorName,
+        unique,
+        algorithm,
+        columns: columnIds.map(getColName)
+      };
+    }
+  );
   return {
     // For client,`schama.tableName` will always be there as canonical name.
     // For module, if explicit name is not provided via `name`, accessor name will
@@ -6154,26 +6187,16 @@ function tableToSchema(accName, schema2, tableDef) {
     columns: schema2.rowType.row,
     // typed as T[i]['rowType']['row'] under TablesToSchema<T>
     rowType: schema2.rowSpacetimeType,
+    // Keep declarative indexes in their original shape for type-level consumers.
+    indexes: schema2.idxs,
     constraints: tableDef.constraints.map((c) => ({
       name: c.sourceName,
       constraint: "unique",
       columns: c.data.value.columns.map(getColName)
     })),
-    // TODO: horrible horrible horrible. we smuggle this `Array<UntypedIndex>`
-    // by casting it to an `Array<IndexOpts>` as `TableToSchema` expects.
-    // This is then used in `TableCacheImpl.constructor` and who knows where else.
-    // We should stop lying about our types.
-    indexes: tableDef.indexes.map((idx) => {
-      const columnIds = idx.algorithm.tag === "Direct" ? [idx.algorithm.value] : idx.algorithm.value;
-      return {
-        name: idx.accessorName,
-        unique: tableDef.constraints.some(
-          (c) => c.data.value.columns.every((col) => columnIds.includes(col))
-        ),
-        algorithm: idx.algorithm.tag.toLowerCase(),
-        columns: columnIds.map(getColName)
-      };
-    }),
+    // Expose resolved runtime indexes separately so runtime users don't have to
+    // reinterpret `indexes` with unsafe casts.
+    resolvedIndexes,
     tableDef,
     ...tableDef.isEvent ? { isEvent: true } : {}
   };
@@ -6997,6 +7020,14 @@ function table(opts, row, ..._) {
     }
   }
   for (const indexOpts of userIndexes ?? []) {
+    const accessor = indexOpts.accessor;
+    if (typeof accessor !== "string" || accessor.length === 0) {
+      const tableLabel = name ?? "<unnamed>";
+      const indexLabel = indexOpts.name ?? "<unnamed>";
+      throw new TypeError(
+        `Index '${indexLabel}' on table '${tableLabel}' must define a non-empty 'accessor'`
+      );
+    }
     let algorithm;
     switch (indexOpts.algorithm) {
       case "btree":
@@ -7017,7 +7048,7 @@ function table(opts, row, ..._) {
     }
     indexes.push({
       sourceName: void 0,
-      accessorName: indexOpts.accessor,
+      accessorName: accessor,
       algorithm,
       canonicalName: indexOpts.name
     });
@@ -7067,7 +7098,9 @@ function table(opts, row, ..._) {
         isEvent
       };
     },
-    idxs: {},
+    // Preserve the declared index options as runtime data so `tableToSchema`
+    // can expose them without type-smuggling.
+    idxs: userIndexes,
     constraints,
     schedule
   };