spacetimedb 2.2.0 → 2.4.0

package/src/server/schema.ts

@@ -1,5 +1,9 @@
 import { moduleHooks, type ModuleDefaultExport } from 'spacetime:sys@2.0';
-import { CaseConversionPolicy, Lifecycle } from '../lib/autogen/types';
+import {
+  CaseConversionPolicy,
+  Lifecycle,
+  type MethodOrAny,
+} from '../lib/autogen/types';
 import {
   type ParamsAsObject,
   type ParamsObj,
@@ -14,6 +18,14 @@ import {
 } from '../lib/schema';
 import type { UntypedTableSchema } from '../lib/table_schema';
 import { ColumnBuilder, TypeBuilder } from '../lib/type_builders';
+import {
+  Router,
+  type HandlerFn,
+  type HttpHandlerExport,
+  type HttpHandlerOpts,
+  makeHttpHandlerExport,
+  makeHttpRouterExport,
+} from './http_handlers';
 import {
   makeProcedureExport,
   type ProcedureExport,
@@ -47,10 +59,12 @@ export class SchemaInner<
 > extends ModuleContext {
   schemaType: S;
   existingFunctions = new Set<string>();
+  existingHttpHandlers = new Set<string>();
   reducers: Reducers = [];
   procedures: Procedures = [];
   views: Views = [];
   anonViews: AnonViews = [];
+  httpHandlers: HandlerFn[] = [];
   /**
    * Maps ReducerExport objects to the name of the reducer.
    * Used for resolving the reducers of scheduled tables.
@@ -60,7 +74,10 @@ export class SchemaInner<
     | ProcedureExport<UntypedSchemaDef, any, any>,
     string
   > = new Map();
+  httpHandlerExports: Map<HttpHandlerExport<UntypedSchemaDef>, string> =
+    new Map();
   pendingSchedules: PendingSchedule[] = [];
+  pendingHttpRoutes: PendingHttpRoute[] = [];
 
   constructor(getSchemaType: (ctx: SchemaInner<S>) => S) {
     super();
@@ -70,12 +87,21 @@ export class SchemaInner<
   defineFunction(name: string) {
     if (this.existingFunctions.has(name)) {
       throw new TypeError(
-        `There is already a reducer or procedure with the name '${name}'`
+        `There is already a reducer, procedure, or view with the name '${name}'`
       );
     }
     this.existingFunctions.add(name);
   }
 
+  defineHttpHandler(name: string) {
+    if (this.existingHttpHandlers.has(name)) {
+      throw new TypeError(
+        `There is already an HTTP handler with the name '${name}'`
+      );
+    }
+    this.existingHttpHandlers.add(name);
+  }
+
   resolveSchedules() {
     for (const { reducer, scheduleAtCol, tableName } of this.pendingSchedules) {
       const functionName = this.functionExports.get(reducer());
@@ -91,9 +117,30 @@ export class SchemaInner<
       });
     }
   }
+
+  resolveHttpRoutes() {
+    for (const route of this.pendingHttpRoutes) {
+      const handlerFunction = this.httpHandlerExports.get(route.handler);
+      if (handlerFunction === undefined) {
+        throw new TypeError(
+          `HTTP route for path '${route.path}' refers to a handler that was not exported.`
+        );
+      }
+      this.moduleDef.httpRoutes.push({
+        handlerFunction,
+        method: route.method,
+        path: route.path,
+      });
+    }
+  }
 }
 
 type PendingSchedule = UntypedTableSchema['schedule'] & { tableName: string };
+type PendingHttpRoute = {
+  handler: HttpHandlerExport<UntypedSchemaDef>;
+  method: MethodOrAny;
+  path: string;
+};
 
 /**
  * The Schema class represents the database schema for a SpacetimeDB application.
@@ -153,6 +200,7 @@ export class Schema<S extends UntypedSchemaDef> implements ModuleDefaultExport {
       moduleExport[registerExport](registeredSchema, name);
     }
     registeredSchema.resolveSchedules();
+    registeredSchema.resolveHttpRoutes();
     return makeHooks(registeredSchema);
   }
 
@@ -458,6 +506,27 @@ export class Schema<S extends UntypedSchemaDef> implements ModuleDefaultExport {
     return makeProcedureExport(this.#ctx, opts, params, ret, fn);
   }
 
+  httpHandler(fn: HandlerFn<S>): HttpHandlerExport<S>;
+  httpHandler(opts: HttpHandlerOpts, fn: HandlerFn<S>): HttpHandlerExport<S>;
+  httpHandler(
+    ...args: [HandlerFn<S>] | [HttpHandlerOpts, HandlerFn<S>]
+  ): HttpHandlerExport<S> {
+    let opts: HttpHandlerOpts | undefined, fn: HandlerFn<S>;
+    switch (args.length) {
+      case 1:
+        [fn] = args;
+        break;
+      case 2:
+        [opts, fn] = args;
+        break;
+    }
+    return makeHttpHandlerExport(this.#ctx, opts, fn);
+  }
+
+  httpRouter(router: Router): ModuleExport {
+    return makeHttpRouterExport(this.#ctx, router);
+  }
+
   /**
    * Bundle multiple reducers, procedures, etc into one value to export.
    * The name they will be exported with is their corresponding key in the `exports` argument.

package/src/server/sys.d.ts

@@ -37,6 +37,13 @@ declare module 'spacetime:sys@2.0' {
       timestamp: bigint,
       args: Uint8Array
     ): Uint8Array;
+
+    __call_http_handler__(
+      id: u32,
+      timestamp: bigint,
+      request: Uint8Array,
+      body: Uint8Array
+    ): [response: Uint8Array, body: Uint8Array];
   }
 
   export function register_hooks(hooks: ModuleHooks);

package/src/server/views.ts

@@ -143,6 +143,7 @@ export function registerView<
     ? AnonymousViewFn<S, Params, Ret>
     : ViewFn<S, Params, Ret>
 ) {
+  ctx.defineFunction(exportName);
   const paramsBuilder = new RowBuilder(params, toPascalCase(exportName));
 
   // Register return types if they are product types

package/src/tanstack/index.ts

@@ -13,3 +13,4 @@ export {
 export * from '../react/SpacetimeDBProvider';
 export { useSpacetimeDB } from '../react/useSpacetimeDB';
 export { useReducer } from '../react/useReducer';
+export { useProcedure } from '../react/useProcedure';

package/src/vue/index.ts

@@ -2,3 +2,4 @@ export * from './SpacetimeDBProvider.ts';
 export { useSpacetimeDB } from './useSpacetimeDB.ts';
 export { useTable } from './useTable.ts';
 export { useReducer } from './useReducer.ts';
+export { useProcedure } from './useProcedure.ts';

package/src/vue/useProcedure.ts

@@ -0,0 +1,62 @@
+import { shallowRef, watch, onUnmounted } from 'vue';
+import { useSpacetimeDB } from './useSpacetimeDB';
+import type { UntypedProcedureDef } from '../sdk/procedures';
+import type {
+  ProcedureParamsType,
+  ProcedureReturnType,
+} from '../sdk/type_utils';
+
+export function useProcedure<ProcedureDef extends UntypedProcedureDef>(
+  procedureDef: ProcedureDef
+): (
+  ...params: ProcedureParamsType<ProcedureDef>
+) => Promise<ProcedureReturnType<ProcedureDef>> {
+  const conn = useSpacetimeDB();
+  const procedureName = procedureDef.accessorName;
+
+  const queueRef = shallowRef<
+    {
+      params: ProcedureParamsType<ProcedureDef>;
+      resolve: (val: any) => void;
+      reject: (err: unknown) => void;
+    }[]
+  >([]);
+
+  const stopWatch = watch(
+    () => conn.isActive,
+    () => {
+      const connection = conn.getConnection();
+      if (!connection) return;
+
+      const fn = (connection.procedures as any)[procedureName] as (
+        ...p: ProcedureParamsType<ProcedureDef>
+      ) => Promise<ProcedureReturnType<ProcedureDef>>;
+      if (queueRef.value.length) {
+        const pending = queueRef.value.splice(0);
+        for (const item of pending) {
+          fn(...item.params).then(item.resolve, item.reject);
+        }
+      }
+    },
+    { immediate: true }
+  );
+
+  onUnmounted(() => {
+    stopWatch();
+  });
+
+  return (...params: ProcedureParamsType<ProcedureDef>) => {
+    const connection = conn.getConnection();
+    if (!connection) {
+      return new Promise<ProcedureReturnType<ProcedureDef>>(
+        (resolve, reject) => {
+          queueRef.value.push({ params, resolve, reject });
+        }
+      );
+    }
+    const fn = (connection.procedures as any)[procedureName] as (
+      ...p: ProcedureParamsType<ProcedureDef>
+    ) => Promise<ProcedureReturnType<ProcedureDef>>;
+    return fn(...params);
+  };
+}

package/dist/lib/http_types.d.ts

@@ -1,2 +0,0 @@
-export { HttpHeaderPair, HttpHeaders, HttpMethod, HttpRequest, HttpResponse, HttpVersion, } from './autogen/types';
-//# sourceMappingURL=http_types.d.ts.map

package/dist/lib/http_types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"http_types.d.ts","sourceRoot":"","sources":["../../src/lib/http_types.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,cAAc,EACd,WAAW,EACX,UAAU,EACV,WAAW,EACX,YAAY,EACZ,WAAW,GACZ,MAAM,iBAAiB,CAAC"}

package/src/lib/http_types.ts

@@ -1,8 +0,0 @@
-export {
-  HttpHeaderPair,
-  HttpHeaders,
-  HttpMethod,
-  HttpRequest,
-  HttpResponse,
-  HttpVersion,
-} from './autogen/types';