matrix-nodejs-homeserver 0.0.0-stage → 0.2.0

package/dist/http/input.js

@@ -0,0 +1,24 @@
+import { MatrixError } from "../core/errors.js";
+import { z } from "zod";
+//#region src/http/input.ts
+/** A request body: a JSON object whose unknown keys are kept. */
+const body = (shape) => z.looseObject(shape);
+/**
+* Errors carry their Matrix errcode in the message, as `M_CODE: text`: `fail` builds the zod
+* error option for a field. Without one, a missing field is M_MISSING_PARAM and any other
+* problem M_BAD_JSON.
+*/
+const fail = (errcode, message, missing) => ({ error: (issue) => issue.input === void 0 && missing ? `M_MISSING_PARAM: ${missing}` : `${errcode}: ${message}` });
+/** A field that, when its value has the wrong type, is ignored (treated as absent), as Matrix clients expect for optional fields. */
+const lenient = (schema) => schema.optional().catch(void 0);
+/** Turn a failed body parse into the Matrix error the client sees. */
+function inputError(error) {
+	const issue = error.issues[0];
+	const path = issue?.path.join(".") ?? "";
+	const tagged = /^(M_[A-Z_]+): ([\s\S]*)$/.exec(issue?.message ?? "");
+	if (tagged) return new MatrixError(400, tagged[1], tagged[2]);
+	if (issue?.code === "invalid_type" && issue.input === void 0) return new MatrixError(400, "M_MISSING_PARAM", `Missing ${path || "parameter"}`);
+	return new MatrixError(400, "M_BAD_JSON", path ? `Invalid ${path}: ${issue.message}` : issue?.message ?? "Bad JSON");
+}
+//#endregion
+export { body, fail, inputError, lenient };

package/dist/http/router.d.ts

@@ -0,0 +1,60 @@
+import { Session } from "../core/auth.js";
+import { RateLimitAction } from "../core/ratelimit.js";
+import { Homeserver } from "../homeserver.js";
+import { z } from "zod";
+//#region src/http/router.d.ts
+export type HttpMethod = "GET" | "POST" | "PUT" | "DELETE";
+export interface RequestContext<I = unknown> {
+  hs: Homeserver;
+  request: Request;
+  url: URL;
+  method: string;
+  params: Record<string, string>;
+  query: URLSearchParams;
+  /** Remote address, if known. */
+  ip: string | null;
+  /** Parsed JSON body (empty object when no body was sent). */
+  json<T = any>(): Promise<T>;
+  bytes(): Promise<Uint8Array>;
+  /** Authenticate the request; throws M_MISSING_TOKEN / M_UNKNOWN_TOKEN. */
+  auth(): Promise<Session>;
+  /** Authenticate if a token was supplied. */
+  optionalAuth(): Promise<Session | null>;
+  accessToken(): string | null;
+  /** Apply the rate limit for `action` to the requesting user (or IP when unauthenticated). */
+  rateLimit(action: RateLimitAction): Promise<void>;
+  /**
+   * The request body parsed with the route's `input` schema (undefined for routes without one).
+   * Validated on first access, which throws the Matrix error for an invalid body: read it where
+   * the handler needs the body, after authenticating.
+   */
+  input: I;
+}
+export type HandlerResult = Response | object | void;
+export type Handler<I = any> = (ctx: RequestContext<I>) => Promise<HandlerResult> | HandlerResult;
+/** Per-route options. `input` validates and parses the JSON body before the handler runs. */
+export interface RouteOptions<S extends z.ZodType = z.ZodType> {
+  input?: S;
+}
+/** A route's handler, with the body type its `input` schema produces. */
+type Routed<S> = S extends z.ZodType ? Handler<z.output<S>> : Handler;
+export declare class Router {
+  private routes;
+  add<S extends z.ZodType | undefined = undefined>(method: HttpMethod, path: string, handler: Routed<S>, options?: RouteOptions<NonNullable<S>>): void;
+  get(path: string, h: Handler): void;
+  post<S extends z.ZodType>(path: string, options: RouteOptions<S>, h: Routed<S>): void;
+  post(path: string, h: Handler): void;
+  put<S extends z.ZodType>(path: string, options: RouteOptions<S>, h: Routed<S>): void;
+  put(path: string, h: Handler): void;
+  delete(path: string, h: Handler): void;
+  /** Register a client-server API route under both `r0` and `v3` (or the given versions). */
+  client<S extends z.ZodType>(method: HttpMethod, path: string, options: RouteOptions<S>, handler: Routed<S>, versions?: string[]): void;
+  client(method: HttpMethod, path: string, handler: Handler, versions?: string[]): void;
+  match(method: string, pathname: string): {
+    handler: Handler;
+    params: Record<string, string>;
+    input?: z.ZodType;
+  } | "method" | null;
+}
+//#endregion
+export {};

package/dist/http/router.js

@@ -0,0 +1,76 @@
+//#region src/http/router.ts
+var Router = class {
+	routes = [];
+	add(method, path, handler, options = {}) {
+		this.routes.push({
+			method,
+			segments: path.split("/").filter(Boolean),
+			handler,
+			input: options.input
+		});
+	}
+	get(path, h) {
+		this.add("GET", path, h);
+	}
+	post(path, a, b) {
+		if (typeof a === "function") this.add("POST", path, a);
+		else this.add("POST", path, b, a);
+	}
+	put(path, a, b) {
+		if (typeof a === "function") this.add("PUT", path, a);
+		else this.add("PUT", path, b, a);
+	}
+	delete(path, h) {
+		this.add("DELETE", path, h);
+	}
+	client(method, path, a, b, c) {
+		const [options, handler, versions] = typeof a === "function" ? [
+			{},
+			a,
+			b ?? ["r0", "v3"]
+		] : [
+			a,
+			b,
+			c ?? ["r0", "v3"]
+		];
+		for (const v of versions) this.add(method, `/_matrix/client/${v}${path}`, handler, options);
+	}
+	match(method, pathname) {
+		const parts = pathname.split("/").filter(Boolean);
+		let methodMismatch = false;
+		for (const route of this.routes) {
+			const params = matchSegments(route.segments, parts);
+			if (!params) continue;
+			if (route.method !== method) {
+				methodMismatch = true;
+				continue;
+			}
+			return {
+				handler: route.handler,
+				params,
+				input: route.input
+			};
+		}
+		return methodMismatch ? "method" : null;
+	}
+};
+function matchSegments(segments, parts) {
+	const params = {};
+	for (let i = 0; i < segments.length; i++) {
+		const seg = segments[i];
+		if (seg.startsWith("*")) {
+			params[seg.slice(1)] = parts.slice(i).map(decodeURIComponent).join("/");
+			return params;
+		}
+		if (i >= parts.length) return null;
+		if (seg.startsWith(":")) try {
+			params[seg.slice(1)] = decodeURIComponent(parts[i]);
+		} catch {
+			return null;
+		}
+		else if (seg !== parts[i]) return null;
+	}
+	return segments.length === parts.length ? params : null;
+}
+//#endregion
+export { Router };

package/dist/index.d.ts

@@ -0,0 +1,25 @@
+import { ThreepidEmail, ThreepidOptions, ThreepidPurpose, ThreepidSms } from "./core/threepid.js";
+import { AppServiceRegistration, loadAppServiceRegistrations, parseAppServiceRegistration } from "./core/appservices.js";
+import { ClusterAdapter, localCluster } from "./core/cluster.js";
+import { DatabaseAdapter, FieldDef, FindManyOptions, ModelDef, Operator, Row, Schema, WhereClause } from "./storage/types.js";
+import { AdminService, ServerNoticesOptions } from "./core/admin.js";
+import { OAuthDelegationOptions } from "./core/oauth.js";
+import { SsoOptions, SsoProvider } from "./core/sso.js";
+import { MatrixError } from "./core/errors.js";
+import { FederationOptions } from "./federation/index.js";
+import { DelayedEventsOptions } from "./core/delayed.js";
+import { RateLimitAction, RateLimitRule, RateLimiter, memoryRateLimiter } from "./core/ratelimit.js";
+import { RtcOptions, TurnOptions } from "./api/rtc.js";
+import { AuditAction, AuditEntry, AuditOptions } from "./core/audit.js";
+import { AdminRoomOptions } from "./core/adminroom.js";
+import { PasswordCheckContext, UserAuthAdapter } from "./adapters/auth.js";
+import { MediaAdapter, MediaMetadata, ThumbnailRequest, Thumbnailer, filesystemMedia, memoryMedia, sharpThumbnailer } from "./adapters/media.js";
+import { Homeserver, HomeserverOptions, Logger, createHomeserver } from "./homeserver.js";
+import { NodeHandler, getExpressHandler, getFastifyPlugin, getFetchHandler, getHonoHandler, getNodeHandler, isMatrixPath } from "./http/adapters.js";
+import { handleRequest } from "./http/handler.js";
+import { memoryAdapter } from "./storage/memory.js";
+import { MysqlPoolLike, PgPoolLike, SqlAdapterOptions, SqlDialect, SqlExecutor, SqliteDatabaseLike, mysqlAdapter, postgresAdapter, sqlAdapter, sqliteAdapter } from "./storage/sql.js";
+import { schema } from "./storage/schema.js";
+import { S3MediaOptions, s3Media } from "./adapters/s3.js";
+import { PgClusterPoolLike, RedisLike, RedisSubscriberLike, postgresCluster, redisCluster } from "./adapters/cluster.js";
+export { type AdminRoomOptions, type AdminService, type AppServiceRegistration, type AuditAction, type AuditEntry, type AuditOptions, type ClusterAdapter, type DatabaseAdapter, type DelayedEventsOptions, type FederationOptions, type FieldDef, type FindManyOptions, Homeserver, type HomeserverOptions, type Logger, MatrixError, type MediaAdapter, type MediaMetadata, type ModelDef, type MysqlPoolLike, type NodeHandler, type OAuthDelegationOptions, type Operator, type PasswordCheckContext, type PgClusterPoolLike, type PgPoolLike, type RateLimitAction, type RateLimitRule, type RateLimiter, type RedisLike, type RedisSubscriberLike, type Row, type RtcOptions, type S3MediaOptions, type Schema, type ServerNoticesOptions, type SqlAdapterOptions, type SqlDialect, type SqlExecutor, type SqliteDatabaseLike, type SsoOptions, type SsoProvider, type ThreepidEmail, type ThreepidOptions, type ThreepidPurpose, type ThreepidSms, type ThumbnailRequest, type Thumbnailer, type TurnOptions, type UserAuthAdapter, type WhereClause, createHomeserver, filesystemMedia, getExpressHandler, getFastifyPlugin, getFetchHandler, getHonoHandler, getNodeHandler, handleRequest, isMatrixPath, loadAppServiceRegistrations, localCluster, memoryAdapter, memoryMedia, memoryRateLimiter, mysqlAdapter, parseAppServiceRegistration, postgresAdapter, postgresCluster, redisCluster, s3Media, schema, sharpThumbnailer, sqlAdapter, sqliteAdapter };

package/dist/index.js

@@ -0,0 +1,14 @@
+import { MatrixError } from "./core/errors.js";
+import { localCluster } from "./core/cluster.js";
+import { loadAppServiceRegistrations, parseAppServiceRegistration } from "./core/appservices.js";
+import { memoryRateLimiter } from "./core/ratelimit.js";
+import { filesystemMedia, memoryMedia, sharpThumbnailer } from "./adapters/media.js";
+import { memoryAdapter } from "./storage/memory.js";
+import { schema } from "./storage/schema.js";
+import { handleRequest } from "./http/handler.js";
+import { Homeserver, createHomeserver } from "./homeserver.js";
+import { getExpressHandler, getFastifyPlugin, getFetchHandler, getHonoHandler, getNodeHandler, isMatrixPath } from "./http/adapters.js";
+import { mysqlAdapter, postgresAdapter, sqlAdapter, sqliteAdapter } from "./storage/sql.js";
+import { s3Media } from "./adapters/s3.js";
+import { postgresCluster, redisCluster } from "./adapters/cluster.js";
+export { Homeserver, MatrixError, createHomeserver, filesystemMedia, getExpressHandler, getFastifyPlugin, getFetchHandler, getHonoHandler, getNodeHandler, handleRequest, isMatrixPath, loadAppServiceRegistrations, localCluster, memoryAdapter, memoryMedia, memoryRateLimiter, mysqlAdapter, parseAppServiceRegistration, postgresAdapter, postgresCluster, redisCluster, s3Media, schema, sharpThumbnailer, sqlAdapter, sqliteAdapter };

package/dist/storage/memory.d.ts

@@ -0,0 +1,5 @@
+import { DatabaseAdapter } from "./types.js";
+//#region src/storage/memory.d.ts
+/** In-memory adapter. Data is lost on restart; useful for tests and development. */
+export declare function memoryAdapter(): DatabaseAdapter;
+//#endregion

package/dist/storage/memory.js

@@ -0,0 +1,122 @@
+//#region src/storage/memory.ts
+function matches(row, where = []) {
+	for (const w of where) {
+		const v = row[w.field] ?? null;
+		const target = w.value ?? null;
+		switch (w.operator ?? "eq") {
+			case "eq":
+				if (v !== target) return false;
+				break;
+			case "ne":
+				if (v === target) return false;
+				break;
+			case "lt":
+				if (!(v < target)) return false;
+				break;
+			case "lte":
+				if (!(v <= target)) return false;
+				break;
+			case "gt":
+				if (!(v > target)) return false;
+				break;
+			case "gte":
+				if (!(v >= target)) return false;
+				break;
+			case "in": if (!target.includes(v)) return false;
+		}
+	}
+	return true;
+}
+/** In-memory adapter. Data is lost on restart; useful for tests and development. */
+function memoryAdapter() {
+	const tables = /* @__PURE__ */ new Map();
+	const pks = /* @__PURE__ */ new Map();
+	const table = (model) => {
+		let t = tables.get(model);
+		if (!t) tables.set(model, t = /* @__PURE__ */ new Map());
+		return t;
+	};
+	const keyOf = (model, row) => JSON.stringify((pks.get(model) ?? Object.keys(row)).map((k) => row[k]));
+	const build = (journal) => {
+		const set = (model, key, row) => {
+			const t = table(model);
+			journal?.push({
+				model,
+				key,
+				row: t.get(key)
+			});
+			if (row === void 0) t.delete(key);
+			else t.set(key, row);
+		};
+		return {
+			async migrate(schema) {
+				for (const [name, def] of Object.entries(schema)) pks.set(name, def.primaryKey);
+			},
+			async create(model, data) {
+				const key = keyOf(model, data);
+				if (table(model).has(key)) throw new Error(`Duplicate primary key in ${model}`);
+				set(model, key, structuredClone(data));
+			},
+			async upsert(model, data) {
+				set(model, keyOf(model, data), structuredClone(data));
+			},
+			async findOne(model, where) {
+				for (const row of table(model).values()) if (matches(row, where)) return structuredClone(row);
+				return null;
+			},
+			async findMany(model, opts = {}) {
+				let rows = [...table(model).values()].filter((r) => matches(r, opts.where));
+				if (opts.sortBy) {
+					const { field, direction } = opts.sortBy;
+					const dir = direction === "asc" ? 1 : -1;
+					rows.sort((a, b) => a[field] < b[field] ? -dir : a[field] > b[field] ? dir : 0);
+				}
+				if (opts.limit !== void 0) rows = rows.slice(0, opts.limit);
+				return rows.map((r) => structuredClone(r));
+			},
+			async update(model, where, data) {
+				let count = 0;
+				for (const [key, row] of [...table(model).entries()]) {
+					if (!matches(row, where)) continue;
+					const updated = {
+						...row,
+						...structuredClone(data)
+					};
+					set(model, key, void 0);
+					set(model, keyOf(model, updated), updated);
+					count++;
+				}
+				return count;
+			},
+			async delete(model, where) {
+				let count = 0;
+				for (const [key, row] of [...table(model).entries()]) if (matches(row, where)) {
+					set(model, key, void 0);
+					count++;
+				}
+				return count;
+			},
+			async max(model, field) {
+				let max = null;
+				for (const row of table(model).values()) {
+					const v = row[field];
+					if (typeof v === "number" && (max === null || v > max)) max = v;
+				}
+				return max;
+			},
+			async transaction(fn) {
+				const log = [];
+				try {
+					return await fn(build(log));
+				} catch (err) {
+					for (const entry of log.reverse()) if (entry.row === void 0) table(entry.model).delete(entry.key);
+					else table(entry.model).set(entry.key, entry.row);
+					throw err;
+				}
+			}
+		};
+	};
+	return build(null);
+}
+//#endregion
+export { matches, memoryAdapter };

package/dist/storage/schema.d.ts

@@ -0,0 +1,4 @@
+import { Schema } from "./types.js";
+//#region src/storage/schema.d.ts
+export declare const schema: Schema;
+//#endregion