feat: sqlite

Author: jog1t

packages/core/src/client/worker-common.ts

@@ -2,16 +2,6 @@ import type {
 	AnyWorkerDefinition,
 	WorkerDefinition,
 } from "@/worker/definition";
-import type * as protoHttpResolve from "@/worker/protocol/http/resolve";
-import type { Encoding } from "@/worker/protocol/serde";
-import type { WorkerQuery } from "@/manager/protocol/query";
-import { logger } from "./log";
-import * as errors from "./errors";
-import { sendHttpRequest } from "./utils";
-import {
-	HEADER_WORKER_QUERY,
-	HEADER_ENCODING,
-} from "@/worker/router-endpoints";
 
 /**
  * Action function returned by Worker connections and handles.
@@ -33,7 +23,8 @@ export type WorkerActionFunction<
  * Maps action methods from worker definition to typed function signatures.
  */
 export type WorkerDefinitionActions<AD extends AnyWorkerDefinition> =
-	AD extends WorkerDefinition<any, any, any, any, any, any, infer R>
+	// biome-ignore lint/suspicious/noExplicitAny: safe to use any here
+	AD extends WorkerDefinition<any, any, any, any, infer R, any, any, any>
 		? {
 				[K in keyof R]: R[K] extends (...args: infer Args) => infer Return
 					? WorkerActionFunction<Args, Return>

packages/core/src/registry/config.ts

@@ -5,7 +5,7 @@ import { z } from "zod";
 
 export const WorkersSchema = z.record(
 	z.string(),
-	z.custom<WorkerDefinition<any, any, any, any, any, any, any>>(),
+	z.custom<WorkerDefinition<any, any, any, any, any, any, any, any>>(),
 );
 export type RegistryWorkers = z.infer<typeof WorkersSchema>;
 
@@ -21,6 +21,7 @@ export const RegistryConfigSchema = z.object({
 	 * Test configuration.
 	 *
 	 * DO NOT MANUALLY ENABLE. THIS IS USED INTERNALLY.
+	 * @internal
 	 **/
 	test: TestConfigSchema.optional().default({ enabled: false }),
 });

packages/core/src/worker/action.ts

@@ -1,20 +1,18 @@
-import type { AnyWorkerInstance } from "./instance";
 import type { Conn } from "./connection";
 import type { Logger } from "@/common/log";
 import type { WorkerKey } from "@/common/utils";
 import type { Schedule } from "./schedule";
 import type { ConnId } from "./connection";
 import type { SaveStateOptions } from "./instance";
-import { Actions } from "./config";
-import { WorkerContext } from "./context";
+import type { WorkerContext } from "./context";
 
 /**
  * Context for a remote procedure call.
  *
  * @typeParam A Worker this action belongs to
  */
-export class ActionContext<S, CP, CS, V, I, AD> {
-	#workerContext: WorkerContext<S, CP, CS, V, I, AD>;
+export class ActionContext<S, CP, CS, V, I, AD, DB> {
+	#workerContext: WorkerContext<S, CP, CS, V, I, AD, DB>;
 
 	/**
 	 * Should not be called directly.
@@ -23,8 +21,8 @@ export class ActionContext<S, CP, CS, V, I, AD> {
 	 * @param conn - The connection associated with the action
 	 */
 	constructor(
-		workerContext: WorkerContext<S, CP, CS, V, I, AD>,
-		public readonly conn: Conn<S, CP, CS, V, I, AD>,
+		workerContext: WorkerContext<S, CP, CS, V, I, AD, DB>,
+		public readonly conn: Conn<S, CP, CS, V, I, AD, DB>,
 	) {
 		this.#workerContext = workerContext;
 	}
@@ -95,10 +93,17 @@ export class ActionContext<S, CP, CS, V, I, AD> {
 	/**
 	 * Gets the map of connections.
 	 */
-	get conns(): Map<ConnId, Conn<S, CP, CS, V, I, AD>> {
+	get conns(): Map<ConnId, Conn<S, CP, CS, V, I, AD, DB>> {
 		return this.#workerContext.conns;
 	}
 
+	/**
+	 * @experimental
+	 */
+	get db(): DB {
+		return this.#workerContext.db;
+	}
+
 	/**
 	 * Forces the state to get saved.
 	 */

packages/core/src/worker/config.ts

@@ -24,6 +24,7 @@ export const WorkerConfigSchema = z
 		connState: z.any().optional(),
 		createConnState: z.function().optional(),
 		vars: z.any().optional(),
+		db: z.any().optional(),
 		createVars: z.function().optional(),
 		options: z
 			.object({
@@ -98,11 +99,19 @@ export interface OnConnectOptions<CP> {
 // This must have only one or the other or else S will not be able to be inferred
 //
 // Data returned from this handler will be available on `c.state`.
-type CreateState<S, CP, CS, V, I, AD> =
+type CreateState<S, CP, CS, V, I, AD, DB> =
 	| { state: S }
 	| {
 			createState: (
-				c: WorkerContext<undefined, undefined, undefined, undefined, undefined, undefined>,
+				c: WorkerContext<
+					undefined,
+					undefined,
+					undefined,
+					undefined,
+					undefined,
+					undefined,
+					undefined
+				>,
 				opts: CreateStateOptions<I>,
 			) => S | Promise<S>;
 	  }
@@ -113,11 +122,19 @@ type CreateState<S, CP, CS, V, I, AD> =
 // This must have only one or the other or else S will not be able to be inferred
 //
 // Data returned from this handler will be available on `c.conn.state`.
-type CreateConnState<S, CP, CS, V, I, AD> =
+type CreateConnState<S, CP, CS, V, I, AD, DB> =
 	| { connState: CS }
 	| {
 			createConnState: (
-				c: WorkerContext<undefined, undefined, undefined, undefined, undefined, undefined>,
+				c: WorkerContext<
+					undefined,
+					undefined,
+					undefined,
+					undefined,
+					undefined,
+					undefined,
+					undefined
+				>,
 				opts: OnConnectOptions<CP>,
 			) => CS | Promise<CS>;
 	  }
@@ -129,7 +146,7 @@ type CreateConnState<S, CP, CS, V, I, AD> =
 /**
  * @experimental
  */
-type CreateVars<S, CP, CS, V, I, AD> =
+type CreateVars<S, CP, CS, V, I, AD, DB> =
 	| {
 			/**
 			 * @experimental
@@ -141,15 +158,23 @@ type CreateVars<S, CP, CS, V, I, AD> =
 			 * @experimental
 			 */
 			createVars: (
-				c: WorkerContext<undefined, undefined, undefined, undefined, undefined, undefined>,
+				c: WorkerContext<
+					undefined,
+					undefined,
+					undefined,
+					undefined,
+					undefined,
+					undefined,
+					undefined
+				>,
 				driverCtx: unknown,
 			) => V | Promise<V>;
 	  }
 	| Record<never, never>;
 
-export interface Actions<S, CP, CS, V, I, AD> {
+export interface Actions<S, CP, CS, V, I, AD, DB> {
 	[Action: string]: (
-		c: ActionContext<S, CP, CS, V, I, AD>,
+		c: ActionContext<S, CP, CS, V, I, AD, DB>,
 		...args: any[]
 	) => any;
 }
@@ -180,7 +205,8 @@ interface BaseWorkerConfig<
 	V,
 	I,
 	AD,
-	R extends Actions<S, CP, CS, V, I, AD>,
+	DB,
+	R extends Actions<S, CP, CS, V, I, AD, DB>,
 > {
 	/**
 	 * Called on the HTTP server before clients can interact with the worker.
@@ -216,7 +242,7 @@ interface BaseWorkerConfig<
 	 * This is called before any other lifecycle hooks.
 	 */
 	onCreate?: (
-		c: WorkerContext<S, CP, CS, V, I, AD>,
+		c: WorkerContext<S, CP, CS, V, I, AD, DB>,
 		opts: OnCreateOptions<I>,
 	) => void | Promise<void>;
 
@@ -228,7 +254,7 @@ interface BaseWorkerConfig<
 	 *
 	 * @returns Void or a Promise that resolves when startup is complete
 	 */
-	onStart?: (c: WorkerContext<S, CP, CS, V, I, AD>) => void | Promise<void>;
+	onStart?: (c: WorkerContext<S, CP, CS, V, I, AD, DB>) => void | Promise<void>;
 
 	/**
 	 * Called when the worker's state changes.
@@ -238,7 +264,10 @@ interface BaseWorkerConfig<
 	 *
 	 * @param newState The updated state
 	 */
-	onStateChange?: (c: WorkerContext<S, CP, CS, V, I, AD>, newState: S) => void;
+	onStateChange?: (
+		c: WorkerContext<S, CP, CS, V, I, AD, DB>,
+		newState: S,
+	) => void;
 
 	/**
 	 * Called before a client connects to the worker.
@@ -261,7 +290,7 @@ interface BaseWorkerConfig<
 	 * @throws Throw an error to reject the connection
 	 */
 	onBeforeConnect?: (
-		c: WorkerContext<S, CP, CS, V, I, AD>,
+		c: WorkerContext<S, CP, CS, V, I, AD, DB>,
 		opts: OnConnectOptions<CP>,
 	) => void | Promise<void>;
 
@@ -275,8 +304,8 @@ interface BaseWorkerConfig<
 	 * @returns Void or a Promise that resolves when connection handling is complete
 	 */
 	onConnect?: (
-		c: WorkerContext<S, CP, CS, V, I, AD>,
-		conn: Conn<S, CP, CS, V, I, AD>,
+		c: WorkerContext<S, CP, CS, V, I, AD, DB>,
+		conn: Conn<S, CP, CS, V, I, AD, DB>,
 	) => void | Promise<void>;
 
 	/**
@@ -289,8 +318,8 @@ interface BaseWorkerConfig<
 	 * @returns Void or a Promise that resolves when disconnect handling is complete
 	 */
 	onDisconnect?: (
-		c: WorkerContext<S, CP, CS, V, I, AD>,
-		conn: Conn<S, CP, CS, V, I, AD>,
+		c: WorkerContext<S, CP, CS, V, I, AD, DB>,
+		conn: Conn<S, CP, CS, V, I, AD, DB>,
 	) => void | Promise<void>;
 
 	/**
@@ -306,7 +335,7 @@ interface BaseWorkerConfig<
 	 * @returns The modified output to send to the client
 	 */
 	onBeforeActionResponse?: <Out>(
-		c: WorkerContext<S, CP, CS, V, I, AD>,
+		c: WorkerContext<S, CP, CS, V, I, AD, DB>,
 		name: string,
 		args: unknown[],
 		output: Out,
@@ -315,10 +344,19 @@ interface BaseWorkerConfig<
 	actions: R;
 }
 
+type WorkerDatabaseConfig<DB> =
+	| {
+			/**
+			 * @experimental
+			 */
+			db: DB;
+	  }
+	| Record<never, never>;
+
 // 1. Infer schema
 // 2. Omit keys that we'll manually define (because of generics)
 // 3. Define our own types that have generic constraints
-export type WorkerConfig<S, CP, CS, V, I, AD> = Omit<
+export type WorkerConfig<S, CP, CS, V, I, AD, DB> = Omit<
 	z.infer<typeof WorkerConfigSchema>,
 	| "actions"
 	| "onAuth"
@@ -335,11 +373,13 @@ export type WorkerConfig<S, CP, CS, V, I, AD> = Omit<
 	| "createConnState"
 	| "vars"
 	| "createVars"
+	| "db"
 > &
-	BaseWorkerConfig<S, CP, CS, V, I, AD, Actions<S, CP, CS, V, I, AD>> &
-	CreateState<S, CP, CS, V, I, AD> &
-	CreateConnState<S, CP, CS, V, I, AD> &
-	CreateVars<S, CP, CS, V, I, AD>;
+	BaseWorkerConfig<S, CP, CS, V, I, AD, DB, Actions<S, CP, CS, V, I, AD, DB>> &
+	CreateState<S, CP, CS, V, I, AD, DB> &
+	CreateConnState<S, CP, CS, V, I, AD, DB> &
+	CreateVars<S, CP, CS, V, I, AD, DB> &
+	WorkerDatabaseConfig<DB>;
 
 // See description on `WorkerConfig`
 export type WorkerConfigInput<
@@ -349,7 +389,8 @@ export type WorkerConfigInput<
 	V,
 	I,
 	AD,
-	R extends Actions<S, CP, CS, V, I, AD>,
+	DB,
+	R extends Actions<S, CP, CS, V, I, AD, DB>,
 > = Omit<
 	z.input<typeof WorkerConfigSchema>,
 	| "actions"
@@ -367,11 +408,13 @@ export type WorkerConfigInput<
 	| "createConnState"
 	| "vars"
 	| "createVars"
+	| "db"
 > &
-	BaseWorkerConfig<S, CP, CS, V, I, AD, R> &
-	CreateState<S, CP, CS, V, I, AD> &
-	CreateConnState<S, CP, CS, V, I, AD> &
-	CreateVars<S, CP, CS, V, I, AD>;
+	BaseWorkerConfig<S, CP, CS, V, I, AD, DB, R> &
+	CreateState<S, CP, CS, V, I, AD, DB> &
+	CreateConnState<S, CP, CS, V, I, AD, DB> &
+	CreateVars<S, CP, CS, V, I, AD, DB> &
+	WorkerDatabaseConfig<DB>;
 
 // For testing type definitions:
 export function test<
@@ -381,17 +424,19 @@ export function test<
 	V,
 	I,
 	AD,
-	R extends Actions<S, CP, CS, V, I, AD>,
+	DB,
+	R extends Actions<S, CP, CS, V, I, AD, DB>,
 >(
-	input: WorkerConfigInput<S, CP, CS, V, I, AD, R>,
-): WorkerConfig<S, CP, CS, V, I, AD> {
+	input: WorkerConfigInput<S, CP, CS, V, I, AD, DB, R>,
+): WorkerConfig<S, CP, CS, V, I, AD, DB> {
 	const config = WorkerConfigSchema.parse(input) as WorkerConfig<
 		S,
 		CP,
 		CS,
 		V,
 		I,
-		AD
+		AD,
+		DB
 	>;
 	return config;
 }