spacetimedb 1.11.2 → 1.11.4

package/LICENSE.txt

@@ -5,7 +5,7 @@ Business Source License 1.1
 Parameters
 
 Licensor:             Clockwork Laboratories, Inc.
-Licensed Work:        SpacetimeDB 1.11.1
+Licensed Work:        SpacetimeDB 1.11.2
                       The Licensed Work is
                       (c) 2023 Clockwork Laboratories, Inc.
                       
@@ -21,7 +21,7 @@ Additional Use Grant: You may make use of the Licensed Work provided your
                       Licensed Work by creating tables whose schemas are
                       controlled by such third parties.
 
-Change Date:          2030-12-18
+Change Date:          2031-01-08
 
 Change License:       GNU Affero General Public License v3.0 with a linking
                       exception

package/dist/browser/react/index.mjs

@@ -99,6 +99,10 @@ var Timestamp = class _Timestamp {
   static now() {
     return _Timestamp.fromDate(/* @__PURE__ */ new Date());
   }
+  /** Convert to milliseconds since Unix epoch. */
+  toMillis() {
+    return this.microsSinceUnixEpoch / 1000n;
+  }
   /**
    * Get a `Timestamp` representing the same point in time as `date`.
    */
@@ -129,6 +133,257 @@ var Timestamp = class _Timestamp {
     );
   }
 };
+
+// src/lib/uuid.ts
+var Uuid = class _Uuid {
+  __uuid__;
+  /**
+   * The nil UUID (all zeros).
+   *
+   * @example
+   * ```ts
+   * const uuid = Uuid.NIL;
+   * console.assert(
+   *   uuid.toString() === "00000000-0000-0000-0000-000000000000"
+   * );
+   * ```
+   */
+  static NIL = new _Uuid(0n);
+  static MAX_UUID_BIGINT = 0xffffffffffffffffffffffffffffffffn;
+  /**
+   * The max UUID (all ones).
+   *
+   * @example
+   * ```ts
+   * const uuid = Uuid.MAX;
+   * console.assert(
+   *   uuid.toString() === "ffffffff-ffff-ffff-ffff-ffffffffffff"
+   * );
+   * ```
+   */
+  static MAX = new _Uuid(_Uuid.MAX_UUID_BIGINT);
+  /**
+   * Create a UUID from a raw 128-bit value.
+   *
+   * @param u - Unsigned 128-bit integer
+   * @throws {Error} If the value is outside the valid UUID range
+   */
+  constructor(u) {
+    if (u < 0n || u > _Uuid.MAX_UUID_BIGINT) {
+      throw new Error("Invalid UUID: must be between 0 and `MAX_UUID_BIGINT`");
+    }
+    this.__uuid__ = u;
+  }
+  /**
+   * Create a UUID `v4` from explicit random bytes.
+   *
+   * This method assumes the bytes are already sufficiently random.
+   * It only sets the appropriate bits for the UUID version and variant.
+   *
+   * @param bytes - Exactly 16 random bytes
+   * @returns A UUID `v4`
+   * @throws {Error} If `bytes.length !== 16`
+   *
+   * @example
+   * ```ts
+   * const randomBytes = new Uint8Array(16);
+   * const uuid = Uuid.fromRandomBytesV4(randomBytes);
+   *
+   * console.assert(
+   *   uuid.toString() === "00000000-0000-4000-8000-000000000000"
+   * );
+   * ```
+   */
+  static fromRandomBytesV4(bytes) {
+    if (bytes.length !== 16) throw new Error("UUID v4 requires 16 bytes");
+    const arr = new Uint8Array(bytes);
+    arr[6] = arr[6] & 15 | 64;
+    arr[8] = arr[8] & 63 | 128;
+    return new _Uuid(_Uuid.bytesToBigInt(arr));
+  }
+  /**
+   * Generate a UUID `v7` using a monotonic counter from `0` to `2^31 - 1`,
+   * a timestamp, and 4 random bytes.
+   *
+   * The counter wraps around on overflow.
+   *
+   * The UUID `v7` is structured as follows:
+   *
+   * ```ascii
+   * ┌───────────────────────────────────────────────┬───────────────────┐
+   * | B0  | B1  | B2  | B3  | B4  | B5              |         B6        |
+   * ├───────────────────────────────────────────────┼───────────────────┤
+   * |                 unix_ts_ms                    |      version 7    |
+   * └───────────────────────────────────────────────┴───────────────────┘
+   * ┌──────────────┬─────────┬──────────────────┬───────────────────────┐
+   * | B7           | B8      | B9  | B10 | B11  | B12 | B13 | B14 | B15 |
+   * ├──────────────┼─────────┼──────────────────┼───────────────────────┤
+   * | counter_high | variant |    counter_low   |        random         |
+   * └──────────────┴─────────┴──────────────────┴───────────────────────┘
+   * ```
+   *
+   * @param counter - Mutable monotonic counter (31-bit)
+   * @param now - Timestamp since the Unix epoch
+   * @param randomBytes - Exactly 4 random bytes
+   * @returns A UUID `v7`
+   *
+   * @throws {Error} If the `counter` is negative
+   * @throws {Error} If the `timestamp` is before the Unix epoch
+   * @throws {Error} If `randomBytes.length !== 4`
+   *
+   * @example
+   * ```ts
+   * const now = Timestamp.fromMillis(1_686_000_000_000n);
+   * const counter = { value: 1 };
+   * const randomBytes = new Uint8Array(4);
+   *
+   * const uuid = Uuid.fromCounterV7(counter, now, randomBytes);
+   *
+   * console.assert(
+   *   uuid.toString() === "0000647e-5180-7000-8000-000200000000"
+   * );
+   * ```
+   */
+  static fromCounterV7(counter, now, randomBytes) {
+    if (randomBytes.length !== 4) {
+      throw new Error("`fromCounterV7` requires `randomBytes.length == 4`");
+    }
+    if (counter.value < 0) {
+      throw new Error("`fromCounterV7` uuid `counter` must be non-negative");
+    }
+    if (now.__timestamp_micros_since_unix_epoch__ < 0) {
+      throw new Error("`fromCounterV7` `timestamp` before unix epoch");
+    }
+    const counterVal = counter.value;
+    counter.value = counterVal + 1 & 2147483647;
+    const tsMs = now.toMillis() & 0xffffffffffffn;
+    const bytes = new Uint8Array(16);
+    bytes[0] = Number(tsMs >> 40n & 0xffn);
+    bytes[1] = Number(tsMs >> 32n & 0xffn);
+    bytes[2] = Number(tsMs >> 24n & 0xffn);
+    bytes[3] = Number(tsMs >> 16n & 0xffn);
+    bytes[4] = Number(tsMs >> 8n & 0xffn);
+    bytes[5] = Number(tsMs & 0xffn);
+    bytes[7] = counterVal >>> 23 & 255;
+    bytes[9] = counterVal >>> 15 & 255;
+    bytes[10] = counterVal >>> 7 & 255;
+    bytes[11] = (counterVal & 127) << 1 & 255;
+    bytes[12] |= randomBytes[0] & 127;
+    bytes[13] = randomBytes[1];
+    bytes[14] = randomBytes[2];
+    bytes[15] = randomBytes[3];
+    bytes[6] = bytes[6] & 15 | 112;
+    bytes[8] = bytes[8] & 63 | 128;
+    return new _Uuid(_Uuid.bytesToBigInt(bytes));
+  }
+  /**
+   * Parse a UUID from a string representation.
+   *
+   * @param s - UUID string
+   * @returns Parsed UUID
+   * @throws {Error} If the string is not a valid UUID
+   *
+   * @example
+   * ```ts
+   * const s = "01888d6e-5c00-7000-8000-000000000000";
+   * const uuid = Uuid.parse(s);
+   *
+   * console.assert(uuid.toString() === s);
+   * ```
+   */
+  static parse(s) {
+    const hex = s.replace(/-/g, "");
+    if (hex.length !== 32) throw new Error("Invalid hex UUID");
+    let v = 0n;
+    for (let i = 0; i < 32; i += 2) {
+      v = v << 8n | BigInt(parseInt(hex.slice(i, i + 2), 16));
+    }
+    return new _Uuid(v);
+  }
+  /** Convert to string (hyphenated form). */
+  toString() {
+    const bytes = _Uuid.bigIntToBytes(this.__uuid__);
+    const hex = [...bytes].map((b) => b.toString(16).padStart(2, "0")).join("");
+    return hex.slice(0, 8) + "-" + hex.slice(8, 12) + "-" + hex.slice(12, 16) + "-" + hex.slice(16, 20) + "-" + hex.slice(20);
+  }
+  /** Convert to bigint (u128). */
+  asBigInt() {
+    return this.__uuid__;
+  }
+  /** Return a `Uint8Array` of 16 bytes. */
+  toBytes() {
+    return _Uuid.bigIntToBytes(this.__uuid__);
+  }
+  static bytesToBigInt(bytes) {
+    let result = 0n;
+    for (const b of bytes) result = result << 8n | BigInt(b);
+    return result;
+  }
+  static bigIntToBytes(value) {
+    const bytes = new Uint8Array(16);
+    for (let i = 15; i >= 0; i--) {
+      bytes[i] = Number(value & 0xffn);
+      value >>= 8n;
+    }
+    return bytes;
+  }
+  /**
+   * Returns the version of this UUID.
+   *
+   * This represents the algorithm used to generate the value.
+   *
+   * @returns A `UuidVersion`
+   * @throws {Error} If the version field is not recognized
+   */
+  getVersion() {
+    const version = this.toBytes()[6] >> 4 & 15;
+    switch (version) {
+      case 4:
+        return "V4";
+      case 7:
+        return "V7";
+      default:
+        if (this == _Uuid.NIL) {
+          return "Nil";
+        }
+        if (this == _Uuid.MAX) {
+          return "Max";
+        }
+        throw new Error(`Unsupported UUID version: ${version}`);
+    }
+  }
+  /**
+   * Extract the monotonic counter from a UUIDv7.
+   *
+   * Intended for testing and diagnostics.
+   * Behavior is undefined if called on a non-V7 UUID.
+   *
+   * @returns 31-bit counter value
+   */
+  getCounter() {
+    const bytes = this.toBytes();
+    const high = bytes[7];
+    const mid1 = bytes[9];
+    const mid2 = bytes[10];
+    const low = bytes[11] >>> 1;
+    return high << 23 | mid1 << 15 | mid2 << 7 | low | 0;
+  }
+  compareTo(other) {
+    if (this.__uuid__ < other.__uuid__) return -1;
+    if (this.__uuid__ > other.__uuid__) return 1;
+    return 0;
+  }
+  static getAlgebraicType() {
+    return AlgebraicType.Product({
+      elements: [
+        {
+          name: "__uuid__",
+          algebraicType: AlgebraicType.U128
+        }
+      ]
+    });
+  }
+};
 var BinaryWriter = class {
   #buffer;
   #view;
@@ -753,6 +1008,9 @@ var ProductType = {
       if (ty.elements[0].name === "__connection_id__") {
         return new ConnectionId(reader.readU128());
       }
+      if (ty.elements[0].name === "__uuid__") {
+        return new Uuid(reader.readU128());
+      }
     }
     for (const element of ty.elements) {
       result[element.name] = AlgebraicType.deserializeValue(
@@ -777,6 +1035,9 @@ var ProductType = {
       if (ty.elements[0].name === "__connection_id__") {
         return value.__connection_id__;
       }
+      if (ty.elements[0].name === "__uuid__") {
+        return value.__uuid__;
+      }
     }
     const writer = new BinaryWriter(10);
     AlgebraicType.serializeValue(writer, AlgebraicType.Product(ty), value);
@@ -797,6 +1058,29 @@ var SumType = {
       } else {
         writer.writeByte(1);
       }
+    } else if (ty.variants.length == 2 && ty.variants[0].name === "ok" && ty.variants[1].name === "err") {
+      let variantName;
+      let innerValue;
+      let index;
+      if ("ok" in value) {
+        variantName = "ok";
+        innerValue = value.ok;
+        index = 0;
+      } else {
+        variantName = "err";
+        innerValue = value.err;
+        index = 1;
+      }
+      if (index < 0) {
+        throw `Result serialization error: variant '${variantName}' not found in ${JSON.stringify(ty)}`;
+      }
+      writer.writeU8(index);
+      AlgebraicType.serializeValue(
+        writer,
+        ty.variants[index].algebraicType,
+        innerValue,
+        typespace
+      );
     } else {
       const variant = value["tag"];
       const index = ty.variants.findIndex((v) => v.name === variant);
@@ -826,6 +1110,24 @@ var SumType = {
       } else {
         throw `Can't deserialize an option type, couldn't find ${tag} tag`;
       }
+    } else if (ty.variants.length == 2 && ty.variants[0].name === "ok" && ty.variants[1].name === "err") {
+      if (tag === 0) {
+        const value = AlgebraicType.deserializeValue(
+          reader,
+          ty.variants[0].algebraicType,
+          typespace
+        );
+        return { ok: value };
+      } else if (tag === 1) {
+        const value = AlgebraicType.deserializeValue(
+          reader,
+          ty.variants[1].algebraicType,
+          typespace
+        );
+        return { err: value };
+      } else {
+        throw `Can't deserialize a result type, couldn't find ${tag} tag`;
+      }
     } else {
       const variant = ty.variants[tag];
       const value = AlgebraicType.deserializeValue(
@@ -1068,6 +1370,7 @@ function classifyMembership(where2, oldRow, newRow) {
 }
 function useTable(tableDef, whereClauseOrCallbacks, callbacks) {
   const tableName = tableDef.name;
+  const accessorName = tableDef.accessorName;
   let whereClause;
   if (whereClauseOrCallbacks && typeof whereClauseOrCallbacks === "object" && "type" in whereClauseOrCallbacks) {
     whereClause = whereClauseOrCallbacks;
@@ -1092,12 +1395,12 @@ function useTable(tableDef, whereClauseOrCallbacks, callbacks) {
     if (!connection) {
       return [[], false];
     }
-    const table = connection.db[tableName];
+    const table = connection.db[accessorName];
     const result = whereClause ? Array.from(table.iter()).filter(
       (row) => evaluate(whereClause, row)
     ) : Array.from(table.iter());
     return [result, subscribeApplied];
-  }, [connectionState, tableName, whereKey, subscribeApplied]);
+  }, [connectionState, accessorName, whereKey, subscribeApplied]);
   useEffect(() => {
     const connection = connectionState.getConnection();
     if (connectionState.isActive && connection) {
@@ -1159,7 +1462,7 @@ function useTable(tableDef, whereClauseOrCallbacks, callbacks) {
         return () => {
         };
       }
-      const table = connection.db[tableName];
+      const table = connection.db[accessorName];
       table.onInsert(onInsert);
       table.onDelete(onDelete);
       table.onUpdate?.(onUpdate);
@@ -1172,7 +1475,7 @@ function useTable(tableDef, whereClauseOrCallbacks, callbacks) {
     // eslint-disable-next-line react-hooks/exhaustive-deps
     [
       connectionState,
-      tableName,
+      accessorName,
       whereKey,
       callbacks?.onDelete,
       callbacks?.onInsert,