spacetimedb 2.2.0 → 2.4.0

package/src/server/http_internal.ts

@@ -1,133 +1,25 @@
-import { Headers, headersToList } from 'headers-polyfill';
-import status from 'statuses';
 import BinaryReader from '../lib/binary_reader';
 import BinaryWriter from '../lib/binary_writer';
-import {
-  HttpHeaders,
-  HttpMethod,
-  HttpRequest,
-  HttpResponse,
-} from '../lib/http_types';
+import status from 'statuses';
+import { HttpRequest, HttpResponse } from '../lib/autogen/types';
 import type { TimeDuration } from '../lib/time_duration';
 import { bsatnBaseSize } from '../lib/util';
+import {
+  type BodyInit,
+  type HeadersInit,
+  deserializeHeaders,
+  Headers,
+  makeResponse,
+  serializeHeaders,
+  serializeMethod,
+  SyncResponse,
+} from './http_shared';
 import { sys } from './runtime';
 
 export { Headers };
 
 const { freeze } = Object;
 
-export type BodyInit = ArrayBuffer | ArrayBufferView | string;
-export type HeadersInit = [string, string][] | Record<string, string> | Headers;
-export interface ResponseInit {
-  headers?: HeadersInit;
-  status?: number;
-  statusText?: string;
-}
-
-const textEncoder = new TextEncoder();
-const textDecoder = new TextDecoder('utf-8' /* { fatal: true } */);
-
-function deserializeHeaders(headers: HttpHeaders): Headers {
-  return new Headers(
-    headers.entries.map(({ name, value }): [string, string] => [
-      name,
-      textDecoder.decode(value),
-    ])
-  );
-}
-
-const makeResponse = Symbol('makeResponse');
-
-// based on deno's type of the same name
-interface InnerResponse {
-  type: 'basic' | 'cors' | 'default' | 'error' | 'opaque' | 'opaqueredirect';
-  url: string | null;
-  status: number;
-  statusText: string;
-  headers: Headers;
-  aborted: boolean;
-}
-
-export class SyncResponse {
-  #body: string | ArrayBuffer | null;
-  #inner: InnerResponse;
-
-  constructor(body?: BodyInit | null, init?: ResponseInit) {
-    if (body == null) {
-      this.#body = null;
-    } else if (typeof body === 'string') {
-      this.#body = body;
-    } else {
-      // this call is fine, the typings are just weird
-      this.#body = new Uint8Array<ArrayBuffer>(body as any).buffer;
-    }
-
-    // there's a type mismatch - headers-polyfill's typing doesn't expect its
-    // own `Headers` type, even though the actual code handles it correctly.
-    this.#inner = {
-      headers: new Headers(init?.headers as any),
-      status: init?.status ?? 200,
-      statusText: init?.statusText ?? '',
-      type: 'default',
-      url: null,
-      aborted: false,
-    };
-  }
-
-  static [makeResponse](body: BodyInit | null, inner: InnerResponse) {
-    const me = new SyncResponse(body);
-    me.#inner = inner;
-    return me;
-  }
-
-  get headers(): Headers {
-    return this.#inner.headers;
-  }
-  get status(): number {
-    return this.#inner.status;
-  }
-  get statusText() {
-    return this.#inner.statusText;
-  }
-  get ok(): boolean {
-    return 200 <= this.#inner.status && this.#inner.status <= 299;
-  }
-  get url(): string {
-    return this.#inner.url ?? '';
-  }
-  get type() {
-    return this.#inner.type;
-  }
-
-  arrayBuffer(): ArrayBuffer {
-    return this.bytes().buffer;
-  }
-
-  bytes(): Uint8Array<ArrayBuffer> {
-    if (this.#body == null) {
-      return new Uint8Array();
-    } else if (typeof this.#body === 'string') {
-      return textEncoder.encode(this.#body);
-    } else {
-      return new Uint8Array(this.#body);
-    }
-  }
-
-  json(): any {
-    return JSON.parse(this.text());
-  }
-
-  text(): string {
-    if (this.#body == null) {
-      return '';
-    } else if (typeof this.#body === 'string') {
-      return this.#body;
-    } else {
-      return textDecoder.decode(this.#body);
-    }
-  }
-}
-
 export interface RequestOptions {
   /** A BodyInit object or null to set request's body. */
   body?: BodyInit | null;
@@ -147,29 +39,9 @@ export interface HttpClient {
 
 const requestBaseSize = bsatnBaseSize({ types: [] }, HttpRequest.algebraicType);
 
-const methods = new Map<string, HttpMethod>([
-  ['GET', { tag: 'Get' }],
-  ['HEAD', { tag: 'Head' }],
-  ['POST', { tag: 'Post' }],
-  ['PUT', { tag: 'Put' }],
-  ['DELETE', { tag: 'Delete' }],
-  ['CONNECT', { tag: 'Connect' }],
-  ['OPTIONS', { tag: 'Options' }],
-  ['TRACE', { tag: 'Trace' }],
-  ['PATCH', { tag: 'Patch' }],
-]);
-
 function fetch(url: URL | string, init: RequestOptions = {}) {
-  const method = methods.get(init.method?.toUpperCase() ?? 'GET') ?? {
-    tag: 'Extension',
-    value: init.method!,
-  };
-  const headers: HttpHeaders = {
-    // anys because the typings are wonky - see comment in SyncResponse.constructor
-    entries: headersToList(new Headers(init.headers as any) as any)
-      .flatMap(([k, v]) => (Array.isArray(v) ? v.map(v => [k, v]) : [[k, v]]))
-      .map(([name, value]) => ({ name, value: textEncoder.encode(value) })),
-  };
+  const method = serializeMethod(init.method);
+  const headers = serializeHeaders(new Headers(init.headers as any));
   const uri = '' + url;
   const request: HttpRequest = freeze({
     method,
@@ -198,6 +70,7 @@ function fetch(url: URL | string, init: RequestOptions = {}) {
     statusText: status(response.code),
     headers: deserializeHeaders(response.headers),
     aborted: false,
+    version: response.version,
   });
 }
 

package/src/server/http_shared.ts

@@ -0,0 +1,186 @@
+import { Headers, headersToList } from 'headers-polyfill';
+import type {
+  HttpHeaders,
+  HttpMethod,
+  HttpVersion,
+} from '../lib/autogen/types';
+
+export { Headers };
+
+export type BodyInit = ArrayBuffer | ArrayBufferView | string;
+export type HeadersInit = [string, string][] | Record<string, string> | Headers;
+
+export const textEncoder = new TextEncoder();
+export const textDecoder = new TextDecoder('utf-8');
+
+export function deserializeMethod(method: HttpMethod): string {
+  switch (method.tag) {
+    case 'Get':
+      return 'GET';
+    case 'Head':
+      return 'HEAD';
+    case 'Post':
+      return 'POST';
+    case 'Put':
+      return 'PUT';
+    case 'Delete':
+      return 'DELETE';
+    case 'Connect':
+      return 'CONNECT';
+    case 'Options':
+      return 'OPTIONS';
+    case 'Trace':
+      return 'TRACE';
+    case 'Patch':
+      return 'PATCH';
+    case 'Extension':
+      return method.value;
+  }
+}
+
+const methods = new Map<string, HttpMethod>([
+  ['GET', { tag: 'Get' }],
+  ['HEAD', { tag: 'Head' }],
+  ['POST', { tag: 'Post' }],
+  ['PUT', { tag: 'Put' }],
+  ['DELETE', { tag: 'Delete' }],
+  ['CONNECT', { tag: 'Connect' }],
+  ['OPTIONS', { tag: 'Options' }],
+  ['TRACE', { tag: 'Trace' }],
+  ['PATCH', { tag: 'Patch' }],
+]);
+
+export function serializeMethod(method?: string): HttpMethod {
+  return (
+    methods.get(method?.toUpperCase() ?? 'GET') ?? {
+      tag: 'Extension',
+      value: method!,
+    }
+  );
+}
+
+export function serializeHeaders(headers: Headers): HttpHeaders {
+  return {
+    entries: headersToList(headers as any)
+      .flatMap(([k, v]) => (Array.isArray(v) ? v.map(v => [k, v]) : [[k, v]]))
+      .map(([name, value]) => ({ name, value: textEncoder.encode(value) })),
+  };
+}
+
+export function deserializeHeaders(headers: HttpHeaders): Headers {
+  return new Headers(
+    headers.entries.map(({ name, value }): [string, string] => [
+      name,
+      textDecoder.decode(value),
+    ])
+  );
+}
+
+export interface ResponseInit {
+  headers?: HeadersInit;
+  status?: number;
+  statusText?: string;
+  version?: HttpVersion;
+}
+
+export interface InnerResponse {
+  type: 'basic' | 'cors' | 'default' | 'error' | 'opaque' | 'opaqueredirect';
+  url: string | null;
+  status: number;
+  statusText: string;
+  headers: Headers;
+  aborted: boolean;
+  version: HttpVersion;
+}
+
+export const makeResponse = Symbol('makeResponse');
+
+export class SyncResponse {
+  #body: string | ArrayBuffer | null;
+  #inner: InnerResponse;
+
+  constructor(body?: BodyInit | null, init?: ResponseInit) {
+    if (body == null) {
+      this.#body = null;
+    } else if (typeof body === 'string') {
+      this.#body = body;
+    } else {
+      // this call is fine, the typings are just weird
+      this.#body = new Uint8Array<ArrayBuffer>(body as any).buffer;
+    }
+
+    // there's a type mismatch - headers-polyfill's typing doesn't expect its
+    // own `Headers` type, even though the actual code handles it correctly.
+    this.#inner = {
+      headers: new Headers(init?.headers as any),
+      status: init?.status ?? 200,
+      statusText: init?.statusText ?? '',
+      type: 'default',
+      url: null,
+      aborted: false,
+      version: init?.version ?? { tag: 'Http11' },
+    };
+  }
+
+  static [makeResponse](body: BodyInit | null, inner: InnerResponse) {
+    const me = new SyncResponse(body);
+    me.#inner = inner;
+    return me;
+  }
+
+  get headers(): Headers {
+    return this.#inner.headers;
+  }
+
+  get status(): number {
+    return this.#inner.status;
+  }
+
+  get statusText() {
+    return this.#inner.statusText;
+  }
+
+  get ok(): boolean {
+    return 200 <= this.#inner.status && this.#inner.status <= 299;
+  }
+
+  get url(): string {
+    return this.#inner.url ?? '';
+  }
+
+  get type() {
+    return this.#inner.type;
+  }
+
+  get version(): HttpVersion {
+    return this.#inner.version;
+  }
+
+  arrayBuffer(): ArrayBuffer {
+    return this.bytes().buffer;
+  }
+
+  bytes(): Uint8Array<ArrayBuffer> {
+    if (this.#body == null) {
+      return new Uint8Array();
+    } else if (typeof this.#body === 'string') {
+      return textEncoder.encode(this.#body);
+    } else {
+      return new Uint8Array(this.#body);
+    }
+  }
+
+  json(): any {
+    return JSON.parse(this.text());
+  }
+
+  text(): string {
+    if (this.#body == null) {
+      return '';
+    } else if (typeof this.#body === 'string') {
+      return this.#body;
+    } else {
+      return textDecoder.decode(this.#body);
+    }
+  }
+}

package/src/server/index.ts

@@ -22,5 +22,16 @@ export type { Uuid } from '../lib/uuid';
 export type { Random } from './rng';
 export type { ViewExport, ViewCtx, AnonymousViewCtx } from './views';
 export { Range, type Bound } from './range';
+export {
+  Headers,
+  Request,
+  SyncResponse,
+  Router,
+  type BodyInit,
+  type HeadersInit,
+  type RequestInit,
+  type ResponseInit,
+} from './http';
+export type { HandlerContext, HttpHandlerExport } from './http';
 
 import './polyfills'; // Ensure polyfills are loaded

package/src/server/procedures.ts

@@ -22,7 +22,7 @@ import { Uuid } from '../lib/uuid';
 import { httpClient, type HttpClient } from './http_internal';
 import type { DbView } from './db_view';
 import { makeRandom, type Random } from './rng';
-import { callUserFunction, ReducerCtxImpl, sys } from './runtime';
+import { callUserFunction, ReducerCtxImpl, runWithTx, sys } from './runtime';
 import {
   exportContext,
   registerExport,
@@ -75,6 +75,8 @@ export interface ProcedureOpts {
 
 export interface ProcedureCtx<S extends UntypedSchemaDef> {
   readonly sender: Identity;
+  readonly databaseIdentity: Identity;
+  /** @deprecated Use `databaseIdentity` instead. */
   readonly identity: Identity;
   readonly timestamp: Timestamp;
   readonly connectionId: ConnectionId | null;
@@ -195,10 +197,14 @@ const ProcedureCtxImpl = class ProcedureCtx<S extends UntypedSchemaDef>
     this.#dbView = dbView;
   }
 
-  get identity() {
+  get databaseIdentity() {
     return (this.#identity ??= new Identity(sys.identity()));
   }
 
+  get identity() {
+    return this.databaseIdentity;
+  }
+
   get random() {
     return (this.#random ??= makeRandom(this.timestamp));
   }
@@ -208,38 +214,16 @@ const ProcedureCtxImpl = class ProcedureCtx<S extends UntypedSchemaDef>
   }
 
   withTx<T>(body: (ctx: TransactionCtx<S>) => T): T {
-    const run = () => {
-      const timestamp = sys.procedure_start_mut_tx();
-
-      try {
-        const ctx: TransactionCtx<S> = new TransactionCtxImpl(
+    return runWithTx(
+      timestamp =>
+        new TransactionCtxImpl(
           this.sender,
-          new Timestamp(timestamp),
+          timestamp,
           this.connectionId,
           this.#dbView()
-        );
-        return body(ctx);
-      } catch (e) {
-        sys.procedure_abort_mut_tx();
-        throw e;
-      }
-    };
-
-    let res = run();
-    try {
-      sys.procedure_commit_mut_tx();
-      return res;
-    } catch {
-      // ignore the commit error
-    }
-    console.warn('committing anonymous transaction failed');
-    res = run();
-    try {
-      sys.procedure_commit_mut_tx();
-      return res;
-    } catch (e) {
-      throw new Error('transaction retry failed again', { cause: e });
-    }
+        ) as TransactionCtx<S>,
+      body
+    );
   }
 
   newUuidV4(): Uuid {

package/src/server/runtime.ts

@@ -27,6 +27,18 @@ import {
   type UniqueIndex,
 } from '../lib/indexes';
 import { callProcedure } from './procedures';
+import {
+  type HandlerContext,
+  Request,
+  SyncResponse,
+  makeRequest,
+} from './http_handlers';
+import { httpClient } from './http_internal';
+import {
+  deserializeHeaders,
+  deserializeMethod,
+  serializeHeaders,
+} from './http_shared';
 import {
   type AuthCtx,
   type JsonObject,
@@ -35,7 +47,7 @@ import {
 } from '../lib/reducers';
 import { type UntypedSchemaDef } from '../lib/schema';
 import { type RowType, type Table, type TableMethods } from '../lib/table';
-import { hasOwn } from '../lib/util';
+import { bsatnBaseSize, hasOwn } from '../lib/util';
 import { type AnonymousViewCtx, type ViewCtx } from './views';
 import { isRowTypedQuery, makeQueryBuilder, toSql } from './query';
 import type { DbView } from './db_view';
@@ -43,11 +55,32 @@ import { getErrorConstructor, SenderError } from './errors';
 import { Range, type Bound } from './range';
 import { makeRandom, type Random } from './rng';
 import type { SchemaInner } from './schema';
+import { HttpRequest, HttpResponse } from '../lib/autogen/types';
 
 const { freeze } = Object;
 
 export const sys = { ..._syscalls2_0, ..._syscalls2_1 };
 
+function requestFromWire(request: HttpRequest, body: Uint8Array): Request {
+  return Request[makeRequest](body, {
+    headers: deserializeHeaders(request.headers),
+    method: deserializeMethod(request.method),
+    uri: request.uri,
+    version: request.version,
+  });
+}
+
+function responseIntoWire(response: SyncResponse): [HttpResponse, Uint8Array] {
+  return [
+    {
+      headers: serializeHeaders(response.headers),
+      version: response.version,
+      code: response.status,
+    },
+    response.bytes(),
+  ];
+}
+
 export function parseJsonObject(json: string): JsonObject {
   let value: unknown;
 
@@ -221,10 +254,14 @@ export const ReducerCtxImpl = class ReducerCtx<
     me.#senderAuth = undefined;
   }
 
-  get identity() {
+  get databaseIdentity() {
     return (this.#identity ??= new Identity(sys.identity()));
   }
 
+  get identity() {
+    return this.databaseIdentity;
+  }
+
   get senderAuth() {
     return (this.#senderAuth ??= AuthCtxImpl.fromSystemTables(
       this.connectionId,
@@ -268,6 +305,38 @@ export const callUserFunction = function __spacetimedb_end_short_backtrace<
   return fn(...args);
 };
 
+export function runWithTx<T, Ctx>(
+  makeCtx: (timestamp: Timestamp) => Ctx,
+  body: (ctx: Ctx) => T
+): T {
+  const run = () => {
+    const timestamp = sys.procedure_start_mut_tx();
+
+    try {
+      return body(makeCtx(new Timestamp(timestamp)));
+    } catch (e) {
+      sys.procedure_abort_mut_tx();
+      throw e;
+    }
+  };
+
+  let res = run();
+  try {
+    sys.procedure_commit_mut_tx();
+    return res;
+  } catch {
+    // ignore the commit error
+  }
+  console.warn('committing anonymous transaction failed');
+  res = run();
+  try {
+    sys.procedure_commit_mut_tx();
+    return res;
+  } catch (e) {
+    throw new Error('transaction retry failed again', { cause: e });
+  }
+}
+
 export const makeHooks = (schema: SchemaInner): ModuleHooks =>
   new ModuleHooksImpl(schema);
 
@@ -414,11 +483,82 @@ class ModuleHooksImpl implements ModuleHooks {
       () => this.#dbView
     );
   }
+
+  __call_http_handler__(
+    id: u32,
+    timestamp: bigint,
+    request: Uint8Array,
+    body: Uint8Array
+  ): [response: Uint8Array, body: Uint8Array] {
+    const moduleCtx = this.#schema;
+    const handler = moduleCtx.httpHandlers[id];
+    const ctx = new HandlerContextImpl(
+      new Timestamp(timestamp),
+      () => this.#dbView
+    );
+    const requestMetadata = HttpRequest.deserialize(new BinaryReader(request));
+    const response = callUserFunction(
+      handler,
+      ctx,
+      requestFromWire(requestMetadata, body)
+    );
+    const [responseMetadata, responseBody] = responseIntoWire(response);
+    const responseBuf = new BinaryWriter(
+      bsatnBaseSize(moduleCtx.typespace, HttpResponse.algebraicType)
+    );
+    HttpResponse.serialize(responseBuf, responseMetadata);
+    return [responseBuf.getBuffer(), responseBody];
+  }
 }
 
 const BINARY_WRITER = new BinaryWriter(0);
 const BINARY_READER = new BinaryReader(new Uint8Array());
 
+class HandlerContextImpl<S extends UntypedSchemaDef = UntypedSchemaDef>
+  implements HandlerContext<S>
+{
+  #identity: Identity | undefined;
+  #uuidCounter: { value: number } | undefined;
+  #random: Random | undefined;
+  #dbView: () => DbView<any>;
+
+  readonly http = httpClient;
+
+  constructor(
+    readonly timestamp: Timestamp,
+    dbView: () => DbView<any>
+  ) {
+    this.#dbView = dbView;
+  }
+
+  get identity() {
+    return (this.#identity ??= new Identity(sys.identity()));
+  }
+
+  get random() {
+    return (this.#random ??= makeRandom(this.timestamp));
+  }
+
+  withTx<T>(body: (ctx: any) => T): T {
+    return runWithTx(
+      timestamp =>
+        new ReducerCtxImpl(Identity.zero(), timestamp, null, this.#dbView()),
+      body
+    );
+  }
+
+  newUuidV4(): Uuid {
+    const bytes = this.random.fill(new Uint8Array(16));
+    return Uuid.fromRandomBytesV4(bytes);
+  }
+
+  newUuidV7(): Uuid {
+    const bytes = this.random.fill(new Uint8Array(4));
+    const counter = (this.#uuidCounter ??= { value: 0 });
+    return Uuid.fromCounterV7(counter, this.timestamp, bytes);
+  }
+}
+
 function makeTableView(
   typespace: Typespace,
   table: RawTableDefV10