matrix-nodejs-homeserver 0.0.0-stage → 0.3.1

package/dist/http/procedure.js

@@ -0,0 +1,25 @@
+import { inputError } from "./input.js";
+//#region src/http/procedure.ts
+function procedure(def) {
+	return async (ctx) => {
+		const session = def.auth === "user" ? await ctx.auth() : def.auth === "optional" ? await ctx.optionalAuth() : void 0;
+		const extra = def.guard ? await def.guard(ctx) : {};
+		if (def.rateLimit) await ctx.rateLimit(def.rateLimit);
+		let input;
+		if (def.input) {
+			const parsed = def.input.safeParse(await ctx.json());
+			if (!parsed.success) throw inputError(parsed.error);
+			input = parsed.data;
+		}
+		const result = await def.handler(Object.assign(ctx, extra, {
+			session,
+			input
+		}));
+		if (!def.output || result instanceof Response) return result;
+		const checked = def.output.safeParse(result);
+		if (!checked.success) throw new Error(`Response does not match the output schema: ${checked.error.message}`);
+		return checked.data;
+	};
+}
+//#endregion
+export { procedure };

package/dist/http/router.d.ts

@@ -0,0 +1,43 @@
+import { Session } from "../core/auth.js";
+import { RateLimitAction } from "../core/ratelimit.js";
+import { Homeserver } from "../homeserver.js";
+//#region src/http/router.d.ts
+export type HttpMethod = "GET" | "POST" | "PUT" | "DELETE";
+export interface RequestContext {
+  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>;
+}
+export type HandlerResult = Response | object | void;
+/** What the router calls; endpoints build one with `procedure()` (see http/procedure.ts). */
+export type Handler = (ctx: RequestContext) => Promise<HandlerResult> | HandlerResult;
+export declare class Router {
+  private routes;
+  add(method: HttpMethod, path: string, handler: Handler): void;
+  get: (path: string, h: Handler) => void;
+  post: (path: string, h: Handler) => 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(method: HttpMethod, path: string, handler: Handler, versions?: string[]): void;
+  match(method: string, pathname: string): {
+    handler: Handler;
+    params: Record<string, string>;
+  } | "method" | null;
+}
+//#endregion

package/dist/http/router.js

@@ -0,0 +1,56 @@
+//#region src/http/router.ts
+var Router = class {
+	routes = [];
+	add(method, path, handler) {
+		this.routes.push({
+			method,
+			segments: path.split("/").filter(Boolean),
+			handler
+		});
+	}
+	get = (path, h) => this.add("GET", path, h);
+	post = (path, h) => this.add("POST", path, h);
+	put = (path, h) => this.add("PUT", path, h);
+	delete = (path, h) => this.add("DELETE", path, h);
+	/** Register a client-server API route under both `r0` and `v3` (or the given versions). */
+	client(method, path, handler, versions = ["r0", "v3"]) {
+		for (const v of versions) this.add(method, `/_matrix/client/${v}${path}`, handler);
+	}
+	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
+			};
+		}
+		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,26 @@
+import { ThreepidEmail, ThreepidOptions, ThreepidPurpose, ThreepidSms } from "./core/threepid.js";
+import { M, UNSTABLE } from "./core/m.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, M, 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, UNSTABLE, 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,15 @@
+import { M, UNSTABLE } from "./core/m.js";
+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, M, MatrixError, UNSTABLE, 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