@fraqjs/plugin-conversation 0.1.0

package/dist/index.d.mts

@@ -0,0 +1,42 @@
+import { Context, Router, Session, milky } from "@fraqjs/fraq";
+
+//#region src/service.d.ts
+interface ConversationServiceOptions {
+  defaultTimeout?: number;
+  onCollision?: 'reject-incoming' | 'abort-existing';
+}
+interface ConversationContext<R> {
+  session: Session;
+  router: Router;
+  done(result: R): void;
+  abort(reason?: string): void;
+}
+interface ConversationOptions {
+  timeout?: number;
+  onUnmatched?: (raw: milky.IncomingMessage) => void | Promise<void>;
+}
+declare class ConversationService {
+  readonly defaultTimeout: number;
+  readonly onCollision: 'reject-incoming' | 'abort-existing';
+  private readonly activeConversations;
+  constructor(ctx: Context, options?: ConversationServiceOptions);
+  open<R>(session: Session, handler: (conversationContext: ConversationContext<R>) => void | Promise<void>, options?: ConversationOptions): Promise<R | null>;
+  private accept;
+  private resolve;
+  private reject;
+  private abort;
+  private settle;
+}
+//#endregion
+//#region src/error.d.ts
+declare class ConversationRejectionError extends Error {
+  constructor(reason: string);
+}
+declare class ConversationAbortionError extends Error {
+  constructor(reason: string);
+}
+//#endregion
+//#region src/index.d.ts
+declare const ConversationPlugin: import("@fraqjs/fraq").Plugin<[options: ConversationServiceOptions], import("@fraqjs/fraq").Injection | undefined, import("@fraqjs/fraq").Injection | undefined>;
+//#endregion
+export { ConversationAbortionError, ConversationContext, ConversationOptions, ConversationPlugin, ConversationRejectionError, ConversationService, ConversationServiceOptions };

package/dist/index.mjs

@@ -0,0 +1,124 @@
+import { Router, definePlugin } from "@fraqjs/fraq";
+//#region src/error.ts
+var ConversationRejectionError = class extends Error {
+	constructor(reason) {
+		super(`Conversation rejected: ${reason}`);
+		this.name = "ConversationRejectionError";
+	}
+};
+var ConversationAbortionError = class extends Error {
+	constructor(reason) {
+		super(`Conversation aborted: ${reason}`);
+		this.name = "ConversationAbortionError";
+	}
+};
+//#endregion
+//#region src/service.ts
+function conversationKey(raw) {
+	return `${raw.sender_id}:${raw.message_scene}:${raw.peer_id}`;
+}
+function assertPositiveTimeout(timeout, name) {
+	if (!Number.isFinite(timeout) || timeout <= 0) throw new RangeError(`${name} must be a positive finite number.`);
+}
+function isSame(a, b) {
+	return a.message_scene === b.message_scene && a.peer_id === b.peer_id && a.sender_id === b.sender_id && a.message_seq === b.message_seq;
+}
+var ConversationService = class {
+	defaultTimeout;
+	onCollision;
+	activeConversations = /* @__PURE__ */ new Map();
+	constructor(ctx, options) {
+		this.defaultTimeout = options?.defaultTimeout ?? 3e4;
+		assertPositiveTimeout(this.defaultTimeout, "defaultTimeout");
+		this.onCollision = options?.onCollision ?? "reject-incoming";
+		ctx.on("message_receive", ({ data }) => {
+			this.accept(data);
+		});
+	}
+	async open(session, handler, options) {
+		const timeout = options?.timeout ?? this.defaultTimeout;
+		assertPositiveTimeout(timeout, "timeout");
+		const key = conversationKey(session.raw);
+		const existing = this.activeConversations.get(key);
+		if (existing) {
+			if (this.onCollision === "reject-incoming") return Promise.reject(new ConversationRejectionError("conversation already active"));
+			this.abort(existing, "aborted due to new conversation");
+		}
+		return new Promise((resolve, reject) => {
+			const active = {
+				key,
+				session,
+				router: new Router(),
+				options,
+				resolve,
+				reject,
+				ready: Promise.resolve().then(() => handler({
+					session,
+					router: active.router,
+					done: (result) => this.resolve(active, result),
+					abort: (reason) => this.abort(active, reason)
+				})).catch((error) => {
+					this.reject(active, error);
+				}),
+				settled: false
+			};
+			active.timeoutId = setTimeout(() => {
+				this.resolve(active, null);
+			}, timeout);
+			this.activeConversations.set(key, active);
+		});
+	}
+	async accept(raw) {
+		const active = this.activeConversations.get(conversationKey(raw));
+		if (!active || active.settled) return;
+		if (isSame(active.session.raw, raw)) return;
+		await active.ready;
+		if (this.activeConversations.get(active.key) !== active || active.settled) return;
+		const session = {
+			...active.session,
+			raw
+		};
+		let matched;
+		try {
+			matched = await active.router.dispatch(session, raw);
+		} catch (error) {
+			this.reject(active, error);
+			return;
+		}
+		if (!matched && this.activeConversations.get(active.key) === active && !active.settled) try {
+			await active.options?.onUnmatched?.(raw);
+		} catch (error) {
+			this.reject(active, error);
+		}
+	}
+	resolve(active, result) {
+		this.settle(active, () => active.resolve(result));
+	}
+	reject(active, error) {
+		this.settle(active, () => active.reject(error));
+	}
+	abort(active, reason) {
+		this.reject(active, new ConversationAbortionError(reason ?? "conversation aborted"));
+	}
+	settle(active, onSettled) {
+		if (active.settled) return;
+		active.settled = true;
+		if (active.timeoutId) {
+			clearTimeout(active.timeoutId);
+			active.timeoutId = void 0;
+		}
+		if (this.activeConversations.get(active.key) === active) this.activeConversations.delete(active.key);
+		onSettled();
+	}
+};
+//#endregion
+//#region src/index.ts
+const ConversationPlugin = definePlugin({
+	name: "conversation",
+	provides: [ConversationService],
+	apply(ctx, options) {
+		ctx.provide(ConversationService, new ConversationService(ctx, options));
+	}
+});
+//#endregion
+export { ConversationAbortionError, ConversationPlugin, ConversationRejectionError, ConversationService };

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@fraqjs/plugin-conversation",
+  "type": "module",
+  "version": "0.1.0",
+  "description": "Conversation utility plugin for Fraq",
+  "files": [
+    "dist"
+  ],
+  "main": "dist/index.mjs",
+  "typings": "dist/index.d.mts",
+  "keywords": [],
+  "author": "fraqjs",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/fraqjs/fraq.git"
+  },
+  "homepage": "https://fraq.ntqqrev.org/",
+  "license": "MIT",
+  "peerDependencies": {
+    "@fraqjs/fraq": "^0.4.0"
+  },
+  "devDependencies": {
+    "@fraqjs/mock": "^0.1.0"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "test": "tsx --test test/*.test.ts"
+  }
+}