spacetimedb 2.5.0 → 2.6.0

package/src/lib/constraints.ts

@@ -1,48 +1,48 @@
-import type { table, UntypedTableDef } from './table';
-import type { ColumnMetadata } from './type_builders';
-
-/**
- * A helper type to determine if all columns in an index are unique.
- */
-export type AllUnique<
-  TableDef extends UntypedTableDef,
-  Columns extends ReadonlyArray<keyof TableDef['columns']>,
-> = Columns extends readonly [
-  infer Head extends keyof TableDef['columns'],
-  ...infer Tail extends ReadonlyArray<keyof TableDef['columns']>,
-]
-  ? ColumnIsUnique<TableDef['columns'][Head]['columnMetadata']> extends true
-    ? AllUnique<TableDef, Tail>
-    : false
-  : true;
-
-/**
- * A helper type to determine if a column is unique based on its metadata.
- * A column is considered unique if it has either `isUnique` or `isPrimaryKey` set to true in its metadata.
- * @template M - The column metadata to check.
- * @returns `true` if the column is unique, otherwise `false`.
- * @example
- * ```typescript
- * type Meta1 = { isUnique: true };
- * type Meta2 = { isPrimaryKey: true };
- * type Meta3 = { isUnique: false };
- * type Meta4 = {};
- * type Result1 = ColumnIsUnique<Meta1>; // true
- * type Result2 = ColumnIsUnique<Meta2>; // true
- * type Result3 = ColumnIsUnique<Meta3>; // false
- * type Result4 = ColumnIsUnique<Meta4>; // false
- * ```
- */
-export type ColumnIsUnique<M extends ColumnMetadata<any>> = M extends
-  | { isUnique: true }
-  | { isPrimaryKey: true }
-  ? true
-  : false;
-
-/**
- * Constraint helper type used *inside* {@link table} to enforce the type
- * of constraint definitions.
- */
-export type ConstraintOpts<AllowedCol extends string> = {
-  name?: string;
-} & { constraint: 'unique'; columns: [AllowedCol] };
+import type { table, UntypedTableDef } from './table';
+import type { ColumnMetadata } from './type_builders';
+
+/**
+ * A helper type to determine if all columns in an index are unique.
+ */
+export type AllUnique<
+  TableDef extends UntypedTableDef,
+  Columns extends ReadonlyArray<keyof TableDef['columns']>,
+> = Columns extends readonly [
+  infer Head extends keyof TableDef['columns'],
+  ...infer Tail extends ReadonlyArray<keyof TableDef['columns']>,
+]
+  ? ColumnIsUnique<TableDef['columns'][Head]['columnMetadata']> extends true
+    ? AllUnique<TableDef, Tail>
+    : false
+  : true;
+
+/**
+ * A helper type to determine if a column is unique based on its metadata.
+ * A column is considered unique if it has either `isUnique` or `isPrimaryKey` set to true in its metadata.
+ * @template M - The column metadata to check.
+ * @returns `true` if the column is unique, otherwise `false`.
+ * @example
+ * ```typescript
+ * type Meta1 = { isUnique: true };
+ * type Meta2 = { isPrimaryKey: true };
+ * type Meta3 = { isUnique: false };
+ * type Meta4 = {};
+ * type Result1 = ColumnIsUnique<Meta1>; // true
+ * type Result2 = ColumnIsUnique<Meta2>; // true
+ * type Result3 = ColumnIsUnique<Meta3>; // false
+ * type Result4 = ColumnIsUnique<Meta4>; // false
+ * ```
+ */
+export type ColumnIsUnique<M extends ColumnMetadata<any>> = M extends
+  | { isUnique: true }
+  | { isPrimaryKey: true }
+  ? true
+  : false;
+
+/**
+ * Constraint helper type used *inside* {@link table} to enforce the type
+ * of constraint definitions.
+ */
+export type ConstraintOpts<AllowedCol extends string> = {
+  name?: string;
+} & { constraint: 'unique'; columns: [AllowedCol] };

package/src/lib/errors.ts

@@ -1,26 +1,26 @@
-/**
- * An error thrown by a reducer that indicates a problem to the sender.
- *
- * When this error is thrown by a reducer, the sender will be notified
- * that the reducer failed gracefully with the given message.
- */
-export class SenderError extends Error {
-  constructor(message: string) {
-    super(message);
-  }
-  get name(): string {
-    return 'SenderError';
-  }
-}
-
-/**
- * An internal reducer error returned by the server runtime.
- */
-export class InternalError extends Error {
-  constructor(message: string) {
-    super(message);
-  }
-  get name(): string {
-    return 'InternalError';
-  }
-}
+/**
+ * An error thrown by a reducer that indicates a problem to the sender.
+ *
+ * When this error is thrown by a reducer, the sender will be notified
+ * that the reducer failed gracefully with the given message.
+ */
+export class SenderError extends Error {
+  constructor(message: string) {
+    super(message);
+  }
+  get name(): string {
+    return 'SenderError';
+  }
+}
+
+/**
+ * An internal reducer error returned by the server runtime.
+ */
+export class InternalError extends Error {
+  constructor(message: string) {
+    super(message);
+  }
+  get name(): string {
+    return 'InternalError';
+  }
+}

package/src/lib/filter.ts

@@ -1,195 +1,195 @@
-import type { RowType, UntypedTableDef } from './table';
-import { Timestamp } from './timestamp';
-import { Uuid } from './uuid';
-
-export type Value = string | number | boolean | Uuid | Timestamp;
-
-export type Expr<Column extends string> =
-  | { type: 'eq'; key: Column; value: Value }
-  | { type: 'and'; children: Expr<Column>[] }
-  | { type: 'or'; children: Expr<Column>[] };
-
-export const eq = <Column extends string>(
-  key: Column,
-  value: Value
-): Expr<Column> => ({ type: 'eq', key, value });
-
-export const and = <Column extends string>(
-  ...children: Expr<Column>[]
-): Expr<Column> => {
-  const flat: Expr<Column>[] = [];
-  for (const c of children) {
-    if (!c) continue;
-    if (c.type === 'and') flat.push(...c.children);
-    else flat.push(c);
-  }
-  const pruned = flat.filter(Boolean);
-  if (pruned.length === 0) return { type: 'and', children: [] };
-  if (pruned.length === 1) return pruned[0];
-  return { type: 'and', children: pruned };
-};
-
-export const or = <Column extends string>(
-  ...children: Expr<Column>[]
-): Expr<Column> => {
-  const flat: Expr<Column>[] = [];
-  for (const c of children) {
-    if (!c) continue;
-    if (c.type === 'or') flat.push(...c.children);
-    else flat.push(c);
-  }
-  const pruned = flat.filter(Boolean);
-  if (pruned.length === 0) return { type: 'or', children: [] };
-  if (pruned.length === 1) return pruned[0];
-  return { type: 'or', children: pruned };
-};
-
-export const isEq = <Column extends string>(
-  e: Expr<Column>
-): e is Extract<Expr<Column>, { type: 'eq' }> => e.type === 'eq';
-export const isAnd = <Column extends string>(
-  e: Expr<Column>
-): e is Extract<Expr<Column>, { type: 'and' }> => e.type === 'and';
-export const isOr = <Column extends string>(
-  e: Expr<Column>
-): e is Extract<Expr<Column>, { type: 'or' }> => e.type === 'or';
-
-export function evaluate<Column extends string>(
-  expr: Expr<Column>,
-  row: Record<Column, any>
-): boolean {
-  switch (expr.type) {
-    case 'eq': {
-      // The actual value of the Column
-      const v = row[expr.key];
-      if (
-        typeof v === 'string' ||
-        typeof v === 'number' ||
-        typeof v === 'boolean'
-      ) {
-        return v === expr.value;
-      }
-      if (typeof v === 'object') {
-        // Value of the Column and passed Value are both a Uuid so do an integer comparison.
-        if (v instanceof Uuid && expr.value instanceof Uuid) {
-          return v.asBigInt() === expr.value.asBigInt();
-        }
-        // Value of the Column is a Uuid but passed Value is a String so compare them via string.
-        if (v instanceof Uuid && typeof expr.value === 'string') {
-          return v.toString() === expr.value;
-        }
-
-        if (v instanceof Timestamp) {
-          // Value of the Column and passed Value are both Timestamps so compare microseconds.
-          if (expr.value instanceof Timestamp) {
-            return v.microsSinceUnixEpoch === expr.value.microsSinceUnixEpoch;
-          }
-        }
-      }
-      return false;
-    }
-    case 'and':
-      return (
-        expr.children.length === 0 || expr.children.every(c => evaluate(c, row))
-      );
-    case 'or':
-      return (
-        expr.children.length !== 0 && expr.children.some(c => evaluate(c, row))
-      );
-  }
-}
-
-function formatValue(v: Value): string {
-  switch (typeof v) {
-    case 'string':
-      return `'${v.replace(/'/g, "''")}'`;
-    case 'number':
-      return Number.isFinite(v) ? String(v) : `'${String(v)}'`;
-    case 'boolean':
-      return v ? 'TRUE' : 'FALSE';
-    case 'object': {
-      if (v instanceof Uuid) {
-        return `'${v.toString()}'`;
-      }
-      if (v instanceof Timestamp) {
-        return `'${v.toISOString()}'`;
-      }
-
-      return '';
-    }
-  }
-}
-
-function escapeIdent(id: string): string {
-  if (/^[A-Za-z_][A-Za-z0-9_]*$/.test(id)) return id;
-  return `"${id.replace(/"/g, '""')}"`;
-}
-
-function parenthesize(s: string): string {
-  if (!s.includes(' AND ') && !s.includes(' OR ')) return s;
-  return `(${s})`;
-}
-
-export function toString<TableDef extends UntypedTableDef>(
-  tableDef: TableDef,
-  expr: Expr<ColumnsFromRow<RowType<TableDef>>>
-): string {
-  switch (expr.type) {
-    case 'eq': {
-      const key = tableDef.columns[expr.key].columnMetadata.name ?? expr.key;
-      return `${escapeIdent(key)} = ${formatValue(expr.value)}`;
-    }
-    case 'and':
-      return parenthesize(
-        expr.children.map(expr => toString(tableDef, expr)).join(' AND ')
-      );
-    case 'or':
-      return parenthesize(
-        expr.children.map(expr => toString(tableDef, expr)).join(' OR ')
-      );
-  }
-}
-
-/**
- * This is just the identity function to make things look like SQL.
- * @param expr
- * @returns
- */
-export function where<Column extends string>(expr: Expr<Column>): Expr<Column> {
-  return expr;
-}
-
-type MembershipChange = 'enter' | 'leave' | 'stayIn' | 'stayOut';
-
-export function classifyMembership<
-  Col extends string,
-  R extends Record<string, unknown>,
->(where: Expr<Col> | undefined, oldRow: R, newRow: R): MembershipChange {
-  // No filter: everything is in, so updates are always "stayIn".
-  if (!where) {
-    return 'stayIn';
-  }
-
-  const oldIn = evaluate(where, oldRow);
-  const newIn = evaluate(where, newRow);
-
-  if (oldIn && !newIn) {
-    return 'leave';
-  }
-  if (!oldIn && newIn) {
-    return 'enter';
-  }
-  if (oldIn && newIn) {
-    return 'stayIn';
-  }
-  return 'stayOut';
-}
-
-/**
- * Extracts the column names from a RowType whose values are of type Value.
- * Note that this will exclude columns that are of type object, array, etc.
- */
-export type ColumnsFromRow<R> = {
-  [K in keyof R]-?: R[K] extends Value | undefined ? K : never;
-}[keyof R] &
-  string;
+import type { RowType, UntypedTableDef } from './table';
+import { Timestamp } from './timestamp';
+import { Uuid } from './uuid';
+
+export type Value = string | number | boolean | Uuid | Timestamp;
+
+export type Expr<Column extends string> =
+  | { type: 'eq'; key: Column; value: Value }
+  | { type: 'and'; children: Expr<Column>[] }
+  | { type: 'or'; children: Expr<Column>[] };
+
+export const eq = <Column extends string>(
+  key: Column,
+  value: Value
+): Expr<Column> => ({ type: 'eq', key, value });
+
+export const and = <Column extends string>(
+  ...children: Expr<Column>[]
+): Expr<Column> => {
+  const flat: Expr<Column>[] = [];
+  for (const c of children) {
+    if (!c) continue;
+    if (c.type === 'and') flat.push(...c.children);
+    else flat.push(c);
+  }
+  const pruned = flat.filter(Boolean);
+  if (pruned.length === 0) return { type: 'and', children: [] };
+  if (pruned.length === 1) return pruned[0];
+  return { type: 'and', children: pruned };
+};
+
+export const or = <Column extends string>(
+  ...children: Expr<Column>[]
+): Expr<Column> => {
+  const flat: Expr<Column>[] = [];
+  for (const c of children) {
+    if (!c) continue;
+    if (c.type === 'or') flat.push(...c.children);
+    else flat.push(c);
+  }
+  const pruned = flat.filter(Boolean);
+  if (pruned.length === 0) return { type: 'or', children: [] };
+  if (pruned.length === 1) return pruned[0];
+  return { type: 'or', children: pruned };
+};
+
+export const isEq = <Column extends string>(
+  e: Expr<Column>
+): e is Extract<Expr<Column>, { type: 'eq' }> => e.type === 'eq';
+export const isAnd = <Column extends string>(
+  e: Expr<Column>
+): e is Extract<Expr<Column>, { type: 'and' }> => e.type === 'and';
+export const isOr = <Column extends string>(
+  e: Expr<Column>
+): e is Extract<Expr<Column>, { type: 'or' }> => e.type === 'or';
+
+export function evaluate<Column extends string>(
+  expr: Expr<Column>,
+  row: Record<Column, any>
+): boolean {
+  switch (expr.type) {
+    case 'eq': {
+      // The actual value of the Column
+      const v = row[expr.key];
+      if (
+        typeof v === 'string' ||
+        typeof v === 'number' ||
+        typeof v === 'boolean'
+      ) {
+        return v === expr.value;
+      }
+      if (typeof v === 'object') {
+        // Value of the Column and passed Value are both a Uuid so do an integer comparison.
+        if (v instanceof Uuid && expr.value instanceof Uuid) {
+          return v.asBigInt() === expr.value.asBigInt();
+        }
+        // Value of the Column is a Uuid but passed Value is a String so compare them via string.
+        if (v instanceof Uuid && typeof expr.value === 'string') {
+          return v.toString() === expr.value;
+        }
+
+        if (v instanceof Timestamp) {
+          // Value of the Column and passed Value are both Timestamps so compare microseconds.
+          if (expr.value instanceof Timestamp) {
+            return v.microsSinceUnixEpoch === expr.value.microsSinceUnixEpoch;
+          }
+        }
+      }
+      return false;
+    }
+    case 'and':
+      return (
+        expr.children.length === 0 || expr.children.every(c => evaluate(c, row))
+      );
+    case 'or':
+      return (
+        expr.children.length !== 0 && expr.children.some(c => evaluate(c, row))
+      );
+  }
+}
+
+function formatValue(v: Value): string {
+  switch (typeof v) {
+    case 'string':
+      return `'${v.replace(/'/g, "''")}'`;
+    case 'number':
+      return Number.isFinite(v) ? String(v) : `'${String(v)}'`;
+    case 'boolean':
+      return v ? 'TRUE' : 'FALSE';
+    case 'object': {
+      if (v instanceof Uuid) {
+        return `'${v.toString()}'`;
+      }
+      if (v instanceof Timestamp) {
+        return `'${v.toISOString()}'`;
+      }
+
+      return '';
+    }
+  }
+}
+
+function escapeIdent(id: string): string {
+  if (/^[A-Za-z_][A-Za-z0-9_]*$/.test(id)) return id;
+  return `"${id.replace(/"/g, '""')}"`;
+}
+
+function parenthesize(s: string): string {
+  if (!s.includes(' AND ') && !s.includes(' OR ')) return s;
+  return `(${s})`;
+}
+
+export function toString<TableDef extends UntypedTableDef>(
+  tableDef: TableDef,
+  expr: Expr<ColumnsFromRow<RowType<TableDef>>>
+): string {
+  switch (expr.type) {
+    case 'eq': {
+      const key = tableDef.columns[expr.key].columnMetadata.name ?? expr.key;
+      return `${escapeIdent(key)} = ${formatValue(expr.value)}`;
+    }
+    case 'and':
+      return parenthesize(
+        expr.children.map(expr => toString(tableDef, expr)).join(' AND ')
+      );
+    case 'or':
+      return parenthesize(
+        expr.children.map(expr => toString(tableDef, expr)).join(' OR ')
+      );
+  }
+}
+
+/**
+ * This is just the identity function to make things look like SQL.
+ * @param expr
+ * @returns
+ */
+export function where<Column extends string>(expr: Expr<Column>): Expr<Column> {
+  return expr;
+}
+
+type MembershipChange = 'enter' | 'leave' | 'stayIn' | 'stayOut';
+
+export function classifyMembership<
+  Col extends string,
+  R extends Record<string, unknown>,
+>(where: Expr<Col> | undefined, oldRow: R, newRow: R): MembershipChange {
+  // No filter: everything is in, so updates are always "stayIn".
+  if (!where) {
+    return 'stayIn';
+  }
+
+  const oldIn = evaluate(where, oldRow);
+  const newIn = evaluate(where, newRow);
+
+  if (oldIn && !newIn) {
+    return 'leave';
+  }
+  if (!oldIn && newIn) {
+    return 'enter';
+  }
+  if (oldIn && newIn) {
+    return 'stayIn';
+  }
+  return 'stayOut';
+}
+
+/**
+ * Extracts the column names from a RowType whose values are of type Value.
+ * Note that this will exclude columns that are of type object, array, etc.
+ */
+export type ColumnsFromRow<R> = {
+  [K in keyof R]-?: R[K] extends Value | undefined ? K : never;
+}[keyof R] &
+  string;