@riducms/admin 0.1.0

package/src/core/preferences/preference-write-queue.ts

@@ -0,0 +1,107 @@
+export type PreferenceWriteResult<Value> =
+	{ dispatched: false } | { dispatched: true; value: Value };
+
+export interface PreferenceWriteState {
+	pending: boolean;
+	hasValue: boolean;
+	value?: unknown;
+}
+
+export function preferenceOwnerID(
+	session: { collection: string; user: { id: string } } | undefined
+) {
+	return session === undefined ? "" : JSON.stringify([session.collection, session.user.id]);
+}
+
+type PreferenceWriteListener = (state: PreferenceWriteState) => void;
+
+export class PreferenceWriteQueue {
+	#queues = new Map<string, Promise<unknown>>();
+	#pending = new Map<string, number>();
+	#latest = new Map<string, unknown>();
+	#listeners = new Map<string, Set<PreferenceWriteListener>>();
+	#ownerGenerations = new Map<string, number>();
+	#ownerWrites = new Map<string, Set<Promise<unknown>>>();
+
+	enqueue<Value>(
+		key: string,
+		owner: string,
+		canDispatch: () => boolean,
+		write: () => Promise<Value>
+	): Promise<PreferenceWriteResult<Value>> {
+		const previous = this.#queues.get(key) ?? Promise.resolve();
+		const ownerGeneration = this.#ownerGenerations.get(owner) ?? 0;
+		this.#pending.set(key, (this.#pending.get(key) ?? 0) + 1);
+		this.#emit(key);
+		const queued = previous
+			.catch(() => undefined)
+			.then(async (): Promise<PreferenceWriteResult<Value>> => {
+				if ((this.#ownerGenerations.get(owner) ?? 0) !== ownerGeneration || !canDispatch()) {
+					return { dispatched: false };
+				}
+				const value = await write();
+				this.#latest.set(key, value);
+				return { dispatched: true, value };
+			});
+		this.#queues.set(key, queued);
+		const ownerWrites = this.#ownerWrites.get(owner) ?? new Set<Promise<unknown>>();
+		ownerWrites.add(queued);
+		this.#ownerWrites.set(owner, ownerWrites);
+		const settle = () => {
+			ownerWrites.delete(queued);
+			if (ownerWrites.size === 0) this.#ownerWrites.delete(owner);
+			if (this.#queues.get(key) === queued) this.#queues.delete(key);
+			const pending = (this.#pending.get(key) ?? 1) - 1;
+			if (pending === 0) this.#pending.delete(key);
+			else this.#pending.set(key, pending);
+			this.#emit(key);
+			if (pending === 0) this.#latest.delete(key);
+		};
+		void queued.then(settle, settle);
+		return queued;
+	}
+
+	isPending(key: string) {
+		return (this.#pending.get(key) ?? 0) > 0;
+	}
+
+	subscribe(key: string, listener: PreferenceWriteListener) {
+		const listeners = this.#listeners.get(key) ?? new Set<PreferenceWriteListener>();
+		listeners.add(listener);
+		this.#listeners.set(key, listeners);
+		listener(this.#state(key));
+		return () => {
+			listeners.delete(listener);
+			if (listeners.size === 0) this.#listeners.delete(key);
+		};
+	}
+
+	async settleOwner(owner: string) {
+		while ((this.#ownerWrites.get(owner)?.size ?? 0) > 0) {
+			await Promise.allSettled([...(this.#ownerWrites.get(owner) ?? [])]);
+		}
+	}
+
+	invalidateOwner(owner: string) {
+		this.#ownerGenerations.set(owner, (this.#ownerGenerations.get(owner) ?? 0) + 1);
+	}
+
+	#emit(key: string) {
+		const state = this.#state(key);
+		for (const listener of this.#listeners.get(key) ?? []) listener(state);
+	}
+
+	#state(key: string): PreferenceWriteState {
+		return {
+			pending: this.isPending(key),
+			hasValue: this.#latest.has(key),
+			value: this.#latest.get(key),
+		};
+	}
+}
+
+const preferenceWrites = new PreferenceWriteQueue();
+
+export function getPreferenceWriteQueue() {
+	return preferenceWrites;
+}

package/src/core/routing/admin-paths.ts

@@ -0,0 +1,137 @@
+export const adminRoutePatterns = {
+	home: "/",
+	createFirstUser: "/create-first-user",
+	login: "/login",
+	forgotPassword: "/forgot-password",
+	resetPassword: "/reset-password",
+	requestVerification: "/request-verification",
+	verifyEmail: "/verify-email",
+	account: "/account",
+	accountSecurity: "/account/security",
+	collection: "/collections/:collection",
+	collectionTrash: "/collections/:collection/trash",
+	collectionUpload: "/collections/:collection/upload",
+	createDocument: "/collections/:collection/create",
+	createDocumentAPI: "/collections/:collection/create/api",
+	document: "/collections/:collection/:document",
+	documentAPI: "/collections/:collection/:document/api",
+	documentVersions: "/collections/:collection/:document/versions",
+	documentVersion: "/collections/:collection/:document/versions/:revision",
+	global: "/globals/:global",
+	globalAPI: "/globals/:global/api",
+	globalVersions: "/globals/:global/versions",
+	globalVersion: "/globals/:global/versions/:revision",
+} as const;
+
+const adminAuthPaths = new Set<string>([
+	adminRoutePatterns.login,
+	adminRoutePatterns.createFirstUser,
+	adminRoutePatterns.forgotPassword,
+	adminRoutePatterns.resetPassword,
+	adminRoutePatterns.requestVerification,
+	adminRoutePatterns.verifyEmail,
+]);
+
+export function adminLoginPath(requestedPath: string): string {
+	const redirect = safeAdminRedirectPath(requestedPath);
+	return redirect === adminRoutePatterns.home
+		? adminRoutePatterns.login
+		: `${adminRoutePatterns.login}?redirect=${encodeURIComponent(redirect)}`;
+}
+
+export function adminCreateFirstUserPath(): string {
+	return adminRoutePatterns.createFirstUser;
+}
+
+export function adminRedirectFromSearch(search: string): string {
+	return safeAdminRedirectPath(new URLSearchParams(search).get("redirect"));
+}
+
+function safeAdminRedirectPath(requestedPath: string | null | undefined): string {
+	if (
+		requestedPath === null ||
+		requestedPath === undefined ||
+		!requestedPath.startsWith("/") ||
+		requestedPath.startsWith("//")
+	) {
+		return adminRoutePatterns.home;
+	}
+	try {
+		const origin = "https://ridu.invalid";
+		const target = new URL(requestedPath, origin);
+		if (target.origin !== origin || adminAuthPaths.has(target.pathname)) {
+			return adminRoutePatterns.home;
+		}
+		return `${target.pathname}${target.search}${target.hash}`;
+	} catch {
+		return adminRoutePatterns.home;
+	}
+}
+
+export function collectionPath(collection: string): string {
+	return `/collections/${encodeURIComponent(collection)}`;
+}
+
+export function globalPath(global: string): string {
+	return `/globals/${encodeURIComponent(global)}`;
+}
+
+export function createDocumentPath(collection: string): string {
+	return `${collectionPath(collection)}/create`;
+}
+
+export function createDocumentAPIPath(collection: string): string {
+	return `${createDocumentPath(collection)}/api`;
+}
+
+export function collectionTrashPath(collection: string): string {
+	return `${collectionPath(collection)}/trash`;
+}
+
+export function collectionUploadPath(collection: string): string {
+	return `${collectionPath(collection)}/upload`;
+}
+
+export function documentPath(collection: string, document: string): string {
+	return `${collectionPath(collection)}/${encodeURIComponent(document)}`;
+}
+
+export function documentIDFromAdminPath(pathname: string): string | undefined {
+	const segments = pathname.split("/");
+	if (segments[1] !== "collections" || segments[3] === undefined || segments[3] === "") {
+		return undefined;
+	}
+	try {
+		return decodeURIComponent(segments[3]);
+	} catch {
+		return undefined;
+	}
+}
+
+export function documentAPIPath(collection: string, document: string): string {
+	return `${documentPath(collection, document)}/api`;
+}
+
+export function documentVersionsPath(collection: string, document: string): string {
+	return `${documentPath(collection, document)}/versions`;
+}
+
+export function documentVersionPath(
+	collection: string,
+	document: string,
+	revision: number
+): string {
+	return `${documentVersionsPath(collection, document)}/${revision}`;
+}
+
+export function globalVersionsPath(global: string): string {
+	return `${globalPath(global)}/versions`;
+}
+
+export function globalAPIPath(global: string): string {
+	return `${globalPath(global)}/api`;
+}
+
+export function globalVersionPath(global: string, revision: number): string {
+	return `${globalVersionsPath(global)}/${revision}`;
+}