spacetimedb 2.2.0 → 2.4.0

package/dist/vue/useProcedure.d.ts

@@ -0,0 +1,4 @@
+import type { UntypedProcedureDef } from '../sdk/procedures';
+import type { ProcedureParamsType, ProcedureReturnType } from '../sdk/type_utils';
+export declare function useProcedure<ProcedureDef extends UntypedProcedureDef>(procedureDef: ProcedureDef): (...params: ProcedureParamsType<ProcedureDef>) => Promise<ProcedureReturnType<ProcedureDef>>;
+//# sourceMappingURL=useProcedure.d.ts.map

package/dist/vue/useProcedure.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useProcedure.d.ts","sourceRoot":"","sources":["../../src/vue/useProcedure.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAC7D,OAAO,KAAK,EACV,mBAAmB,EACnB,mBAAmB,EACpB,MAAM,mBAAmB,CAAC;AAE3B,wBAAgB,YAAY,CAAC,YAAY,SAAS,mBAAmB,EACnE,YAAY,EAAE,YAAY,GACzB,CACD,GAAG,MAAM,EAAE,mBAAmB,CAAC,YAAY,CAAC,KACzC,OAAO,CAAC,mBAAmB,CAAC,YAAY,CAAC,CAAC,CAiD9C"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spacetimedb",
-  "version": "2.2.0",
+  "version": "2.4.0",
   "description": "API and ABI bindings for the SpacetimeDB TypeScript module library",
   "homepage": "https://github.com/clockworklabs/SpacetimeDB#readme",
   "bugs": {

package/src/lib/autogen/types.ts

@@ -158,6 +158,15 @@ export const Lifecycle = __t.enum('Lifecycle', {
 });
 export type Lifecycle = __Infer<typeof Lifecycle>;
 
+// The tagged union or sum type for the algebraic type `MethodOrAny`.
+export const MethodOrAny = __t.enum('MethodOrAny', {
+  Any: __t.unit(),
+  get Method() {
+    return HttpMethod;
+  },
+});
+export type MethodOrAny = __Infer<typeof MethodOrAny>;
+
 // The tagged union or sum type for the algebraic type `MiscModuleExport`.
 export const MiscModuleExport = __t.enum('MiscModuleExport', {
   get TypeAlias() {
@@ -239,6 +248,20 @@ export const RawConstraintDefV9 = __t.object('RawConstraintDefV9', {
 });
 export type RawConstraintDefV9 = __Infer<typeof RawConstraintDefV9>;
 
+export const RawHttpHandlerDefV10 = __t.object('RawHttpHandlerDefV10', {
+  sourceName: __t.string(),
+});
+export type RawHttpHandlerDefV10 = __Infer<typeof RawHttpHandlerDefV10>;
+
+export const RawHttpRouteDefV10 = __t.object('RawHttpRouteDefV10', {
+  handlerFunction: __t.string(),
+  get method() {
+    return MethodOrAny;
+  },
+  path: __t.string(),
+});
+export type RawHttpRouteDefV10 = __Infer<typeof RawHttpRouteDefV10>;
+
 // The tagged union or sum type for the algebraic type `RawIndexAlgorithm`.
 export const RawIndexAlgorithm = __t.enum('RawIndexAlgorithm', {
   BTree: __t.array(__t.u16()),
@@ -358,6 +381,12 @@ export const RawModuleDefV10Section = __t.enum('RawModuleDefV10Section', {
   get ExplicitNames() {
     return ExplicitNames;
   },
+  get HttpHandlers() {
+    return __t.array(RawHttpHandlerDefV10);
+  },
+  get HttpRoutes() {
+    return __t.array(RawHttpRouteDefV10);
+  },
 });
 export type RawModuleDefV10Section = __Infer<typeof RawModuleDefV10Section>;
 

package/src/lib/reducers.ts

@@ -103,6 +103,8 @@ export interface JwtClaims {
  */
 export type ReducerCtx<SchemaDef extends UntypedSchemaDef> = Readonly<{
   sender: Identity;
+  databaseIdentity: Identity;
+  /** @deprecated Use `databaseIdentity` instead. */
   identity: Identity;
   timestamp: Timestamp;
   connectionId: ConnectionId | null;

package/src/lib/schema.ts

@@ -195,6 +195,8 @@ export class ModuleContext {
     procedures: [],
     views: [],
     lifeCycleReducers: [],
+    httpHandlers: [],
+    httpRoutes: [],
     caseConversionPolicy: { tag: 'SnakeCase' },
     explicitNames: {
       entries: [],
@@ -227,6 +229,18 @@ export class ModuleContext {
         value: module.lifeCycleReducers,
       }
     );
+    push(
+      module.httpHandlers && {
+        tag: 'HttpHandlers',
+        value: module.httpHandlers,
+      }
+    );
+    push(
+      module.httpRoutes && {
+        tag: 'HttpRoutes',
+        value: module.httpRoutes,
+      }
+    );
     push(
       module.rowLevelSecurity && {
         tag: 'RowLevelSecurity',

package/src/sdk/decompress.ts

@@ -28,9 +28,24 @@ export async function decompress(
   const decompressedStream = readableStream.pipeThrough(decompressionStream);
 
   // Collect the decompressed chunks efficiently
-  const chunks = [];
-  for await (const chunk of decompressedStream) {
-    chunks.push(chunk);
+  const reader = decompressedStream.getReader();
+  const chunks: Uint8Array[] = [];
+  let totalLength = 0;
+  let result: any;
+
+  while (!(result = await reader.read()).done) {
+    chunks.push(result.value);
+    totalLength += result.value.length;
   }
-  return new Blob(chunks).bytes();
+
+  // Allocate a single Uint8Array for the decompressed data
+  const decompressedArray = new Uint8Array(totalLength);
+  let chunkOffset = 0;
+
+  for (const chunk of chunks) {
+    decompressedArray.set(chunk, chunkOffset);
+    chunkOffset += chunk.length;
+  }
+
+  return decompressedArray;
 }

package/src/sdk/logger.ts

@@ -73,7 +73,7 @@ const SENSITIVE_KEYS = new Set([
 ]);
 
 export const stringify = (value: unknown): string | undefined =>
-  ssStringify(value, (key, current) => {
+  ssStringify(value, (key: string, current: unknown) => {
     if (SENSITIVE_KEYS.has(key)) {
       return '[REDACTED]';
     }

package/src/server/http.test-d.ts

@@ -0,0 +1,80 @@
+import { table } from '../lib/table';
+import t from '../lib/type_builders';
+import {
+  type HandlerContext,
+  Request,
+  SyncResponse,
+  Router,
+  schema,
+} from './index';
+
+const person = table(
+  {},
+  {
+    id: t.u32().primaryKey(),
+    name: t.string(),
+  }
+);
+
+const stdb = schema({ person });
+
+const hello = stdb.httpHandler((ctx, req) => {
+  void ctx.identity;
+  void ctx.random;
+  req.text();
+  req.json();
+
+  ctx.withTx(tx => {
+    tx.db.person.insert({ id: 1, name: 'alice' });
+  });
+
+  return new SyncResponse('hello', {
+    headers: { 'content-type': 'text/plain' },
+    status: 200,
+  });
+});
+
+const _typedHello: (ctx: HandlerContext<any>, req: Request) => SyncResponse = (
+  ctx,
+  req
+) => {
+  void ctx.timestamp;
+  return new SyncResponse(req.text());
+};
+
+const named = stdb.httpHandler({ name: 'hello' }, (_ctx, _req) => {
+  return new SyncResponse('named');
+});
+
+const routes = stdb.httpRouter(
+  new Router()
+    .get('/hello', hello)
+    .get('/named', named)
+    .post('/hello-post', hello)
+    .nest('/api', new Router().any('/v1', hello))
+    .merge(new Router().get('', hello))
+);
+
+void routes;
+
+// @ts-expect-error handlers must return SyncResponse
+stdb.httpHandler((_ctx, _req) => 123);
+
+// @ts-expect-error handlers must take HandlerContext as the first argument
+stdb.httpHandler((_ctx: number, _req: Request) => new SyncResponse('bad'));
+
+// @ts-expect-error handlers must take a Request as the second argument
+stdb.httpHandler((_ctx, _req: number) => new SyncResponse('bad'));
+
+stdb.httpHandler((ctx, req) => {
+  // @ts-expect-error HTTP handlers do not expose sender directly
+  void ctx.sender;
+  // @ts-expect-error HTTP handlers do not expose connectionId directly
+  void ctx.connectionId;
+  // @ts-expect-error HTTP handlers do not expose db directly
+  void ctx.db;
+  return new SyncResponse(req.text());
+});
+
+// @ts-expect-error routers must reference exported http handlers, not raw functions
+new Router().get('/raw', (_ctx, _req) => new SyncResponse('bad'));

package/src/server/http.ts

@@ -1,2 +1,14 @@
-export { Headers, SyncResponse } from './http_internal';
-export type { BodyInit, HeadersInit, ResponseInit } from './http_internal';
+export {
+  type BodyInit,
+  type HeadersInit,
+  type RequestInit,
+  type ResponseInit,
+  Headers,
+  Request,
+  SyncResponse,
+  Router,
+  type HandlerContext,
+  type HandlerFn,
+  type HttpHandlerExport,
+  type HttpHandlerOpts,
+} from './http_handlers';

package/src/server/http_handlers.ts

@@ -0,0 +1,413 @@
+import type { Identity } from '../lib/identity';
+import type {
+  HttpMethod,
+  HttpVersion,
+  MethodOrAny,
+} from '../lib/autogen/types';
+import type { UntypedSchemaDef } from '../lib/schema';
+import type { Timestamp } from '../lib/timestamp';
+import type { Uuid } from '../lib/uuid';
+import type { TransactionCtx } from './procedures';
+import type { HttpClient } from './http_internal';
+import type { Random } from './rng';
+import {
+  exportContext,
+  registerExport,
+  type ModuleExport,
+  type SchemaInner,
+} from './schema';
+import {
+  Headers,
+  makeResponse,
+  SyncResponse,
+  textDecoder,
+  textEncoder,
+  type BodyInit,
+  type HeadersInit,
+  type ResponseInit,
+} from './http_shared';
+
+export { Headers };
+export { SyncResponse };
+export type { BodyInit, HeadersInit, ResponseInit };
+export { makeResponse };
+export const httpHandlerFn = Symbol('SpacetimeDB.httpHandlerFn');
+
+export interface RequestInit {
+  body?: BodyInit | null;
+  headers?: HeadersInit;
+  method?: string;
+  version?: HttpVersion;
+}
+
+type RequestInner = {
+  headers: Headers;
+  method: string;
+  uri: string;
+  version: HttpVersion;
+};
+
+type RouteSpec = {
+  handler: HttpHandlerExport<any>;
+  method: MethodOrAny;
+  path: string;
+};
+
+const ACCEPTABLE_ROUTE_PATH_CHARS_HUMAN_DESCRIPTION =
+  'ASCII lowercase letters, digits and `-_~/`';
+
+export const makeRequest = Symbol('makeRequest');
+
+function coerceRequestBody(body?: BodyInit | null): string | Uint8Array | null {
+  if (body == null) {
+    return null;
+  }
+  if (typeof body === 'string') {
+    return body;
+  }
+  return new Uint8Array(body as any);
+}
+
+function requestBodyToBytes(body: string | Uint8Array | null): Uint8Array {
+  if (body == null) {
+    return new Uint8Array();
+  }
+  if (typeof body === 'string') {
+    return textEncoder.encode(body);
+  }
+  return body;
+}
+
+function requestBodyToText(body: string | Uint8Array | null): string {
+  if (body == null) {
+    return '';
+  }
+  if (typeof body === 'string') {
+    return body;
+  }
+  return textDecoder.decode(body);
+}
+
+function characterIsAcceptableForRoutePath(c: string) {
+  return (
+    (c >= 'a' && c <= 'z') ||
+    (c >= '0' && c <= '9') ||
+    c === '-' ||
+    c === '_' ||
+    c === '~' ||
+    c === '/'
+  );
+}
+
+function assertValidPath(path: string) {
+  if (path !== '' && !path.startsWith('/')) {
+    throw new TypeError(`Route paths must start with \`/\`: ${path}`);
+  }
+  if (![...path].every(characterIsAcceptableForRoutePath)) {
+    throw new TypeError(
+      `Route paths may contain only ${ACCEPTABLE_ROUTE_PATH_CHARS_HUMAN_DESCRIPTION}: ${path}`
+    );
+  }
+}
+
+function routesOverlap(a: RouteSpec, b: RouteSpec) {
+  const methodsMatch = (left: HttpMethod, right: HttpMethod) => {
+    if (left.tag !== right.tag) {
+      return false;
+    }
+    if (left.tag === 'Extension' && right.tag === 'Extension') {
+      return left.value === right.value;
+    }
+    return true;
+  };
+
+  return (
+    a.path === b.path &&
+    (a.method.tag === 'Any' ||
+      b.method.tag === 'Any' ||
+      (a.method.tag === 'Method' &&
+        b.method.tag === 'Method' &&
+        methodsMatch(a.method.value, b.method.value)))
+  );
+}
+
+function joinPaths(prefix: string, suffix: string) {
+  if (prefix === '/') {
+    return suffix;
+  }
+  if (suffix === '/') {
+    return prefix;
+  }
+  let prefixEnd = prefix.length;
+  while (prefixEnd > 0 && prefix[prefixEnd - 1] === '/') {
+    prefixEnd--;
+  }
+
+  let suffixStart = 0;
+  while (suffixStart < suffix.length && suffix[suffixStart] === '/') {
+    suffixStart++;
+  }
+
+  const joinedPrefix = prefix.slice(0, prefixEnd);
+  const joinedSuffix = suffix.slice(suffixStart);
+  return `${joinedPrefix}/${joinedSuffix}`;
+}
+
+export class Request {
+  #body: string | Uint8Array | null;
+  #inner: RequestInner;
+
+  constructor(url: URL | string, init: RequestInit = {}) {
+    this.#body = coerceRequestBody(init.body);
+    this.#inner = {
+      headers: new Headers(init.headers as any),
+      method: init.method ?? 'GET',
+      uri: '' + url,
+      version: init.version ?? { tag: 'Http11' },
+    };
+  }
+
+  static [makeRequest](body: BodyInit | null, inner: RequestInner) {
+    const me = new Request(inner.uri);
+    me.#body = coerceRequestBody(body);
+    me.#inner = inner;
+    return me;
+  }
+
+  get headers(): Headers {
+    return this.#inner.headers;
+  }
+
+  get method(): string {
+    return this.#inner.method;
+  }
+
+  get uri(): string {
+    return this.#inner.uri;
+  }
+
+  get url(): string {
+    return this.#inner.uri;
+  }
+
+  get version(): HttpVersion {
+    return this.#inner.version;
+  }
+
+  arrayBuffer(): ArrayBuffer {
+    return this.bytes().buffer as ArrayBuffer;
+  }
+
+  bytes(): Uint8Array {
+    return requestBodyToBytes(this.#body);
+  }
+
+  json(): any {
+    return JSON.parse(this.text());
+  }
+
+  text(): string {
+    return requestBodyToText(this.#body);
+  }
+}
+
+export interface HandlerContext<S extends UntypedSchemaDef = UntypedSchemaDef> {
+  readonly timestamp: Timestamp;
+  readonly http: HttpClient;
+  readonly identity: Identity;
+  readonly random: Random;
+  withTx<T>(body: (ctx: TransactionCtx<S>) => T): T;
+  newUuidV4(): Uuid;
+  newUuidV7(): Uuid;
+}
+
+export type HandlerFn<S extends UntypedSchemaDef = UntypedSchemaDef> = (
+  ctx: HandlerContext<S>,
+  req: Request
+) => SyncResponse;
+
+export interface HttpHandlerExport<
+  S extends UntypedSchemaDef = UntypedSchemaDef,
+> extends ModuleExport {
+  [httpHandlerFn]: HandlerFn<S>;
+}
+
+const exportedHttpHandlerObjects = new WeakSet<object>();
+
+export interface HttpHandlerOpts {
+  name: string;
+}
+
+export class Router {
+  #routes: RouteSpec[];
+
+  constructor(routes: RouteSpec[] = []) {
+    this.#routes = routes;
+  }
+
+  get(path: string, handler: HttpHandlerExport<any>) {
+    return this.addRoute(
+      { tag: 'Method', value: { tag: 'Get' } },
+      path,
+      handler
+    );
+  }
+
+  head(path: string, handler: HttpHandlerExport<any>) {
+    return this.addRoute(
+      { tag: 'Method', value: { tag: 'Head' } },
+      path,
+      handler
+    );
+  }
+
+  options(path: string, handler: HttpHandlerExport<any>) {
+    return this.addRoute(
+      { tag: 'Method', value: { tag: 'Options' } },
+      path,
+      handler
+    );
+  }
+
+  put(path: string, handler: HttpHandlerExport<any>) {
+    return this.addRoute(
+      { tag: 'Method', value: { tag: 'Put' } },
+      path,
+      handler
+    );
+  }
+
+  delete(path: string, handler: HttpHandlerExport<any>) {
+    return this.addRoute(
+      { tag: 'Method', value: { tag: 'Delete' } },
+      path,
+      handler
+    );
+  }
+
+  post(path: string, handler: HttpHandlerExport<any>) {
+    return this.addRoute(
+      { tag: 'Method', value: { tag: 'Post' } },
+      path,
+      handler
+    );
+  }
+
+  patch(path: string, handler: HttpHandlerExport<any>) {
+    return this.addRoute(
+      { tag: 'Method', value: { tag: 'Patch' } },
+      path,
+      handler
+    );
+  }
+
+  any(path: string, handler: HttpHandlerExport<any>) {
+    return this.addRoute({ tag: 'Any' }, path, handler);
+  }
+
+  nest(path: string, subRouter: Router) {
+    assertValidPath(path);
+    if (this.#routes.some(route => route.path.startsWith(path))) {
+      throw new TypeError(
+        `Cannot nest router at \`${path}\`; existing routes overlap with nested path`
+      );
+    }
+    let merged = new Router(this.#routes);
+    for (const route of subRouter.#routes) {
+      merged = merged.addRoute(
+        route.method,
+        joinPaths(path, route.path),
+        route.handler
+      );
+    }
+    return merged;
+  }
+
+  merge(otherRouter: Router) {
+    let merged = new Router(this.#routes);
+    for (const route of otherRouter.#routes) {
+      merged = merged.addRoute(route.method, route.path, route.handler);
+    }
+    return merged;
+  }
+
+  intoRoutes() {
+    return this.#routes.slice();
+  }
+
+  private addRoute(
+    method: MethodOrAny,
+    path: string,
+    handler: HttpHandlerExport<any>
+  ) {
+    assertValidPath(path);
+    const candidate = { method, path, handler };
+    if (this.#routes.some(route => routesOverlap(route, candidate))) {
+      throw new TypeError(`Route conflict for \`${path}\``);
+    }
+    return new Router([...this.#routes, candidate]);
+  }
+}
+
+export function makeHttpHandlerExport<S extends UntypedSchemaDef>(
+  ctx: SchemaInner,
+  opts: HttpHandlerOpts | undefined,
+  fn: HandlerFn<S>
+): HttpHandlerExport<S> {
+  const handlerExport = {
+    [httpHandlerFn]: fn,
+    [exportContext]: ctx,
+    [registerExport](ctx: SchemaInner, exportName: string) {
+      if (exportedHttpHandlerObjects.has(handlerExport)) {
+        throw new TypeError(
+          `HTTP handler '${exportName}' was exported more than once`
+        );
+      }
+      exportedHttpHandlerObjects.add(handlerExport);
+      registerHttpHandler(ctx, exportName, fn, opts);
+      ctx.httpHandlerExports.set(
+        handlerExport as HttpHandlerExport<UntypedSchemaDef>,
+        exportName
+      );
+    },
+  };
+  return handlerExport as HttpHandlerExport<S>;
+}
+
+export function makeHttpRouterExport(
+  ctx: SchemaInner,
+  router: Router
+): ModuleExport {
+  return {
+    [exportContext]: ctx,
+    [registerExport](ctx: SchemaInner) {
+      ctx.pendingHttpRoutes.push(...router.intoRoutes());
+    },
+  };
+}
+
+function registerHttpHandler<S extends UntypedSchemaDef>(
+  ctx: SchemaInner,
+  exportName: string,
+  fn: HandlerFn<S>,
+  opts?: HttpHandlerOpts
+) {
+  ctx.defineHttpHandler(exportName);
+  ctx.moduleDef.httpHandlers.push({ sourceName: exportName });
+
+  if (opts?.name != null) {
+    ctx.moduleDef.explicitNames.entries.push({
+      tag: 'Function',
+      value: {
+        sourceName: exportName,
+        canonicalName: opts.name,
+      },
+    });
+  }
+
+  if (!fn.name) {
+    Object.defineProperty(fn, 'name', { value: exportName, writable: false });
+  }
+
+  ctx.httpHandlers.push(fn as HandlerFn<UntypedSchemaDef>);
+}