spacetimedb 2.0.3 → 2.1.0

package/dist/index.browser.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;
@@ -1220,7 +1223,8 @@ writer.offset += ${primitiveSizes[tag]};` : `writer.write${tag}(value.${name});`
 const result = { ${ty.elements.map(getElementInitializer).join(", ")} };
 const view = reader.view;
 ${ty.elements.map(
-        ({ name, algebraicType: { tag } }) => tag in primitiveJSName ? `result.${name} = view.get${primitiveJSName[tag]}(reader.offset, ${primitiveSizes[tag] > 1 ? "true" : ""});
+        ({ name, algebraicType: { tag } }) => tag in primitiveJSName ? tag === "Bool" ? `result.${name} = view.getUint8(reader.offset) !== 0;
+reader.offset += 1;` : `result.${name} = view.get${primitiveJSName[tag]}(reader.offset, ${primitiveSizes[tag] > 1 ? "true" : ""});
 reader.offset += ${primitiveSizes[tag]};` : `result.${name} = reader.read${tag}();`
       ).join("\n")}
 return result;`;
@@ -1628,7 +1632,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);
   }
@@ -1723,7 +1727,8 @@ function createRowExpr(tableDef) {
     const column = new ColumnExpression(
       tableDef.sourceName,
       columnName,
-      columnBuilder.typeBuilder.algebraicType
+      columnBuilder.typeBuilder.algebraicType,
+      columnBuilder.columnMetadata.name
     );
     row[columnName] = Object.freeze(column);
   }
@@ -1741,14 +1746,18 @@ function renderSelectSqlWithJoins(table2, where, extraClauses = []) {
 }
 var ColumnExpression = class {
   type = "column";
+  // This is the column accessor
   column;
+  // The name of the column in the database.
+  columnName;
   table;
   // phantom: actual runtime value is undefined
   tsValueType;
   spacetimeType;
-  constructor(table2, column, spacetimeType) {
+  constructor(table2, column, spacetimeType, columnName) {
     this.table = table2;
     this.column = column;
+    this.columnName = columnName || column;
     this.spacetimeType = spacetimeType;
   }
   eq(x) {
@@ -1805,15 +1814,36 @@ 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;
   }
   and(other) {
-    return new _BooleanExpr({ type: "and", clauses: [this.data, other.data] });
+    return new _BooleanExpr({
+      type: "and",
+      clauses: [this.data, other.data]
+    });
   }
   or(other) {
-    return new _BooleanExpr({ type: "or", clauses: [this.data, other.data] });
+    return new _BooleanExpr({
+      type: "or",
+      clauses: [this.data, other.data]
+    });
   }
   not() {
     return new _BooleanExpr({ type: "not", clause: this.data });
@@ -1822,13 +1852,15 @@ var BooleanExpr = class _BooleanExpr {
 function not(clause) {
   return new BooleanExpr({ type: "not", clause: clause.data });
 }
-function and(...clauses) {
+function and(first, second, ...rest) {
+  const clauses = [first, second, ...rest];
   return new BooleanExpr({
     type: "and",
     clauses: clauses.map((c) => c.data)
   });
 }
-function or(...clauses) {
+function or(first, second, ...rest) {
+  const clauses = [first, second, ...rest];
   return new BooleanExpr({
     type: "or",
     clauses: clauses.map((c) => c.data)
@@ -1865,7 +1897,7 @@ function valueExprToSql(expr, tableAlias) {
     return literalValueToSql(expr.value);
   }
   const table2 = expr.table;
-  return `${quoteIdentifier(table2)}.${quoteIdentifier(expr.column)}`;
+  return `${quoteIdentifier(table2)}.${quoteIdentifier(expr.columnName)}`;
 }
 function literalValueToSql(value) {
   if (value === null || value === void 0) {
@@ -4446,9 +4478,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;
     }
@@ -5005,37 +5035,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);
@@ -5044,14 +5076,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;
   }
@@ -5688,12 +5712,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);
@@ -5703,12 +5728,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) => {
@@ -5863,34 +5889,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;
@@ -6232,11 +6256,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);
@@ -6266,17 +6286,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
@@ -6286,26 +6334,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 } : {}
   };
@@ -7129,6 +7167,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":
@@ -7149,7 +7195,7 @@ function table(opts, row, ..._) {
     }
     indexes.push({
       sourceName: void 0,
-      accessorName: indexOpts.accessor,
+      accessorName: accessor,
       algorithm,
       canonicalName: indexOpts.name
     });
@@ -7199,7 +7245,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
   };