velocious 1.0.172 → 1.0.173

package/README.md

@@ -1,11 +1,11 @@
 # README
 
 * Concurrent multi threadded web server
-* Database framework ala Rails
-* Database models ala Rails
+* Database framework with familiar MVC concepts
+* Database models with migrations and validations
 * Database models that work almost the same in frontend and backend
-* Migrations ala Rails
-* Controllers and views ala Rails
+* Migrations for schema changes
+* Controllers and views for HTTP endpoints
 
 # Setup
 
@@ -546,6 +546,8 @@ socket.addEventListener("message", (event) => {
 })
 ```
 
+If `websocketChannelResolver` is configured, subscribe messages are treated as channel identifiers (see below).
+
 ## Broadcast an event from backend code
 
 Any backend code (controllers, services, jobs) can publish to subscribed websocket clients using the shared event bus on the configuration:
@@ -557,9 +559,9 @@ this.getConfiguration().getWebsocketEvents().publish(channel, payload)
 this.renderJsonArg({status: "published"})
 ```
 
-## Websocket channels (Rails-style)
+## Websocket channels
 
-You can resolve a websocket channel class per connection and let it subscribe clients server-side:
+You can resolve websocket channel classes from subscribe messages and let them decide which streams to allow:
 
 ```js
 import WebsocketChannel from "velocious/build/src/http-server/websocket-channel.js"
@@ -578,17 +580,32 @@ class NewsChannel extends WebsocketChannel {
 
 const configuration = new Configuration({
   // ...
-  websocketChannelResolver: ({request}) => {
-    const query = request?.path?.().split("?")[1]
-    const channel = new URLSearchParams(query).get("channel")
+  websocketChannelResolver: ({request, subscription}) => {
+    const channel = subscription?.channel
+    const params = subscription?.params || {}
 
     if (channel === "news") return NewsChannel
+
+    const query = request?.path?.().split("?")[1]
+    const legacyChannel = new URLSearchParams(query).get("channel")
+
+    if (legacyChannel === "news") return NewsChannel
   }
 })
 ```
 
 Channel classes are the recommended place to authorize subscriptions and decide which streams a connection should receive. If authorization fails, simply return without calling `streamFrom` or close the socket in `subscribed()`.
 
+Subscribe from the client using a channel identifier and params:
+
+```js
+socket.send(JSON.stringify({
+  type: "subscribe",
+  channel: "news",
+  params: {token: "secret"}
+}))
+```
+
 ## Combine: subscribe and invoke another action
 
 You can subscribe first and then call another controller action over the same websocket connection to trigger broadcasts:

package/build/src/configuration-types.d.ts

@@ -5,7 +5,7 @@
  * @typedef {function({request: import("./http-server/client/request.js").default | import("./http-server/client/websocket-request.js").default, response: import("./http-server/client/response.js").default}): Promise<void>} CorsType
  */
 /**
- * @typedef {function({request: import("./http-server/client/request.js").default | import("./http-server/client/websocket-request.js").default | undefined, client: import("./http-server/client/index.js").default, websocketSession: import("./http-server/client/websocket-session.js").default, configuration: import("./configuration.js").default}): typeof import("./http-server/websocket-channel.js").default | import("./http-server/websocket-channel.js").default | void | Promise<typeof import("./http-server/websocket-channel.js").default | import("./http-server/websocket-channel.js").default | void>} WebsocketChannelResolverType
+ * @typedef {function({request: import("./http-server/client/request.js").default | import("./http-server/client/websocket-request.js").default | undefined, subscription?: {channel: string, params?: Record<string, unknown>}, client: import("./http-server/client/index.js").default, websocketSession: import("./http-server/client/websocket-session.js").default, configuration: import("./configuration.js").default}): typeof import("./http-server/websocket-channel.js").default | import("./http-server/websocket-channel.js").default | void | Promise<typeof import("./http-server/websocket-channel.js").default | import("./http-server/websocket-channel.js").default | void>} WebsocketChannelResolverType
  */
 /**
  * @typedef {(id: string) => {default: typeof import("./initializer.js").default}} InitializersRequireContextType
@@ -88,6 +88,10 @@ export type CorsType = (arg0: {
 }) => Promise<void>;
 export type WebsocketChannelResolverType = (arg0: {
     request: import("./http-server/client/request.js").default | import("./http-server/client/websocket-request.js").default | undefined;
+    subscription?: {
+        channel: string;
+        params?: Record<string, unknown>;
+    };
     client: import("./http-server/client/index.js").default;
     websocketSession: import("./http-server/client/websocket-session.js").default;
     configuration: import("./configuration.js").default;

package/build/src/configuration-types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"configuration-types.d.ts","sourceRoot":"","sources":["../../src/configuration-types.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"configuration-types.d.ts","sourceRoot":"","sources":["../../src/configuration-types.js"],"names":[],"mappings":"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"}

package/build/src/configuration-types.js

@@ -6,7 +6,7 @@
  * @typedef {function({request: import("./http-server/client/request.js").default | import("./http-server/client/websocket-request.js").default, response: import("./http-server/client/response.js").default}): Promise<void>} CorsType
  */
 /**
- * @typedef {function({request: import("./http-server/client/request.js").default | import("./http-server/client/websocket-request.js").default | undefined, client: import("./http-server/client/index.js").default, websocketSession: import("./http-server/client/websocket-session.js").default, configuration: import("./configuration.js").default}): typeof import("./http-server/websocket-channel.js").default | import("./http-server/websocket-channel.js").default | void | Promise<typeof import("./http-server/websocket-channel.js").default | import("./http-server/websocket-channel.js").default | void>} WebsocketChannelResolverType
+ * @typedef {function({request: import("./http-server/client/request.js").default | import("./http-server/client/websocket-request.js").default | undefined, subscription?: {channel: string, params?: Record<string, unknown>}, client: import("./http-server/client/index.js").default, websocketSession: import("./http-server/client/websocket-session.js").default, configuration: import("./configuration.js").default}): typeof import("./http-server/websocket-channel.js").default | import("./http-server/websocket-channel.js").default | void | Promise<typeof import("./http-server/websocket-channel.js").default | import("./http-server/websocket-channel.js").default | void>} WebsocketChannelResolverType
  */
 /**
  * @typedef {(id: string) => {default: typeof import("./initializer.js").default}} InitializersRequireContextType
@@ -83,4 +83,4 @@
  * @property {WebsocketChannelResolverType} [websocketChannelResolver] - Resolve a websocket channel class/instance for each connection.
  */
 export const nothing = {};
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"configuration-types.js","sourceRoot":"","sources":["../../src/configuration-types.js"],"names":[],"mappings":"AAAA,YAAY;AAEZ;;GAEG;AAEH;;GAEG;AAEH;;GAEG;AAEH;;;;;;;;GAQG;AAEH;;;;;;;;;;;;;;GAcG;AAEH;;;;;;;;;;;;;;;;;;;GAmBG;AAEH;;;;;;;;GAQG;AAEH;;GAEG;AAEH;;;;;;;;;;;;;;;;;GAiBG;AAEH,MAAM,CAAC,MAAM,OAAO,GAAG,EAAE,CAAA","sourcesContent":["// @ts-check\n\n/**\n * @module types\n */\n\n/**\n * @typedef {function({request: import(\"./http-server/client/request.js\").default | import(\"./http-server/client/websocket-request.js\").default, response: import(\"./http-server/client/response.js\").default}): Promise<void>} CorsType\n */\n\n/**\n * @typedef {function({request: import(\"./http-server/client/request.js\").default | import(\"./http-server/client/websocket-request.js\").default | undefined, client: import(\"./http-server/client/index.js\").default, websocketSession: import(\"./http-server/client/websocket-session.js\").default, configuration: import(\"./configuration.js\").default}): typeof import(\"./http-server/websocket-channel.js\").default | import(\"./http-server/websocket-channel.js\").default | void | Promise<typeof import(\"./http-server/websocket-channel.js\").default | import(\"./http-server/websocket-channel.js\").default | void>} WebsocketChannelResolverType\n */\n\n/**\n * @typedef {(id: string) => {default: typeof import(\"./initializer.js\").default}} InitializersRequireContextType\n * @typedef {InitializersRequireContextType & {\n *   keys: () => string[],\n *   id: string\n * }} WebpackRequireContext\n * @typedef {{requireContext: WebpackRequireContext}} InitializersExportType\n * @typedef {function({configuration: import(\"./configuration.js\").default}) : Promise<InitializersExportType>} InitializersType\n */\n\n/**\n * @typedef {object} SqlConfig\n * @property {string} [database] - Database name for the SQL driver.\n * @property {object} [options] - Driver-specific connection options.\n * @property {boolean} [options.encrypt] - Whether to encrypt the connection (MSSQL).\n * @property {string} [options.serverName] - TLS SNI server name override for MSSQL (empty string disables SNI).\n * @property {boolean} [options.trustServerCertificate] - Whether to trust the server certificate (MSSQL).\n * @property {string} [password] - Password for the SQL user.\n * @property {object} [pool] - Connection pool configuration.\n * @property {number} [pool.max] - Maximum number of connections.\n * @property {number} [pool.min] - Minimum number of connections.\n * @property {number} [pool.idleTimeoutMillis] - Idle timeout before releasing a connection.\n * @property {string} [server] - SQL server hostname.\n * @property {string} [user] - SQL username.\n */\n\n/**\n * @typedef {object} DatabaseConfigurationType\n * @property {string} [database] - Database name for this connection.\n * @property {typeof import(\"./database/drivers/base.js\").default} [driver] - Driver class to use for this database.\n * @property {typeof import(\"./database/pool/base.js\").default} [poolType] - Pool class to use for this database.\n * @property {function() : unknown} [getConnection] - Custom connection factory override.\n * @property {string} [host] - Database host.\n * @property {boolean} [migrations] - Whether migrations are enabled for this database.\n * @property {string} [password] - Password for the database user.\n * @property {number} [port] - Database port.\n * @property {string} [name] - Friendly name for the configuration.\n * @property {boolean} [readOnly] - Whether writes should be blocked for this database.\n * @property {object} [record] - Record-level configuration.\n * @property {boolean} [record.transactions] - Whether record operations should use transactions.\n * @property {boolean} [reset] - Whether to reset the database on startup.\n * @property {SqlConfig} [sqlConfig] - Driver-specific SQL config.\n * @property {\"mssql\" | \"mysql\" | \"pgsql\" | \"sqlite\"} [type] - Database type identifier.\n * @property {string} [useDatabase] - Database to switch to after connecting.\n * @property {string} [username] - Username for database authentication.\n */\n\n/**\n * @typedef {object} LoggingConfiguration\n * @property {boolean} [console] - Enable/disable console logging for request logging. Defaults to true outside of \"test\" and for HTTP server logs.\n * @property {boolean} [file] - Enable/disable writing logs to a file. Defaults to true.\n * @property {string} [directory] - Directory where log files are stored. Defaults to \"<project>/log\".\n * @property {string} [filePath] - Explicit path for the log file. Defaults to \"<directory>/<environment>.log\".\n * @property {Array<\"debug-low-level\" | \"debug\" | \"info\" | \"warn\" | \"error\">} [levels] - Override which log levels are emitted.\n * @property {boolean} [debugLowLevel] - Convenience flag to include very low-level debug logs.\n */\n\n/**\n * @typedef {Record<string, string[]>} LocaleFallbacksType\n */\n\n/**\n * @typedef {object} ConfigurationArgsType\n * @property {CorsType} [cors] - CORS configuration for the HTTP server.\n * @property {{[key: string]: {[key: string]: DatabaseConfigurationType}}} database - Database configurations keyed by environment and identifier.\n * @property {boolean} [debug] - Enable debug logging.\n * @property {string} [directory] - Base directory for the project.\n * @property {string} [environment] - Current environment name.\n * @property {import(\"./environment-handlers/base.js\").default} environmentHandler - Environment handler instance.\n * @property {LoggingConfiguration} [logging] - Logging configuration.\n * @property {function({configuration: import(\"./configuration.js\").default, type: string}) : void} initializeModels - Hook to register models for a given initialization type.\n * @property {InitializersType} [initializers] - Initializer loader for environment bootstrapping.\n * @property {string | function() : string} locale - Default locale or locale resolver.\n * @property {string[]} locales - Supported locales.\n * @property {LocaleFallbacksType} localeFallbacks - Locale fallback map.\n * @property {string} [testing] - Path to the testing configuration file.\n * @property {number | (() => number)} [timezoneOffsetMinutes] - Default timezone offset in minutes.\n * @property {WebsocketChannelResolverType} [websocketChannelResolver] - Resolve a websocket channel class/instance for each connection.\n */\n\nexport const nothing = {}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"configuration-types.js","sourceRoot":"","sources":["../../src/configuration-types.js"],"names":[],"mappings":"AAAA,YAAY;AAEZ;;GAEG;AAEH;;GAEG;AAEH;;GAEG;AAEH;;;;;;;;GAQG;AAEH;;;;;;;;;;;;;;GAcG;AAEH;;;;;;;;;;;;;;;;;;;GAmBG;AAEH;;;;;;;;GAQG;AAEH;;GAEG;AAEH;;;;;;;;;;;;;;;;;GAiBG;AAEH,MAAM,CAAC,MAAM,OAAO,GAAG,EAAE,CAAA","sourcesContent":["// @ts-check\n\n/**\n * @module types\n */\n\n/**\n * @typedef {function({request: import(\"./http-server/client/request.js\").default | import(\"./http-server/client/websocket-request.js\").default, response: import(\"./http-server/client/response.js\").default}): Promise<void>} CorsType\n */\n\n/**\n * @typedef {function({request: import(\"./http-server/client/request.js\").default | import(\"./http-server/client/websocket-request.js\").default | undefined, subscription?: {channel: string, params?: Record<string, unknown>}, client: import(\"./http-server/client/index.js\").default, websocketSession: import(\"./http-server/client/websocket-session.js\").default, configuration: import(\"./configuration.js\").default}): typeof import(\"./http-server/websocket-channel.js\").default | import(\"./http-server/websocket-channel.js\").default | void | Promise<typeof import(\"./http-server/websocket-channel.js\").default | import(\"./http-server/websocket-channel.js\").default | void>} WebsocketChannelResolverType\n */\n\n/**\n * @typedef {(id: string) => {default: typeof import(\"./initializer.js\").default}} InitializersRequireContextType\n * @typedef {InitializersRequireContextType & {\n *   keys: () => string[],\n *   id: string\n * }} WebpackRequireContext\n * @typedef {{requireContext: WebpackRequireContext}} InitializersExportType\n * @typedef {function({configuration: import(\"./configuration.js\").default}) : Promise<InitializersExportType>} InitializersType\n */\n\n/**\n * @typedef {object} SqlConfig\n * @property {string} [database] - Database name for the SQL driver.\n * @property {object} [options] - Driver-specific connection options.\n * @property {boolean} [options.encrypt] - Whether to encrypt the connection (MSSQL).\n * @property {string} [options.serverName] - TLS SNI server name override for MSSQL (empty string disables SNI).\n * @property {boolean} [options.trustServerCertificate] - Whether to trust the server certificate (MSSQL).\n * @property {string} [password] - Password for the SQL user.\n * @property {object} [pool] - Connection pool configuration.\n * @property {number} [pool.max] - Maximum number of connections.\n * @property {number} [pool.min] - Minimum number of connections.\n * @property {number} [pool.idleTimeoutMillis] - Idle timeout before releasing a connection.\n * @property {string} [server] - SQL server hostname.\n * @property {string} [user] - SQL username.\n */\n\n/**\n * @typedef {object} DatabaseConfigurationType\n * @property {string} [database] - Database name for this connection.\n * @property {typeof import(\"./database/drivers/base.js\").default} [driver] - Driver class to use for this database.\n * @property {typeof import(\"./database/pool/base.js\").default} [poolType] - Pool class to use for this database.\n * @property {function() : unknown} [getConnection] - Custom connection factory override.\n * @property {string} [host] - Database host.\n * @property {boolean} [migrations] - Whether migrations are enabled for this database.\n * @property {string} [password] - Password for the database user.\n * @property {number} [port] - Database port.\n * @property {string} [name] - Friendly name for the configuration.\n * @property {boolean} [readOnly] - Whether writes should be blocked for this database.\n * @property {object} [record] - Record-level configuration.\n * @property {boolean} [record.transactions] - Whether record operations should use transactions.\n * @property {boolean} [reset] - Whether to reset the database on startup.\n * @property {SqlConfig} [sqlConfig] - Driver-specific SQL config.\n * @property {\"mssql\" | \"mysql\" | \"pgsql\" | \"sqlite\"} [type] - Database type identifier.\n * @property {string} [useDatabase] - Database to switch to after connecting.\n * @property {string} [username] - Username for database authentication.\n */\n\n/**\n * @typedef {object} LoggingConfiguration\n * @property {boolean} [console] - Enable/disable console logging for request logging. Defaults to true outside of \"test\" and for HTTP server logs.\n * @property {boolean} [file] - Enable/disable writing logs to a file. Defaults to true.\n * @property {string} [directory] - Directory where log files are stored. Defaults to \"<project>/log\".\n * @property {string} [filePath] - Explicit path for the log file. Defaults to \"<directory>/<environment>.log\".\n * @property {Array<\"debug-low-level\" | \"debug\" | \"info\" | \"warn\" | \"error\">} [levels] - Override which log levels are emitted.\n * @property {boolean} [debugLowLevel] - Convenience flag to include very low-level debug logs.\n */\n\n/**\n * @typedef {Record<string, string[]>} LocaleFallbacksType\n */\n\n/**\n * @typedef {object} ConfigurationArgsType\n * @property {CorsType} [cors] - CORS configuration for the HTTP server.\n * @property {{[key: string]: {[key: string]: DatabaseConfigurationType}}} database - Database configurations keyed by environment and identifier.\n * @property {boolean} [debug] - Enable debug logging.\n * @property {string} [directory] - Base directory for the project.\n * @property {string} [environment] - Current environment name.\n * @property {import(\"./environment-handlers/base.js\").default} environmentHandler - Environment handler instance.\n * @property {LoggingConfiguration} [logging] - Logging configuration.\n * @property {function({configuration: import(\"./configuration.js\").default, type: string}) : void} initializeModels - Hook to register models for a given initialization type.\n * @property {InitializersType} [initializers] - Initializer loader for environment bootstrapping.\n * @property {string | function() : string} locale - Default locale or locale resolver.\n * @property {string[]} locales - Supported locales.\n * @property {LocaleFallbacksType} localeFallbacks - Locale fallback map.\n * @property {string} [testing] - Path to the testing configuration file.\n * @property {number | (() => number)} [timezoneOffsetMinutes] - Default timezone offset in minutes.\n * @property {WebsocketChannelResolverType} [websocketChannelResolver] - Resolve a websocket channel class/instance for each connection.\n */\n\nexport const nothing = {}\n"]}

package/build/src/http-server/client/websocket-session.d.ts

@@ -12,6 +12,7 @@ export default class VelociousHttpServerClientWebsocketSession {
     });
     events: import("eventemitter3").EventEmitter<string | symbol, any>;
     subscriptions: Set<any>;
+    channels: Set<any>;
     buffer: Buffer<ArrayBuffer>;
     client: import("./index.js").default;
     configuration: import("../../configuration.js").default;
@@ -43,7 +44,6 @@ export default class VelociousHttpServerClientWebsocketSession {
      * @returns {Promise<void>} - Resolves when complete.
      */
     initializeChannel(): Promise<void>;
-    channel: WebsocketChannel;
     /**
      * @param {import("./index.js").default} client - Client instance.
      * @returns {void} - No return value.
@@ -79,6 +79,12 @@ export default class VelociousHttpServerClientWebsocketSession {
     }): Promise<boolean>;
     _handleClose(): void;
     _teardownChannel(): Promise<void>;
+    _teardownSingleChannel(channel: any): Promise<void>;
+    _registerChannel(channel: any): Promise<void>;
+    _handleChannelSubscription({ channel, params }: {
+        channel: any;
+        params: any;
+    }): Promise<void>;
     /**
      * @param {Buffer} payload - Payload data.
      * @param {Buffer} mask - Mask.
@@ -88,5 +94,4 @@ export default class VelociousHttpServerClientWebsocketSession {
 }
 import WebsocketRequest from "./websocket-request.js";
 import { Logger } from "../../logger.js";
-import WebsocketChannel from "../websocket-channel.js";
 //# sourceMappingURL=websocket-session.d.ts.map

package/build/src/http-server/client/websocket-session.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"websocket-session.d.ts","sourceRoot":"","sources":["../../../../src/http-server/client/websocket-session.js"],"names":[],"mappings":"AAcA;IAIE;;;;;OAKG;IACH,uDAJG;QAAuD,aAAa,EAA5D,OAAO,wBAAwB,EAAE,OAAO;QACL,MAAM,EAAzC,OAAO,YAAY,EAAE,OAAO;QACqD,cAAc,GAA/F,OAAO,cAAc,EAAE,OAAO,GAAG,OAAO,wBAAwB,EAAE,OAAO;KACnF,EAOA;IAfD,mEAA2B;IAC3B,wBAAyB;IASvB,4BAA6B;IAC7B,qCAAoB;IACpB,wDAAkC;IAClC,kEAAoC;IACpC,eAA8B;IAGhC;;;OAGG;IACH,yBAHW,MAAM,GACJ,IAAI,CAIhB;IAED,gBAGC;IAED;;;OAGG;IACH,yBAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;OAGG;IACH,aAHW,MAAM,GACJ,IAAI,CAKhB;IAED;;;;OAIG;IACH,mBAJW,MAAM,WACN,GAAG,GACD,OAAO,CAAC,IAAI,CAAC,CAMzB;IAED;;OAEG;IACH,qBAFa,OAAO,CAAC,IAAI,CAAC,CA6BzB;IAZG,0BAEY;IAYhB;;;OAGG;IACH,oBAHW,OAAO,YAAY,EAAE,OAAO,GAC1B,IAAI,CAMhB;IAED;;;OAGG;IACH,wBAHW,MAAM,GACJ,OAAO,CAAC,IAAI,CAAC,CAkDzB;IAED;;OAEG;IACH,kBAFa,IAAI,CAuEhB;IAED;;;;OAIG;IACH,0BAJW,MAAM,WACN,MAAM,GACJ,IAAI,CAShB;IAED;;;OAGG;IACH,gBAHW,MAAM,GACJ,IAAI,CAuBhB;IAED;;;;OAIG;IACH,4BAJW,MAAM,oBACN;QAAC,WAAW,CAAC,EAAE,OAAO,CAAA;KAAC,GACrB,OAAO,CAAC,OAAO,CAAC,CAQ5B;IAED,qBAGC;IAED,kCAMC;IAED;;;;OAIG;IACH,wBAJW,MAAM,QACN,MAAM,GACJ,MAAM,CAWlB;CACF;6BAhU4B,wBAAwB;uBAFhC,iBAAiB;6BAGT,yBAAyB"}
+{"version":3,"file":"websocket-session.d.ts","sourceRoot":"","sources":["../../../../src/http-server/client/websocket-session.js"],"names":[],"mappings":"AAcA;IAKE;;;;;OAKG;IACH,uDAJG;QAAuD,aAAa,EAA5D,OAAO,wBAAwB,EAAE,OAAO;QACL,MAAM,EAAzC,OAAO,YAAY,EAAE,OAAO;QACqD,cAAc,GAA/F,OAAO,cAAc,EAAE,OAAO,GAAG,OAAO,wBAAwB,EAAE,OAAO;KACnF,EAOA;IAhBD,mEAA2B;IAC3B,wBAAyB;IACzB,mBAAoB;IASlB,4BAA6B;IAC7B,qCAAoB;IACpB,wDAAkC;IAClC,kEAAoC;IACpC,eAA8B;IAGhC;;;OAGG;IACH,yBAHW,MAAM,GACJ,IAAI,CAIhB;IAED,gBAGC;IAED;;;OAGG;IACH,yBAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;OAGG;IACH,aAHW,MAAM,GACJ,IAAI,CAKhB;IAED;;;;OAIG;IACH,mBAJW,MAAM,WACN,GAAG,GACD,OAAO,CAAC,IAAI,CAAC,CAMzB;IAED;;OAEG;IACH,qBAFa,OAAO,CAAC,IAAI,CAAC,CA6BzB;IAED;;;OAGG;IACH,oBAHW,OAAO,YAAY,EAAE,OAAO,GAC1B,IAAI,CAMhB;IAED;;;OAGG;IACH,wBAHW,MAAM,GACJ,OAAO,CAAC,IAAI,CAAC,CAwDzB;IAED;;OAEG;IACH,kBAFa,IAAI,CAuEhB;IAED;;;;OAIG;IACH,0BAJW,MAAM,WACN,MAAM,GACJ,IAAI,CAShB;IAED;;;OAGG;IACH,gBAHW,MAAM,GACJ,IAAI,CAuBhB;IAED;;;;OAIG;IACH,4BAJW,MAAM,oBACN;QAAC,WAAW,CAAC,EAAE,OAAO,CAAA;KAAC,GACrB,OAAO,CAAC,OAAO,CAAC,CAQ5B;IAED,qBAGC;IAED,kCAKC;IAED,oDAMC;IAED,8CAKC;IAED;;;sBAsCC;IAED;;;;OAIG;IACH,wBAJW,MAAM,QACN,MAAM,GACJ,MAAM,CAWlB;CACF;6BA7X4B,wBAAwB;uBAFhC,iBAAiB"}

package/build/src/http-server/client/websocket-session.js

@@ -12,6 +12,7 @@ const WEBSOCKET_OPCODE_PONG = 0xA;
 export default class VelociousHttpServerClientWebsocketSession {
     events = new EventEmitter();
     subscriptions = new Set();
+    channels = new Set();
     /**
      * @param {object} args - Options object.
      * @param {import("../../configuration.js").default} args.configuration - Configuration instance.
@@ -77,13 +78,13 @@ export default class VelociousHttpServerClientWebsocketSession {
             });
             if (!resolved)
                 return;
-            this.channel = typeof resolved === "function"
+            const channel = typeof resolved === "function"
                 ? new resolved({ client: this.client, configuration: this.configuration, request: this.upgradeRequest, websocketSession: this })
                 : resolved;
-            if (this.channel && !(this.channel instanceof WebsocketChannel)) {
+            if (channel && !(channel instanceof WebsocketChannel)) {
                 throw new Error("Resolved websocket channel must extend WebsocketChannel");
             }
-            await this.channel?.subscribed?.();
+            await this._registerChannel(channel);
         }
         catch (error) {
             this.logger.error(() => ["Failed to initialize websocket channel", error]);
@@ -103,10 +104,16 @@ export default class VelociousHttpServerClientWebsocketSession {
      */
     async _handleMessage(message) {
         if (message.type === "subscribe") {
-            const { channel } = message;
+            const { channel, params } = message;
             if (!channel)
                 throw new Error("channel is required for subscribe");
-            await this.subscribeToChannel(channel, { acknowledge: true });
+            const resolver = this.configuration.getWebsocketChannelResolver?.();
+            if (resolver) {
+                await this._handleChannelSubscription({ channel, params });
+            }
+            else {
+                await this.subscribeToChannel(channel, { acknowledge: true });
+            }
             return;
         }
         if (message.type && message.type !== "request") {
@@ -262,13 +269,60 @@ export default class VelociousHttpServerClientWebsocketSession {
         this.events.emit("close");
     }
     async _teardownChannel() {
+        for (const channel of this.channels) {
+            await this._teardownSingleChannel(channel);
+        }
+        this.channels.clear();
+    }
+    async _teardownSingleChannel(channel) {
         try {
-            await this.channel?.unsubscribed?.();
+            await channel?.unsubscribed?.();
         }
         catch (error) {
             this.logger.error(() => ["Failed to teardown websocket channel", error]);
         }
     }
+    async _registerChannel(channel) {
+        if (!channel)
+            return;
+        this.channels.add(channel);
+        await channel?.subscribed?.();
+    }
+    async _handleChannelSubscription({ channel, params }) {
+        const resolver = this.configuration.getWebsocketChannelResolver?.();
+        if (!resolver)
+            return;
+        try {
+            const resolved = await resolver({
+                client: this.client,
+                configuration: this.configuration,
+                request: this.upgradeRequest,
+                subscription: { channel, params },
+                websocketSession: this
+            });
+            if (!resolved) {
+                this._sendJson({ channel, error: "Subscription rejected", type: "error" });
+                return;
+            }
+            const channelInstance = typeof resolved === "function"
+                ? new resolved({
+                    client: this.client,
+                    configuration: this.configuration,
+                    request: this.upgradeRequest,
+                    subscriptionParams: params,
+                    websocketSession: this
+                })
+                : resolved;
+            if (channelInstance && !(channelInstance instanceof WebsocketChannel)) {
+                throw new Error("Resolved websocket channel must extend WebsocketChannel");
+            }
+            await this._registerChannel(channelInstance);
+        }
+        catch (error) {
+            this.logger.warn(() => ["Websocket channel subscription failed", error]);
+            this._sendJson({ channel, error: "Subscription rejected", type: "error" });
+        }
+    }
     /**
      * @param {Buffer} payload - Payload data.
      * @param {Buffer} mask - Mask.
@@ -283,4 +337,4 @@ export default class VelociousHttpServerClientWebsocketSession {
         return result;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"websocket-session.js","sourceRoot":"","sources":["../../../../src/http-server/client/websocket-session.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport EventEmitter from \"../../utils/event-emitter.js\"\nimport {Logger} from \"../../logger.js\"\nimport RequestRunner from \"./request-runner.js\"\nimport WebsocketRequest from \"./websocket-request.js\"\nimport WebsocketChannel from \"../websocket-channel.js\"\n\nconst WEBSOCKET_FINAL_FRAME = 0x80\nconst WEBSOCKET_OPCODE_TEXT = 0x1\nconst WEBSOCKET_OPCODE_CLOSE = 0x8\nconst WEBSOCKET_OPCODE_PING = 0x9\nconst WEBSOCKET_OPCODE_PONG = 0xA\n\nexport default class VelociousHttpServerClientWebsocketSession {\n  events = new EventEmitter()\n  subscriptions = new Set()\n\n  /**\n   * @param {object} args - Options object.\n   * @param {import(\"../../configuration.js\").default} args.configuration - Configuration instance.\n   * @param {import(\"./index.js\").default} args.client - Client instance.\n   * @param {import(\"./request.js\").default | import(\"./websocket-request.js\").default} [args.upgradeRequest] - Initial websocket upgrade request.\n   */\n  constructor({client, configuration, upgradeRequest}) {\n    this.buffer = Buffer.alloc(0)\n    this.client = client\n    this.configuration = configuration\n    this.upgradeRequest = upgradeRequest\n    this.logger = new Logger(this)\n  }\n\n  /**\n   * @param {string} channel - Channel name.\n   * @returns {void} - No return value.\n   */\n  addSubscription(channel) {\n    this.subscriptions.add(channel)\n  }\n\n  destroy() {\n    void this._teardownChannel()\n    this.events.removeAllListeners()\n  }\n\n  /**\n   * @param {string} channel - Channel name.\n   * @returns {boolean} - Whether it has subscription.\n   */\n  hasSubscription(channel) {\n    return this.subscriptions.has(channel)\n  }\n\n  /**\n   * @param {Buffer} data - Data payload.\n   * @returns {void} - No return value.\n   */\n  onData(data) {\n    this.buffer = Buffer.concat([this.buffer, data])\n    this._processBuffer()\n  }\n\n  /**\n   * @param {string} channel - Channel name.\n   * @param {any} payload - Payload data.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async sendEvent(channel, payload) {\n    if (!this.hasSubscription(channel)) return\n\n    this._sendJson({channel, payload, type: \"event\"})\n  }\n\n  /**\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async initializeChannel() {\n    const resolver = this.configuration.getWebsocketChannelResolver?.()\n\n    if (!resolver) return\n\n    try {\n      const resolved = await resolver({\n        client: this.client,\n        configuration: this.configuration,\n        request: this.upgradeRequest,\n        websocketSession: this\n      })\n\n      if (!resolved) return\n\n      this.channel = typeof resolved === \"function\"\n        ? new resolved({client: this.client, configuration: this.configuration, request: this.upgradeRequest, websocketSession: this})\n        : resolved\n\n      if (this.channel && !(this.channel instanceof WebsocketChannel)) {\n        throw new Error(\"Resolved websocket channel must extend WebsocketChannel\")\n      }\n\n      await this.channel?.subscribed?.()\n    } catch (error) {\n      this.logger.error(() => [\"Failed to initialize websocket channel\", error])\n    }\n  }\n\n  /**\n   * @param {import(\"./index.js\").default} client - Client instance.\n   * @returns {void} - No return value.\n   */\n  sendGoodbye(client) {\n    const frame = Buffer.from([WEBSOCKET_FINAL_FRAME | WEBSOCKET_OPCODE_CLOSE, 0x00])\n\n    client.events.emit(\"output\", frame)\n  }\n\n  /**\n   * @param {object} message - Message text.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async _handleMessage(message) {\n    if (message.type === \"subscribe\") {\n      const {channel} = message\n\n      if (!channel) throw new Error(\"channel is required for subscribe\")\n      await this.subscribeToChannel(channel, {acknowledge: true})\n\n      return\n    }\n\n    if (message.type && message.type !== \"request\") {\n      this._sendJson({error: `Unknown message type: ${message.type}`, type: \"error\"})\n      return\n    }\n\n    const {body, headers, id, method, path} = message\n\n    if (!method) throw new Error(\"method is required\")\n    if (!path) throw new Error(\"path is required\")\n\n    const request = new WebsocketRequest({\n      body,\n      headers,\n      method,\n      path,\n      remoteAddress: this.client.remoteAddress\n    })\n    const requestRunner = new RequestRunner({\n      configuration: this.configuration,\n      request\n    })\n\n    requestRunner.events.on(\"done\", () => {\n      const response = requestRunner.response\n      const body = response.getBody()\n      const headers = response.headers\n\n      this._sendJson({\n        body,\n        headers,\n        id,\n        statusCode: response.getStatusCode(),\n        statusMessage: response.getStatusMessage(),\n        type: \"response\"\n      })\n    })\n\n    await requestRunner.run()\n  }\n\n  /**\n   * @returns {void} - No return value.\n   */\n  _processBuffer() {\n    while (this.buffer.length >= 2) {\n      const firstByte = this.buffer[0]\n      const secondByte = this.buffer[1]\n      const isFinal = (firstByte & WEBSOCKET_FINAL_FRAME) === WEBSOCKET_FINAL_FRAME\n      const opcode = firstByte & 0x0F\n      const isMasked = (secondByte & 0x80) === 0x80\n      let payloadLength = secondByte & 0x7F\n      let offset = 2\n\n      if (payloadLength === 126) {\n        if (this.buffer.length < offset + 2) return\n        payloadLength = this.buffer.readUInt16BE(offset)\n        offset += 2\n      } else if (payloadLength === 127) {\n        if (this.buffer.length < offset + 8) return\n        const bigLength = this.buffer.readBigUInt64BE(offset)\n\n        payloadLength = Number(bigLength)\n        offset += 8\n      }\n\n      const maskLength = isMasked ? 4 : 0\n\n      if (this.buffer.length < offset + maskLength + payloadLength) return\n\n      /** @type {Buffer} */\n      let payload = this.buffer.slice(offset + maskLength, offset + maskLength + payloadLength)\n\n      if (isMasked) {\n        const mask = this.buffer.slice(offset, offset + maskLength)\n        payload = this._unmaskPayload(payload, mask)\n      }\n\n      this.buffer = this.buffer.slice(offset + maskLength + payloadLength)\n\n      if (!isFinal) {\n        this.logger.warn(\"Fragmented frames are not supported yet\")\n        continue\n      }\n\n      if (opcode === WEBSOCKET_OPCODE_PING) {\n        this._sendControlFrame(WEBSOCKET_OPCODE_PONG, payload)\n        continue\n      }\n\n      if (opcode === WEBSOCKET_OPCODE_CLOSE) {\n        this._handleClose()\n        this.sendGoodbye(this.client)\n        continue\n      }\n\n      if (opcode !== WEBSOCKET_OPCODE_TEXT) {\n        this.logger.warn(`Unsupported websocket opcode: ${opcode}`)\n        continue\n      }\n\n      try {\n        const message = JSON.parse(payload.toString(\"utf-8\"))\n\n        this._handleMessage(message).catch((error) => {\n          this.logger.error(() => [\"Websocket message handler failed\", error])\n          this._sendJson({error: error.message, type: \"error\"})\n        })\n      } catch (error) {\n        this.logger.error(() => [\"Failed to parse websocket message\", error])\n        this._sendJson({error: \"Invalid websocket message\", type: \"error\"})\n      }\n    }\n  }\n\n  /**\n   * @param {number} opcode - Opcode.\n   * @param {Buffer} payload - Payload data.\n   * @returns {void} - No return value.\n   */\n  _sendControlFrame(opcode, payload) {\n    const header = Buffer.alloc(2)\n\n    header[0] = WEBSOCKET_FINAL_FRAME | opcode\n    header[1] = payload.length\n\n    this.client.events.emit(\"output\", Buffer.concat([header, payload]))\n  }\n\n  /**\n   * @param {object} body - Request body.\n   * @returns {void} - No return value.\n   */\n  _sendJson(body) {\n    const json = JSON.stringify(body)\n    const payload = Buffer.from(json, \"utf-8\")\n    let header\n\n    if (payload.length < 126) {\n      header = Buffer.alloc(2)\n      header[1] = payload.length\n    } else if (payload.length < 65536) {\n      header = Buffer.alloc(4)\n      header[1] = 126\n      header.writeUInt16BE(payload.length, 2)\n    } else {\n      header = Buffer.alloc(10)\n      header[1] = 127\n      header.writeBigUInt64BE(BigInt(payload.length), 2)\n    }\n\n    header[0] = WEBSOCKET_FINAL_FRAME | WEBSOCKET_OPCODE_TEXT\n\n    this.client.events.emit(\"output\", Buffer.concat([header, payload]))\n  }\n\n  /**\n   * @param {string} channel - Channel name.\n   * @param {{acknowledge?: boolean}} [options] - Subscribe options.\n   * @returns {Promise<boolean>} - Whether the subscription was added.\n   */\n  async subscribeToChannel(channel, {acknowledge = true} = {}) {\n    this.addSubscription(channel)\n    if (acknowledge) {\n      this._sendJson({channel, type: \"subscribed\"})\n    }\n    return true\n  }\n\n  _handleClose() {\n    void this._teardownChannel()\n    this.events.emit(\"close\")\n  }\n\n  async _teardownChannel() {\n    try {\n      await this.channel?.unsubscribed?.()\n    } catch (error) {\n      this.logger.error(() => [\"Failed to teardown websocket channel\", error])\n    }\n  }\n\n  /**\n   * @param {Buffer} payload - Payload data.\n   * @param {Buffer} mask - Mask.\n   * @returns {Buffer} - The unmask payload.\n   */\n  _unmaskPayload(payload, mask) {\n    /** @type {Buffer} */\n    const result = Buffer.alloc(payload.length)\n\n    for (let i = 0; i < payload.length; i++) {\n      result[i] = payload[i] ^ mask[i % 4]\n    }\n\n    return result\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"websocket-session.js","sourceRoot":"","sources":["../../../../src/http-server/client/websocket-session.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport EventEmitter from \"../../utils/event-emitter.js\"\nimport {Logger} from \"../../logger.js\"\nimport RequestRunner from \"./request-runner.js\"\nimport WebsocketRequest from \"./websocket-request.js\"\nimport WebsocketChannel from \"../websocket-channel.js\"\n\nconst WEBSOCKET_FINAL_FRAME = 0x80\nconst WEBSOCKET_OPCODE_TEXT = 0x1\nconst WEBSOCKET_OPCODE_CLOSE = 0x8\nconst WEBSOCKET_OPCODE_PING = 0x9\nconst WEBSOCKET_OPCODE_PONG = 0xA\n\nexport default class VelociousHttpServerClientWebsocketSession {\n  events = new EventEmitter()\n  subscriptions = new Set()\n  channels = new Set()\n\n  /**\n   * @param {object} args - Options object.\n   * @param {import(\"../../configuration.js\").default} args.configuration - Configuration instance.\n   * @param {import(\"./index.js\").default} args.client - Client instance.\n   * @param {import(\"./request.js\").default | import(\"./websocket-request.js\").default} [args.upgradeRequest] - Initial websocket upgrade request.\n   */\n  constructor({client, configuration, upgradeRequest}) {\n    this.buffer = Buffer.alloc(0)\n    this.client = client\n    this.configuration = configuration\n    this.upgradeRequest = upgradeRequest\n    this.logger = new Logger(this)\n  }\n\n  /**\n   * @param {string} channel - Channel name.\n   * @returns {void} - No return value.\n   */\n  addSubscription(channel) {\n    this.subscriptions.add(channel)\n  }\n\n  destroy() {\n    void this._teardownChannel()\n    this.events.removeAllListeners()\n  }\n\n  /**\n   * @param {string} channel - Channel name.\n   * @returns {boolean} - Whether it has subscription.\n   */\n  hasSubscription(channel) {\n    return this.subscriptions.has(channel)\n  }\n\n  /**\n   * @param {Buffer} data - Data payload.\n   * @returns {void} - No return value.\n   */\n  onData(data) {\n    this.buffer = Buffer.concat([this.buffer, data])\n    this._processBuffer()\n  }\n\n  /**\n   * @param {string} channel - Channel name.\n   * @param {any} payload - Payload data.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async sendEvent(channel, payload) {\n    if (!this.hasSubscription(channel)) return\n\n    this._sendJson({channel, payload, type: \"event\"})\n  }\n\n  /**\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async initializeChannel() {\n    const resolver = this.configuration.getWebsocketChannelResolver?.()\n\n    if (!resolver) return\n\n    try {\n      const resolved = await resolver({\n        client: this.client,\n        configuration: this.configuration,\n        request: this.upgradeRequest,\n        websocketSession: this\n      })\n\n      if (!resolved) return\n\n      const channel = typeof resolved === \"function\"\n        ? new resolved({client: this.client, configuration: this.configuration, request: this.upgradeRequest, websocketSession: this})\n        : resolved\n\n      if (channel && !(channel instanceof WebsocketChannel)) {\n        throw new Error(\"Resolved websocket channel must extend WebsocketChannel\")\n      }\n\n      await this._registerChannel(channel)\n    } catch (error) {\n      this.logger.error(() => [\"Failed to initialize websocket channel\", error])\n    }\n  }\n\n  /**\n   * @param {import(\"./index.js\").default} client - Client instance.\n   * @returns {void} - No return value.\n   */\n  sendGoodbye(client) {\n    const frame = Buffer.from([WEBSOCKET_FINAL_FRAME | WEBSOCKET_OPCODE_CLOSE, 0x00])\n\n    client.events.emit(\"output\", frame)\n  }\n\n  /**\n   * @param {object} message - Message text.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async _handleMessage(message) {\n    if (message.type === \"subscribe\") {\n      const {channel, params} = message\n\n      if (!channel) throw new Error(\"channel is required for subscribe\")\n      const resolver = this.configuration.getWebsocketChannelResolver?.()\n\n      if (resolver) {\n        await this._handleChannelSubscription({channel, params})\n      } else {\n        await this.subscribeToChannel(channel, {acknowledge: true})\n      }\n\n      return\n    }\n\n    if (message.type && message.type !== \"request\") {\n      this._sendJson({error: `Unknown message type: ${message.type}`, type: \"error\"})\n      return\n    }\n\n    const {body, headers, id, method, path} = message\n\n    if (!method) throw new Error(\"method is required\")\n    if (!path) throw new Error(\"path is required\")\n\n    const request = new WebsocketRequest({\n      body,\n      headers,\n      method,\n      path,\n      remoteAddress: this.client.remoteAddress\n    })\n    const requestRunner = new RequestRunner({\n      configuration: this.configuration,\n      request\n    })\n\n    requestRunner.events.on(\"done\", () => {\n      const response = requestRunner.response\n      const body = response.getBody()\n      const headers = response.headers\n\n      this._sendJson({\n        body,\n        headers,\n        id,\n        statusCode: response.getStatusCode(),\n        statusMessage: response.getStatusMessage(),\n        type: \"response\"\n      })\n    })\n\n    await requestRunner.run()\n  }\n\n  /**\n   * @returns {void} - No return value.\n   */\n  _processBuffer() {\n    while (this.buffer.length >= 2) {\n      const firstByte = this.buffer[0]\n      const secondByte = this.buffer[1]\n      const isFinal = (firstByte & WEBSOCKET_FINAL_FRAME) === WEBSOCKET_FINAL_FRAME\n      const opcode = firstByte & 0x0F\n      const isMasked = (secondByte & 0x80) === 0x80\n      let payloadLength = secondByte & 0x7F\n      let offset = 2\n\n      if (payloadLength === 126) {\n        if (this.buffer.length < offset + 2) return\n        payloadLength = this.buffer.readUInt16BE(offset)\n        offset += 2\n      } else if (payloadLength === 127) {\n        if (this.buffer.length < offset + 8) return\n        const bigLength = this.buffer.readBigUInt64BE(offset)\n\n        payloadLength = Number(bigLength)\n        offset += 8\n      }\n\n      const maskLength = isMasked ? 4 : 0\n\n      if (this.buffer.length < offset + maskLength + payloadLength) return\n\n      /** @type {Buffer} */\n      let payload = this.buffer.slice(offset + maskLength, offset + maskLength + payloadLength)\n\n      if (isMasked) {\n        const mask = this.buffer.slice(offset, offset + maskLength)\n        payload = this._unmaskPayload(payload, mask)\n      }\n\n      this.buffer = this.buffer.slice(offset + maskLength + payloadLength)\n\n      if (!isFinal) {\n        this.logger.warn(\"Fragmented frames are not supported yet\")\n        continue\n      }\n\n      if (opcode === WEBSOCKET_OPCODE_PING) {\n        this._sendControlFrame(WEBSOCKET_OPCODE_PONG, payload)\n        continue\n      }\n\n      if (opcode === WEBSOCKET_OPCODE_CLOSE) {\n        this._handleClose()\n        this.sendGoodbye(this.client)\n        continue\n      }\n\n      if (opcode !== WEBSOCKET_OPCODE_TEXT) {\n        this.logger.warn(`Unsupported websocket opcode: ${opcode}`)\n        continue\n      }\n\n      try {\n        const message = JSON.parse(payload.toString(\"utf-8\"))\n\n        this._handleMessage(message).catch((error) => {\n          this.logger.error(() => [\"Websocket message handler failed\", error])\n          this._sendJson({error: error.message, type: \"error\"})\n        })\n      } catch (error) {\n        this.logger.error(() => [\"Failed to parse websocket message\", error])\n        this._sendJson({error: \"Invalid websocket message\", type: \"error\"})\n      }\n    }\n  }\n\n  /**\n   * @param {number} opcode - Opcode.\n   * @param {Buffer} payload - Payload data.\n   * @returns {void} - No return value.\n   */\n  _sendControlFrame(opcode, payload) {\n    const header = Buffer.alloc(2)\n\n    header[0] = WEBSOCKET_FINAL_FRAME | opcode\n    header[1] = payload.length\n\n    this.client.events.emit(\"output\", Buffer.concat([header, payload]))\n  }\n\n  /**\n   * @param {object} body - Request body.\n   * @returns {void} - No return value.\n   */\n  _sendJson(body) {\n    const json = JSON.stringify(body)\n    const payload = Buffer.from(json, \"utf-8\")\n    let header\n\n    if (payload.length < 126) {\n      header = Buffer.alloc(2)\n      header[1] = payload.length\n    } else if (payload.length < 65536) {\n      header = Buffer.alloc(4)\n      header[1] = 126\n      header.writeUInt16BE(payload.length, 2)\n    } else {\n      header = Buffer.alloc(10)\n      header[1] = 127\n      header.writeBigUInt64BE(BigInt(payload.length), 2)\n    }\n\n    header[0] = WEBSOCKET_FINAL_FRAME | WEBSOCKET_OPCODE_TEXT\n\n    this.client.events.emit(\"output\", Buffer.concat([header, payload]))\n  }\n\n  /**\n   * @param {string} channel - Channel name.\n   * @param {{acknowledge?: boolean}} [options] - Subscribe options.\n   * @returns {Promise<boolean>} - Whether the subscription was added.\n   */\n  async subscribeToChannel(channel, {acknowledge = true} = {}) {\n    this.addSubscription(channel)\n    if (acknowledge) {\n      this._sendJson({channel, type: \"subscribed\"})\n    }\n    return true\n  }\n\n  _handleClose() {\n    void this._teardownChannel()\n    this.events.emit(\"close\")\n  }\n\n  async _teardownChannel() {\n    for (const channel of this.channels) {\n      await this._teardownSingleChannel(channel)\n    }\n    this.channels.clear()\n  }\n\n  async _teardownSingleChannel(channel) {\n    try {\n      await channel?.unsubscribed?.()\n    } catch (error) {\n      this.logger.error(() => [\"Failed to teardown websocket channel\", error])\n    }\n  }\n\n  async _registerChannel(channel) {\n    if (!channel) return\n\n    this.channels.add(channel)\n    await channel?.subscribed?.()\n  }\n\n  async _handleChannelSubscription({channel, params}) {\n    const resolver = this.configuration.getWebsocketChannelResolver?.()\n\n    if (!resolver) return\n\n    try {\n      const resolved = await resolver({\n        client: this.client,\n        configuration: this.configuration,\n        request: this.upgradeRequest,\n        subscription: {channel, params},\n        websocketSession: this\n      })\n\n      if (!resolved) {\n        this._sendJson({channel, error: \"Subscription rejected\", type: \"error\"})\n        return\n      }\n\n      const channelInstance = typeof resolved === \"function\"\n        ? new resolved({\n          client: this.client,\n          configuration: this.configuration,\n          request: this.upgradeRequest,\n          subscriptionParams: params,\n          websocketSession: this\n        })\n        : resolved\n\n      if (channelInstance && !(channelInstance instanceof WebsocketChannel)) {\n        throw new Error(\"Resolved websocket channel must extend WebsocketChannel\")\n      }\n\n      await this._registerChannel(channelInstance)\n    } catch (error) {\n      this.logger.warn(() => [\"Websocket channel subscription failed\", error])\n      this._sendJson({channel, error: \"Subscription rejected\", type: \"error\"})\n    }\n  }\n\n  /**\n   * @param {Buffer} payload - Payload data.\n   * @param {Buffer} mask - Mask.\n   * @returns {Buffer} - The unmask payload.\n   */\n  _unmaskPayload(payload, mask) {\n    /** @type {Buffer} */\n    const result = Buffer.alloc(payload.length)\n\n    for (let i = 0; i < payload.length; i++) {\n      result[i] = payload[i] ^ mask[i % 4]\n    }\n\n    return result\n  }\n}\n"]}

package/build/src/http-server/websocket-channel.d.ts

@@ -5,17 +5,20 @@ export default class VelociousHttpServerWebsocketChannel {
      * @param {import("./client/request.js").default | import("./client/websocket-request.js").default | undefined} args.request - Request instance.
      * @param {import("./client/index.js").default} args.client - Client instance.
      * @param {import("./client/websocket-session.js").default} args.websocketSession - Websocket session.
+     * @param {Record<string, unknown>} [args.subscriptionParams] - Params from subscribe message.
      */
-    constructor({ configuration, request, client, websocketSession }: {
+    constructor({ configuration, request, client, websocketSession, subscriptionParams }: {
         configuration: import("../configuration.js").default;
         request: import("./client/request.js").default | import("./client/websocket-request.js").default | undefined;
         client: import("./client/index.js").default;
         websocketSession: import("./client/websocket-session.js").default;
+        subscriptionParams?: Record<string, unknown>;
     });
     configuration: import("../configuration.js").default;
     request: import("./client/websocket-request.js").default | import("./client/request.js").default;
     client: import("./client/index.js").default;
     websocketSession: import("./client/websocket-session.js").default;
+    subscriptionParams: Record<string, unknown>;
     _params: Record<string, unknown>;
     /**
      * @returns {Record<string, unknown>} - Params for the websocket connection.

package/build/src/http-server/websocket-channel.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"websocket-channel.d.ts","sourceRoot":"","sources":["../../../src/http-server/websocket-channel.js"],"names":[],"mappings":"AAEA;IACE;;;;;;OAMG;IACH,kEALG;QAAoD,aAAa,EAAzD,OAAO,qBAAqB,EAAE,OAAO;QACqE,OAAO,EAAjH,OAAO,qBAAqB,EAAE,OAAO,GAAG,OAAO,+BAA+B,EAAE,OAAO,GAAG,SAAS;QACzD,MAAM,EAAhD,OAAO,mBAAmB,EAAE,OAAO;QACmB,gBAAgB,EAAtE,OAAO,+BAA+B,EAAE,OAAO;KACzD,EAOA;IALC,qDAAkC;IAClC,iGAAsB;IACtB,4CAAoB;IACpB,kEAAwC;IACxC,iCAAkC;IAGpC;;OAEG;IACH,UAFa,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAEJ;IAEhC;;;OAGG;IACH,cAFa,OAAO,CAAC,IAAI,CAAC,CAEL;IAErB;;;OAGG;IACH,gBAFa,OAAO,CAAC,IAAI,CAAC,CAEH;IAEvB;;;;OAIG;IACH,oBAHW,MAAM,GACJ,OAAO,CAAC,OAAO,CAAC,CAI5B;IAED;;OAEG;IACH,gBAFa,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CA4BnC;CACF"}
+{"version":3,"file":"websocket-channel.d.ts","sourceRoot":"","sources":["../../../src/http-server/websocket-channel.js"],"names":[],"mappings":"AAEA;IACE;;;;;;;OAOG;IACH,sFANG;QAAoD,aAAa,EAAzD,OAAO,qBAAqB,EAAE,OAAO;QACqE,OAAO,EAAjH,OAAO,qBAAqB,EAAE,OAAO,GAAG,OAAO,+BAA+B,EAAE,OAAO,GAAG,SAAS;QACzD,MAAM,EAAhD,OAAO,mBAAmB,EAAE,OAAO;QACmB,gBAAgB,EAAtE,OAAO,+BAA+B,EAAE,OAAO;QAChB,kBAAkB,GAAjD,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;KACjC,EAQA;IANC,qDAAkC;IAClC,iGAAsB;IACtB,4CAAoB;IACpB,kEAAwC;IACxC,4CAA4C;IAC5C,iCAAkC;IAGpC;;OAEG;IACH,UAFa,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAEJ;IAEhC;;;OAGG;IACH,cAFa,OAAO,CAAC,IAAI,CAAC,CAEL;IAErB;;;OAGG;IACH,gBAFa,OAAO,CAAC,IAAI,CAAC,CAEH;IAEvB;;;;OAIG;IACH,oBAHW,MAAM,GACJ,OAAO,CAAC,OAAO,CAAC,CAI5B;IAED;;OAEG;IACH,gBAFa,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAgCnC;CACF"}

package/build/src/http-server/websocket-channel.js

@@ -6,12 +6,14 @@ export default class VelociousHttpServerWebsocketChannel {
      * @param {import("./client/request.js").default | import("./client/websocket-request.js").default | undefined} args.request - Request instance.
      * @param {import("./client/index.js").default} args.client - Client instance.
      * @param {import("./client/websocket-session.js").default} args.websocketSession - Websocket session.
+     * @param {Record<string, unknown>} [args.subscriptionParams] - Params from subscribe message.
      */
-    constructor({ configuration, request, client, websocketSession }) {
+    constructor({ configuration, request, client, websocketSession, subscriptionParams }) {
         this.configuration = configuration;
         this.request = request;
         this.client = client;
         this.websocketSession = websocketSession;
+        this.subscriptionParams = subscriptionParams;
         this._params = this._buildParams();
     }
     /**
@@ -58,7 +60,10 @@ export default class VelociousHttpServerWebsocketChannel {
                 }
             }
         }
+        if (this.subscriptionParams && typeof this.subscriptionParams === "object") {
+            Object.assign(params, this.subscriptionParams);
+        }
         return params;
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -3,7 +3,7 @@
     "velocious": "build/bin/velocious.js"
   },
   "name": "velocious",
-  "version": "1.0.172",
+  "version": "1.0.173",
   "main": "build/index.js",
   "types": "build/index.d.ts",
   "files": [