spacetimedb 2.6.0 → 2.6.1

package/src/sdk/type_utils.ts

@@ -1,19 +1,19 @@
-import type { Infer, InferTypeOfRow } from '.';
-import type { Prettify } from '../lib/type_util';
-import type { UntypedProcedureDef } from './procedures';
-import type { UntypedReducerDef } from './reducers';
-
-export type IsEmptyObject<T> = [keyof T] extends [never] ? true : false;
-export type MaybeParams<T> = IsEmptyObject<T> extends true ? [] : [params: T];
-
-export type ParamsType<R extends UntypedReducerDef> = MaybeParams<
-  Prettify<InferTypeOfRow<R['params']>>
->;
-
-export type ProcedureParamsType<P extends UntypedProcedureDef> = MaybeParams<
-  Prettify<InferTypeOfRow<P['params']>>
->;
-
-export type ProcedureReturnType<P extends UntypedProcedureDef> = Infer<
-  P['returnType']
->;
+import type { Infer, InferTypeOfParams } from '.';
+import type { Prettify } from '../lib/type_util';
+import type { UntypedProcedureDef } from './procedures';
+import type { UntypedReducerDef } from './reducers';
+
+export type IsEmptyObject<T> = [keyof T] extends [never] ? true : false;
+export type MaybeParams<T> = IsEmptyObject<T> extends true ? [] : [params: T];
+
+export type ParamsType<R extends UntypedReducerDef> = MaybeParams<
+  Prettify<InferTypeOfParams<R['params']>>
+>;
+
+export type ProcedureParamsType<P extends UntypedProcedureDef> = MaybeParams<
+  Prettify<InferTypeOfParams<P['params']>>
+>;
+
+export type ProcedureReturnType<P extends UntypedProcedureDef> = Infer<
+  P['returnType']
+>;

package/src/sdk/version.ts

@@ -1,133 +1,133 @@
-export type PrereleaseId = string | number;
-
-export type PreRelease = PrereleaseId[];
-
-// Compare pre-release identifiers according to the semver spec (https://semver.org/#spec-item-11).
-function comparePreReleases(a: PreRelease, b: PreRelease): number {
-  const len = Math.min(a.length, b.length);
-  for (let i = 0; i < len; i++) {
-    const aPart = a[i];
-    const bPart = b[i];
-    if (aPart === bPart) continue;
-    if (typeof aPart === 'number' && typeof bPart === 'number') {
-      return aPart - bPart;
-    }
-    if (typeof aPart === 'string' && typeof bPart === 'string') {
-      return aPart.localeCompare(bPart);
-    }
-    // According to item 11.4.3, numeric identifiers always have lower precedence than non-numeric identifiers.
-    // So if `a` is a string, it has higher precedence than `b`.
-    return typeof aPart === 'string' ? 1 : -1;
-  }
-  // See rule 11.4.4 in the semver spec.
-  return a.length - b.length;
-}
-
-// We don't use these, and they don't matter for version ordering, so I'm not going to parse it to spec.
-export type BuildInfo = string;
-
-// This is exported for tests.
-export class SemanticVersion {
-  major: number;
-  minor: number;
-  patch: number;
-  preRelease: PreRelease | null;
-  buildInfo: BuildInfo | null;
-
-  constructor(
-    major: number,
-    minor: number,
-    patch: number,
-    preRelease: PreRelease | null = null,
-    buildInfo: BuildInfo | null = null
-  ) {
-    this.major = major;
-    this.minor = minor;
-    this.patch = patch;
-    this.preRelease = preRelease;
-    this.buildInfo = buildInfo;
-  }
-
-  toString(): string {
-    let versionString = `${this.major}.${this.minor}.${this.patch}`;
-    if (this.preRelease) {
-      versionString += `-${this.preRelease.join('.')}`;
-    }
-    if (this.buildInfo) {
-      versionString += `+${this.buildInfo}`;
-    }
-    return versionString;
-  }
-
-  compare(other: SemanticVersion): number {
-    if (this.major !== other.major) {
-      return this.major - other.major;
-    }
-    if (this.minor !== other.minor) {
-      return this.minor - other.minor;
-    }
-    if (this.patch !== other.patch) {
-      return this.patch - other.patch;
-    }
-    if (this.preRelease && other.preRelease) {
-      return comparePreReleases(this.preRelease, other.preRelease);
-    }
-    if (this.preRelease) {
-      return -1; // The version without a pre-release is greater.
-    }
-    if (other.preRelease) {
-      return -1; // Since we don't have a pre-release, this version is greater.
-    }
-    return 0; // versions are equal
-  }
-
-  clone(): SemanticVersion {
-    return new SemanticVersion(
-      this.major,
-      this.minor,
-      this.patch,
-      this.preRelease ? [...this.preRelease] : null,
-      this.buildInfo
-    );
-  }
-
-  static parseVersionString(version: string): SemanticVersion {
-    const regex =
-      /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-([\da-zA-Z-]+(?:\.[\da-zA-Z-]+)*))?(?:\+([\da-zA-Z-]+(?:\.[\da-zA-Z-]+)*))?$/;
-    const match = version.match(regex);
-    if (!match) {
-      throw new Error(`Invalid version string: ${version}`);
-    }
-
-    const major = parseInt(match[1], 10);
-    const minor = parseInt(match[2], 10);
-    const patch = parseInt(match[3], 10);
-    const preRelease = match[4]
-      ? match[4].split('.').map(id => (isNaN(Number(id)) ? id : Number(id)))
-      : null;
-    const buildInfo = match[5] || null;
-
-    return new SemanticVersion(major, minor, patch, preRelease, buildInfo);
-  }
-}
-
-// The SDK depends on some module information that was not generated before this version.
-export const _MINIMUM_CLI_VERSION: SemanticVersion = new SemanticVersion(
-  1,
-  4,
-  0
-);
-
-export function ensureMinimumVersionOrThrow(versionString?: string): void {
-  if (versionString === undefined) {
-    throw new Error(versionErrorMessage(versionString));
-  }
-  const version = SemanticVersion.parseVersionString(versionString);
-  if (version.compare(_MINIMUM_CLI_VERSION) < 0) {
-    throw new Error(versionErrorMessage(versionString));
-  }
-}
-
-function versionErrorMessage(incompatibleVersion?: string): string {
-  return `Module code was generated with an incompatible version of the spacetimedb cli (${incompatibleVersion}). Update the cli version to at least ${_MINIMUM_CLI_VERSION.toString()} and regenerate the bindings. You can upgrade to the latest cli version by running: spacetime version upgrade`;
-}
+export type PrereleaseId = string | number;
+
+export type PreRelease = PrereleaseId[];
+
+// Compare pre-release identifiers according to the semver spec (https://semver.org/#spec-item-11).
+function comparePreReleases(a: PreRelease, b: PreRelease): number {
+  const len = Math.min(a.length, b.length);
+  for (let i = 0; i < len; i++) {
+    const aPart = a[i];
+    const bPart = b[i];
+    if (aPart === bPart) continue;
+    if (typeof aPart === 'number' && typeof bPart === 'number') {
+      return aPart - bPart;
+    }
+    if (typeof aPart === 'string' && typeof bPart === 'string') {
+      return aPart.localeCompare(bPart);
+    }
+    // According to item 11.4.3, numeric identifiers always have lower precedence than non-numeric identifiers.
+    // So if `a` is a string, it has higher precedence than `b`.
+    return typeof aPart === 'string' ? 1 : -1;
+  }
+  // See rule 11.4.4 in the semver spec.
+  return a.length - b.length;
+}
+
+// We don't use these, and they don't matter for version ordering, so I'm not going to parse it to spec.
+export type BuildInfo = string;
+
+// This is exported for tests.
+export class SemanticVersion {
+  major: number;
+  minor: number;
+  patch: number;
+  preRelease: PreRelease | null;
+  buildInfo: BuildInfo | null;
+
+  constructor(
+    major: number,
+    minor: number,
+    patch: number,
+    preRelease: PreRelease | null = null,
+    buildInfo: BuildInfo | null = null
+  ) {
+    this.major = major;
+    this.minor = minor;
+    this.patch = patch;
+    this.preRelease = preRelease;
+    this.buildInfo = buildInfo;
+  }
+
+  toString(): string {
+    let versionString = `${this.major}.${this.minor}.${this.patch}`;
+    if (this.preRelease) {
+      versionString += `-${this.preRelease.join('.')}`;
+    }
+    if (this.buildInfo) {
+      versionString += `+${this.buildInfo}`;
+    }
+    return versionString;
+  }
+
+  compare(other: SemanticVersion): number {
+    if (this.major !== other.major) {
+      return this.major - other.major;
+    }
+    if (this.minor !== other.minor) {
+      return this.minor - other.minor;
+    }
+    if (this.patch !== other.patch) {
+      return this.patch - other.patch;
+    }
+    if (this.preRelease && other.preRelease) {
+      return comparePreReleases(this.preRelease, other.preRelease);
+    }
+    if (this.preRelease) {
+      return -1; // The version without a pre-release is greater.
+    }
+    if (other.preRelease) {
+      return -1; // Since we don't have a pre-release, this version is greater.
+    }
+    return 0; // versions are equal
+  }
+
+  clone(): SemanticVersion {
+    return new SemanticVersion(
+      this.major,
+      this.minor,
+      this.patch,
+      this.preRelease ? [...this.preRelease] : null,
+      this.buildInfo
+    );
+  }
+
+  static parseVersionString(version: string): SemanticVersion {
+    const regex =
+      /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-([\da-zA-Z-]+(?:\.[\da-zA-Z-]+)*))?(?:\+([\da-zA-Z-]+(?:\.[\da-zA-Z-]+)*))?$/;
+    const match = version.match(regex);
+    if (!match) {
+      throw new Error(`Invalid version string: ${version}`);
+    }
+
+    const major = parseInt(match[1], 10);
+    const minor = parseInt(match[2], 10);
+    const patch = parseInt(match[3], 10);
+    const preRelease = match[4]
+      ? match[4].split('.').map(id => (isNaN(Number(id)) ? id : Number(id)))
+      : null;
+    const buildInfo = match[5] || null;
+
+    return new SemanticVersion(major, minor, patch, preRelease, buildInfo);
+  }
+}
+
+// The SDK depends on some module information that was not generated before this version.
+export const _MINIMUM_CLI_VERSION: SemanticVersion = new SemanticVersion(
+  1,
+  4,
+  0
+);
+
+export function ensureMinimumVersionOrThrow(versionString?: string): void {
+  if (versionString === undefined) {
+    throw new Error(versionErrorMessage(versionString));
+  }
+  const version = SemanticVersion.parseVersionString(versionString);
+  if (version.compare(_MINIMUM_CLI_VERSION) < 0) {
+    throw new Error(versionErrorMessage(versionString));
+  }
+}
+
+function versionErrorMessage(incompatibleVersion?: string): string {
+  return `Module code was generated with an incompatible version of the spacetimedb cli (${incompatibleVersion}). Update the cli version to at least ${_MINIMUM_CLI_VERSION.toString()} and regenerate the bindings. You can upgrade to the latest cli version by running: spacetime version upgrade`;
+}

package/src/sdk/websocket_decompress_adapter.ts

@@ -1,63 +1,63 @@
-import { decompress } from './decompress';
-import { openWebSocket, type WebSocketAdapter, type WebSocketArgs } from './ws';
-
-export class WebsocketDecompressAdapter implements WebSocketAdapter {
-  get protocol(): string {
-    return this.#ws.protocol;
-  }
-  set onclose(handler: (ev: CloseEvent) => void) {
-    this.#ws.onclose = handler;
-  }
-  set onopen(handler: () => void) {
-    this.#ws.onopen = handler;
-  }
-  set onmessage(handler: (msg: { data: Uint8Array }) => void) {
-    this.#ws.onmessage = async (msg: MessageEvent<ArrayBuffer>) => {
-      const data = await this.#decompress(new Uint8Array(msg.data));
-      handler({ data });
-    };
-  }
-  set onerror(handler: (msg: ErrorEvent) => void) {
-    this.#ws.onerror = handler as (msg: Event) => void;
-  }
-
-  #ws: WebSocket;
-
-  async #decompress(buffer: Uint8Array<ArrayBuffer>): Promise<Uint8Array> {
-    const tag = buffer[0];
-    const data = buffer.subarray(1);
-    switch (tag) {
-      case 0:
-        return data;
-      case 1:
-        // Some runtimes support brotli, but it's not yet defined in `lib.dom.d.ts`.
-        // We assert runtime support in `DbConnectionBuilder.withCompression`, so
-        // this cast is safe.
-        return await decompress(data, 'brotli' as CompressionFormat);
-      case 2:
-        return await decompress(data, 'gzip');
-      default:
-        throw new Error(
-          'Unexpected Compression Algorithm. Please use `gzip` or `none`'
-        );
-    }
-  }
-
-  send(msg: Uint8Array<ArrayBuffer>): void {
-    this.#ws.send(msg);
-  }
-
-  close(): void {
-    this.#ws.close();
-  }
-
-  constructor(ws: WebSocket) {
-    this.#ws = ws;
-  }
-
-  static async openWebSocket(
-    args: WebSocketArgs
-  ): Promise<WebsocketDecompressAdapter> {
-    return new WebsocketDecompressAdapter(await openWebSocket(args));
-  }
-}
+import { decompress } from './decompress';
+import { openWebSocket, type WebSocketAdapter, type WebSocketArgs } from './ws';
+
+export class WebsocketDecompressAdapter implements WebSocketAdapter {
+  get protocol(): string {
+    return this.#ws.protocol;
+  }
+  set onclose(handler: (ev: CloseEvent) => void) {
+    this.#ws.onclose = handler;
+  }
+  set onopen(handler: () => void) {
+    this.#ws.onopen = handler;
+  }
+  set onmessage(handler: (msg: { data: Uint8Array }) => void) {
+    this.#ws.onmessage = async (msg: MessageEvent<ArrayBuffer>) => {
+      const data = await this.#decompress(new Uint8Array(msg.data));
+      handler({ data });
+    };
+  }
+  set onerror(handler: (msg: ErrorEvent) => void) {
+    this.#ws.onerror = handler as (msg: Event) => void;
+  }
+
+  #ws: WebSocket;
+
+  async #decompress(buffer: Uint8Array<ArrayBuffer>): Promise<Uint8Array> {
+    const tag = buffer[0];
+    const data = buffer.subarray(1);
+    switch (tag) {
+      case 0:
+        return data;
+      case 1:
+        // Some runtimes support brotli, but it's not yet defined in `lib.dom.d.ts`.
+        // We assert runtime support in `DbConnectionBuilder.withCompression`, so
+        // this cast is safe.
+        return await decompress(data, 'brotli' as CompressionFormat);
+      case 2:
+        return await decompress(data, 'gzip');
+      default:
+        throw new Error(
+          'Unexpected Compression Algorithm. Please use `gzip` or `none`'
+        );
+    }
+  }
+
+  send(msg: Uint8Array<ArrayBuffer>): void {
+    this.#ws.send(msg);
+  }
+
+  close(): void {
+    this.#ws.close();
+  }
+
+  constructor(ws: WebSocket) {
+    this.#ws = ws;
+  }
+
+  static async openWebSocket(
+    args: WebSocketArgs
+  ): Promise<WebsocketDecompressAdapter> {
+    return new WebsocketDecompressAdapter(await openWebSocket(args));
+  }
+}

package/src/sdk/websocket_protocols.ts

@@ -1,25 +1,25 @@
-import { stdbLogger } from './logger.ts';
-
-export const V2_WS_PROTOCOL = 'v2.bsatn.spacetimedb';
-export const V3_WS_PROTOCOL = 'v3.bsatn.spacetimedb';
-export const PREFERRED_WS_PROTOCOLS = [V3_WS_PROTOCOL, V2_WS_PROTOCOL] as const;
-
-export type NegotiatedWsProtocol =
-  | typeof V2_WS_PROTOCOL
-  | typeof V3_WS_PROTOCOL;
-
-export function normalizeWsProtocol(protocol: string): NegotiatedWsProtocol {
-  if (protocol === V3_WS_PROTOCOL) {
-    return V3_WS_PROTOCOL;
-  }
-  // We treat an empty negotiated subprotocol as legacy v2 for compatibility.
-  if (protocol === '' || protocol === V2_WS_PROTOCOL) {
-    return V2_WS_PROTOCOL;
-  }
-
-  stdbLogger(
-    'warn',
-    `Unexpected websocket subprotocol "${protocol}", falling back to ${V2_WS_PROTOCOL}.`
-  );
-  return V2_WS_PROTOCOL;
-}
+import { stdbLogger } from './logger.ts';
+
+export const V2_WS_PROTOCOL = 'v2.bsatn.spacetimedb';
+export const V3_WS_PROTOCOL = 'v3.bsatn.spacetimedb';
+export const PREFERRED_WS_PROTOCOLS = [V3_WS_PROTOCOL, V2_WS_PROTOCOL] as const;
+
+export type NegotiatedWsProtocol =
+  | typeof V2_WS_PROTOCOL
+  | typeof V3_WS_PROTOCOL;
+
+export function normalizeWsProtocol(protocol: string): NegotiatedWsProtocol {
+  if (protocol === V3_WS_PROTOCOL) {
+    return V3_WS_PROTOCOL;
+  }
+  // We treat an empty negotiated subprotocol as legacy v2 for compatibility.
+  if (protocol === '' || protocol === V2_WS_PROTOCOL) {
+    return V2_WS_PROTOCOL;
+  }
+
+  stdbLogger(
+    'warn',
+    `Unexpected websocket subprotocol "${protocol}", falling back to ${V2_WS_PROTOCOL}.`
+  );
+  return V2_WS_PROTOCOL;
+}