@fraqjs/plugin-conversation 0.1.0 → 0.2.0

package/dist/index.d.mts

@@ -1,10 +1,13 @@
-import { Context, Router, Session, milky } from "@fraqjs/fraq";
+import { Context, ParamsOf, Pattern, Router, Session } from "@fraqjs/fraq";
 
 //#region src/service.d.ts
 interface ConversationServiceOptions {
   defaultTimeout?: number;
   onCollision?: 'reject-incoming' | 'abort-existing';
 }
+interface ConversationCommandScope {
+  open<R>(handler: (conversationContext: ConversationContext<R>) => void | Promise<void>, options?: ConversationOptions): Promise<R | null>;
+}
 interface ConversationContext<R> {
   session: Session;
   router: Router;
@@ -13,15 +16,19 @@ interface ConversationContext<R> {
 }
 interface ConversationOptions {
   timeout?: number;
-  onUnmatched?: (raw: milky.IncomingMessage) => void | Promise<void>;
 }
 declare class ConversationService {
+  private readonly ctx;
   readonly defaultTimeout: number;
   readonly onCollision: 'reject-incoming' | 'abort-existing';
+  private readonly router;
   private readonly activeConversations;
   constructor(ctx: Context, options?: ConversationServiceOptions);
-  open<R>(session: Session, handler: (conversationContext: ConversationContext<R>) => void | Promise<void>, options?: ConversationOptions): Promise<R | null>;
+  command<P extends Pattern>(name: string, pattern: P, handler: (session: Session, params: ParamsOf<P>, scope: ConversationCommandScope) => void | Promise<void>): this;
+  private openFromCommand;
   private accept;
+  private dispatchCommand;
+  private dispatchActive;
   private resolve;
   private reject;
   private abort;
@@ -37,6 +44,6 @@ declare class ConversationAbortionError extends Error {
 }
 //#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>;
+declare const ConversationPlugin: import("@fraqjs/fraq").Plugin<[options?: ConversationServiceOptions | undefined], import("@fraqjs/fraq").Injection | undefined, import("@fraqjs/fraq").Injection | undefined>;
 //#endregion
-export { ConversationAbortionError, ConversationContext, ConversationOptions, ConversationPlugin, ConversationRejectionError, ConversationService, ConversationServiceOptions };
+export { ConversationAbortionError, ConversationCommandScope, ConversationContext, ConversationOptions, ConversationPlugin, ConversationRejectionError, ConversationService, ConversationServiceOptions };

package/dist/index.mjs

@@ -23,11 +23,39 @@ function assertPositiveTimeout(timeout, name) {
 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;
 }
+function branchFromMatch(match) {
+	switch (match.type) {
+		case "command": return {
+			type: "command",
+			path: match.path,
+			command: match.command
+		};
+		case "rawPattern": return {
+			type: "rawPattern",
+			path: match.path,
+			rawPattern: match.rawPattern
+		};
+	}
+}
+function isSameBranch(a, b) {
+	if (a.path.length !== b.path.length || !a.path.every((part, index) => part === b.path[index])) return false;
+	switch (a.type) {
+		case "command":
+			if (b.type !== "command") return false;
+			return a.command === b.command;
+		case "rawPattern":
+			if (b.type !== "rawPattern") return false;
+			return a.rawPattern === b.rawPattern;
+	}
+}
 var ConversationService = class {
+	ctx;
 	defaultTimeout;
 	onCollision;
+	router = new Router();
 	activeConversations = /* @__PURE__ */ new Map();
 	constructor(ctx, options) {
+		this.ctx = ctx;
 		this.defaultTimeout = options?.defaultTimeout ?? 3e4;
 		assertPositiveTimeout(this.defaultTimeout, "defaultTimeout");
 		this.onCollision = options?.onCollision ?? "reject-incoming";
@@ -35,7 +63,23 @@ var ConversationService = class {
 			this.accept(data);
 		});
 	}
-	async open(session, handler, options) {
+	command(name, pattern, handler) {
+		let branch;
+		this.router.command(name, pattern, (session, params) => {
+			const registeredBranch = branch;
+			if (!registeredBranch) throw new Error(`Conversation command "${name}" was not registered correctly.`);
+			return handler(session, params, { open: (conversationHandler, options) => this.openFromCommand(session, registeredBranch, conversationHandler, options) });
+		});
+		const entry = this.router.routes().at(-1);
+		if (entry?.type !== "command") throw new Error(`Conversation command "${name}" was not registered correctly.`);
+		branch = {
+			type: "command",
+			path: [],
+			command: entry.command
+		};
+		return this;
+	}
+	async openFromCommand(session, branch, handler, options) {
 		const timeout = options?.timeout ?? this.defaultTimeout;
 		assertPositiveTimeout(timeout, "timeout");
 		const key = conversationKey(session.raw);
@@ -48,6 +92,7 @@ var ConversationService = class {
 			const active = {
 				key,
 				session,
+				branch,
 				router: new Router(),
 				options,
 				resolve,
@@ -69,8 +114,30 @@ var ConversationService = class {
 		});
 	}
 	async accept(raw) {
+		const session = this.ctx.createSession(raw);
+		const commandMatch = this.router.match(session, raw);
+		const commandBranch = commandMatch ? branchFromMatch(commandMatch) : void 0;
 		const active = this.activeConversations.get(conversationKey(raw));
-		if (!active || active.settled) return;
+		if (!active || active.settled) {
+			await this.dispatchCommand(commandMatch, session);
+			return;
+		}
+		if (commandBranch && isSameBranch(active.branch, commandBranch) && this.onCollision === "abort-existing" && !isSame(active.session.raw, raw)) {
+			this.abort(active, "aborted due to new conversation");
+			await this.dispatchCommand(commandMatch, session);
+			return;
+		}
+		await this.dispatchActive(active, raw);
+	}
+	async dispatchCommand(match, session) {
+		if (match?.type !== "command") return;
+		try {
+			await match.command.handler(session, match.params);
+		} catch (error) {
+			this.ctx.logger.error(`Error routing conversation command (scene=${session.raw.message_scene} peer=${session.raw.peer_id} sender=${session.raw.sender_id} seq=${session.raw.message_seq})`, error);
+		}
+	}
+	async dispatchActive(active, raw) {
 		if (isSame(active.session.raw, raw)) return;
 		await active.ready;
 		if (this.activeConversations.get(active.key) !== active || active.settled) return;
@@ -78,18 +145,12 @@ var ConversationService = class {
 			...active.session,
 			raw
 		};
-		let matched;
 		try {
-			matched = await active.router.dispatch(session, raw);
+			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));

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@fraqjs/plugin-conversation",
   "type": "module",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Conversation utility plugin for Fraq",
   "files": [
     "dist"
@@ -17,7 +17,7 @@
   "homepage": "https://fraq.ntqqrev.org/",
   "license": "MIT",
   "peerDependencies": {
-    "@fraqjs/fraq": "^0.4.0"
+    "@fraqjs/fraq": "^0.5.1"
   },
   "devDependencies": {
     "@fraqjs/mock": "^0.1.0"