@cspell/cspell-service-bus 6.4.2 → 6.5.0

package/dist/SystemServiceBus.d.ts

@@ -7,24 +7,20 @@ export interface SystemServiceBus extends Dispatcher {
     readonly subsystems: SubsystemServiceBus[];
 }
 export declare function createSystemServiceBus(): SystemServiceBus;
-declare const TypeRequestRegisterHandler: "System:RegisterHandler";
-export declare class RequestRegisterHandlerFactory extends ServiceRequest<typeof TypeRequestRegisterHandler, SubsystemServiceBus> {
+export declare const RequestRegisterHandlerFactory: ServiceRequestFactory<ServiceRequest<"System:RegisterHandler", {
     readonly requestPrefix: string;
     readonly handler: Handler;
-    static type: "System:RegisterHandler";
-    private constructor();
-    static is(req: ServiceRequest): req is RequestRegisterHandlerFactory;
-    static create(requestPrefix: string, handler: Handler): RequestRegisterHandlerFactory;
-}
-declare const TypeRequestCreateSubsystem: "System:CreateSubsystem";
-export declare class RequestCreateSubsystemFactory extends ServiceRequest<typeof TypeRequestCreateSubsystem, SubsystemServiceBus> {
+}, SubsystemServiceBus>, {
+    readonly requestPrefix: string;
+    readonly handler: Handler;
+}, "System:RegisterHandler">;
+export declare const RequestCreateSubsystemFactory: ServiceRequestFactory<ServiceRequest<"System:CreateSubsystem", {
     readonly name: string;
     readonly requestPattern: string | RegExp;
-    static type: "System:CreateSubsystem";
-    private constructor();
-    static is(req: ServiceRequest): req is RequestCreateSubsystemFactory;
-    static create(name: string, requestPattern: string | RegExp): RequestCreateSubsystemFactory;
-}
+}, SubsystemServiceBus>, {
+    readonly name: string;
+    readonly requestPattern: string | RegExp;
+}, "System:CreateSubsystem">;
 interface SubsystemServiceBus extends Dispatcher {
     readonly name: string;
     readonly requestPattern: string | RegExp;

package/dist/SystemServiceBus.js

@@ -4,6 +4,7 @@ exports.createSubsystemServiceBus = exports.RequestCreateSubsystemFactory = expo
 const assert_1 = require("./assert");
 const bus_1 = require("./bus");
 const request_1 = require("./request");
+const requestFactory_1 = require("./requestFactory");
 class SystemServiceBusImpl {
     constructor() {
         this.serviceBus = (0, bus_1.createServiceBus)();
@@ -12,8 +13,8 @@ class SystemServiceBusImpl {
         this.createSubsystem('Default Subsystem', '' /* match everything */);
     }
     bindDefaultHandlers() {
-        this.serviceBus.addHandler((0, bus_1.createRequestHandler)(RequestCreateSubsystemFactory, (req) => {
-            const { name, requestPattern } = req;
+        this.serviceBus.addHandler((0, bus_1.createRequestHandler)(exports.RequestCreateSubsystemFactory, (req) => {
+            const { name, requestPattern } = req.params;
             const sub = createSubsystemServiceBus(name, requestPattern);
             this._subsystems.push(sub);
             this.serviceBus.addHandler(sub.handler);
@@ -24,12 +25,12 @@ class SystemServiceBusImpl {
         return this.serviceBus.dispatch(request);
     }
     createSubsystem(name, requestPattern) {
-        const res = this.dispatch(RequestCreateSubsystemFactory.create(name, requestPattern));
+        const res = this.dispatch(exports.RequestCreateSubsystemFactory.create({ name, requestPattern }));
         (0, assert_1.assert)(res?.value);
         return res.value;
     }
     registerHandler(requestPrefix, handler) {
-        const request = RequestRegisterHandlerFactory.create(requestPrefix, handler);
+        const request = exports.RequestRegisterHandlerFactory.create({ requestPrefix, handler });
         this.serviceBus.dispatch(request);
     }
     registerRequestHandler(requestDef, fn, name, description) {
@@ -44,37 +45,9 @@ function createSystemServiceBus() {
 }
 exports.createSystemServiceBus = createSystemServiceBus;
 const TypeRequestRegisterHandler = 'System:RegisterHandler';
-class RequestRegisterHandlerFactory extends request_1.ServiceRequest {
-    constructor(requestPrefix, handler) {
-        super(RequestRegisterHandlerFactory.type);
-        this.requestPrefix = requestPrefix;
-        this.handler = handler;
-    }
-    static is(req) {
-        return req instanceof RequestRegisterHandlerFactory;
-    }
-    static create(requestPrefix, handler) {
-        return new RequestRegisterHandlerFactory(requestPrefix, handler);
-    }
-}
-exports.RequestRegisterHandlerFactory = RequestRegisterHandlerFactory;
-RequestRegisterHandlerFactory.type = TypeRequestRegisterHandler;
+exports.RequestRegisterHandlerFactory = (0, requestFactory_1.requestFactory)(TypeRequestRegisterHandler);
 const TypeRequestCreateSubsystem = 'System:CreateSubsystem';
-class RequestCreateSubsystemFactory extends request_1.ServiceRequest {
-    constructor(name, requestPattern) {
-        super(RequestCreateSubsystemFactory.type);
-        this.name = name;
-        this.requestPattern = requestPattern;
-    }
-    static is(req) {
-        return req instanceof RequestCreateSubsystemFactory;
-    }
-    static create(name, requestPattern) {
-        return new RequestCreateSubsystemFactory(name, requestPattern);
-    }
-}
-exports.RequestCreateSubsystemFactory = RequestCreateSubsystemFactory;
-RequestCreateSubsystemFactory.type = TypeRequestCreateSubsystem;
+exports.RequestCreateSubsystemFactory = (0, requestFactory_1.requestFactory)(TypeRequestCreateSubsystem);
 class SubsystemServiceBusImpl extends bus_1.ServiceBus {
     constructor(name, requestPattern) {
         super();
@@ -84,7 +57,7 @@ class SubsystemServiceBusImpl extends bus_1.ServiceBus {
             typeof requestPattern === 'string'
                 ? (reqType) => reqType.startsWith(requestPattern)
                 : (reqType) => requestPattern.test(reqType);
-        const handleRegistration = (0, bus_1.createRequestHandler)(RequestRegisterHandlerFactory, (req, next) => this.handleRegistrationReq(req, next), 'Subsystem Register Handlers for ' + name, `Matches against: <${requestPattern.toString()}>`);
+        const handleRegistration = (0, bus_1.createRequestHandler)(exports.RequestRegisterHandlerFactory, (req, next) => this.handleRegistrationReq(req, next), 'Subsystem Register Handlers for ' + name, `Matches against: <${requestPattern.toString()}>`);
         this.addHandler(handleRegistration);
         this.handler = {
             name: 'Subsystem: ' + name,
@@ -94,17 +67,17 @@ class SubsystemServiceBusImpl extends bus_1.ServiceBus {
     }
     handleRegistrationReq(request, next) {
         // console.log(`${this.name}.handleRegistrationReq %o`, request);
-        if (!this.canHandleType(request.requestPrefix)) {
+        if (!this.canHandleType(request.params.requestPrefix)) {
             // console.log(`${this.name}.handleRegistrationReq skip`);
             return next(request);
         }
         // console.log(`${this.name}.handleRegistrationReq add ***`);
-        this.addHandler(request.handler);
+        this.addHandler(request.params.handler);
         return (0, request_1.createResponse)(this);
     }
     _handler(dispatcher) {
         return (next) => (req) => {
-            if (!this.canHandleType(req.type) && !RequestRegisterHandlerFactory.is(req))
+            if (!this.canHandleType(req.type) && !exports.RequestRegisterHandlerFactory.is(req))
                 return next(req);
             const dispatch = this.reduceHandlers(this.handlers, req, dispatcher, next);
             return dispatch(req);

package/dist/bus.d.ts

@@ -1,4 +1,4 @@
-import { IsARequest, RequestResponseType, ServiceRequest, ServiceRequestFactory } from './request';
+import { IsARequest, RequestResponseType, ServiceRequest, ServiceRequestFactory, ServiceRequestFactoryRequestType } from './request';
 export interface Dispatcher {
     dispatch<R extends ServiceRequest>(request: R): RequestResponseType<R>;
 }
@@ -12,13 +12,14 @@ export declare class ServiceBus implements Dispatcher {
     protected reduceHandlers<R extends ServiceRequest>(handlers: readonly Handler[], request: R, dispatcher: Dispatcher, defaultHandler: HandleRequest): HandleRequest;
 }
 export declare function createServiceBus(handlers?: Handler[]): ServiceBus;
-export declare type HandleRequestFn<R extends ServiceRequest> = (request: R, next: HandleRequestKnown<R>, dispatch: Dispatcher) => RequestResponseType<R>;
+export declare type HandleRequestFn<R extends ServiceRequest> = (request: R, next: HandleRequest, dispatch: Dispatcher) => RequestResponseType<R>;
 export interface HandleRequest {
     <R extends ServiceRequest>(request: R): any;
 }
 export interface HandleRequestKnown<R extends ServiceRequest> {
     (request: R): RequestResponseType<R>;
 }
+export declare type FactoryRequestHandler<T extends ServiceRequestFactory<ServiceRequest>, R extends ServiceRequest = ServiceRequestFactoryRequestType<T>> = HandleRequestKnown<R>;
 export interface HandlerNext {
     (next: HandleRequest): HandleRequest;
 }

package/dist/index.d.ts

@@ -1,3 +1,4 @@
-export { ServiceRequest } from './request';
-export { ServiceBus, createServiceBus } from './bus';
+export { createRequestHandler, createServiceBus, ServiceBus } from './bus';
+export { createResponse, createResponseFail, isServiceResponseFailure, isServiceResponseSuccess, ServiceRequest, } from './request';
+export { requestFactory } from './requestFactory';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,9 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createServiceBus = exports.ServiceBus = exports.ServiceRequest = void 0;
-var request_1 = require("./request");
-Object.defineProperty(exports, "ServiceRequest", { enumerable: true, get: function () { return request_1.ServiceRequest; } });
+exports.requestFactory = exports.ServiceRequest = exports.isServiceResponseSuccess = exports.isServiceResponseFailure = exports.createResponseFail = exports.createResponse = exports.ServiceBus = exports.createServiceBus = exports.createRequestHandler = void 0;
 var bus_1 = require("./bus");
-Object.defineProperty(exports, "ServiceBus", { enumerable: true, get: function () { return bus_1.ServiceBus; } });
+Object.defineProperty(exports, "createRequestHandler", { enumerable: true, get: function () { return bus_1.createRequestHandler; } });
 Object.defineProperty(exports, "createServiceBus", { enumerable: true, get: function () { return bus_1.createServiceBus; } });
+Object.defineProperty(exports, "ServiceBus", { enumerable: true, get: function () { return bus_1.ServiceBus; } });
+var request_1 = require("./request");
+Object.defineProperty(exports, "createResponse", { enumerable: true, get: function () { return request_1.createResponse; } });
+Object.defineProperty(exports, "createResponseFail", { enumerable: true, get: function () { return request_1.createResponseFail; } });
+Object.defineProperty(exports, "isServiceResponseFailure", { enumerable: true, get: function () { return request_1.isServiceResponseFailure; } });
+Object.defineProperty(exports, "isServiceResponseSuccess", { enumerable: true, get: function () { return request_1.isServiceResponseSuccess; } });
+Object.defineProperty(exports, "ServiceRequest", { enumerable: true, get: function () { return request_1.ServiceRequest; } });
+var requestFactory_1 = require("./requestFactory");
+Object.defineProperty(exports, "requestFactory", { enumerable: true, get: function () { return requestFactory_1.requestFactory; } });
 //# sourceMappingURL=index.js.map

package/dist/request.d.ts

@@ -1,15 +1,16 @@
-export interface ServiceRequest<T extends string = string, R = unknown> {
+export interface ServiceRequest<T extends string = string, P = unknown, R = unknown> {
     readonly type: T;
+    readonly params: P;
     __r?: ServiceResponseBase<R>;
 }
-declare class BaseServiceRequest<T extends string, R> implements ServiceRequest<T, R> {
+declare class BaseServiceRequest<T extends string, P, R> implements ServiceRequest<T, P, R> {
     readonly type: T;
+    readonly params: P;
     readonly __r?: ServiceResponseBase<R>;
-    constructor(type: T);
+    constructor(type: T, params: P);
 }
-export declare class ServiceRequest<T extends string, R> extends BaseServiceRequest<T, R> {
-    readonly type: T;
-    constructor(type: T);
+export declare class ServiceRequest<T extends string, P, R> extends BaseServiceRequest<T, P, R> {
+    constructor(type: T, params: P);
 }
 interface ServiceResponseBase<T> {
     ___T?: T;
@@ -38,11 +39,15 @@ export declare function isServiceResponseFailure<T>(res: ServiceResponseBase<T>)
 export declare function isInstanceOfFn<T>(constructor: {
     new (): T;
 }): (t: unknown) => t is T;
-export interface ServiceRequestFactory<R extends ServiceRequest, T extends string = R['type']> {
+export interface ServiceRequestFactory<R extends ServiceRequest, P = R['params'], T extends string = R['type']> {
     type: T;
     is: (r: ServiceRequest | R) => r is R;
-    create(...params: any[]): R;
+    create(params: P): R;
+    __request?: R;
 }
+export declare type ServiceRequestFactoryRequestType<T> = T extends {
+    __request?: infer R;
+} ? R : never;
 export declare const __testing__: {
     BaseServiceRequest: typeof BaseServiceRequest;
 };

package/dist/request.js

@@ -2,14 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.__testing__ = exports.isInstanceOfFn = exports.isServiceResponseFailure = exports.isServiceResponseSuccess = exports.createResponseFail = exports.createResponse = exports.ServiceRequest = void 0;
 class BaseServiceRequest {
-    constructor(type) {
+    constructor(type, params) {
         this.type = type;
+        this.params = params;
     }
 }
 class ServiceRequest extends BaseServiceRequest {
-    constructor(type) {
-        super(type);
-        this.type = type;
+    constructor(type, params) {
+        super(type, params);
     }
 }
 exports.ServiceRequest = ServiceRequest;

package/dist/requestFactory.d.ts

@@ -0,0 +1,3 @@
+import { ServiceRequest, ServiceRequestFactory } from './request';
+export declare function requestFactory<T extends string, P, R>(requestType: T): ServiceRequestFactory<ServiceRequest<T, P, R>>;
+//# sourceMappingURL=requestFactory.d.ts.map

package/dist/requestFactory.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requestFactory = void 0;
+const request_1 = require("./request");
+function requestFactory(requestType) {
+    class RequestClass extends request_1.ServiceRequest {
+        constructor(params) {
+            super(requestType, params);
+        }
+        static is(req) {
+            return req instanceof RequestClass && req.type === requestType;
+        }
+        static create(params) {
+            return new RequestClass(params);
+        }
+    }
+    RequestClass.type = requestType;
+    return RequestClass;
+}
+exports.requestFactory = requestFactory;
+//# sourceMappingURL=requestFactory.js.map

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "6.4.2",
+  "version": "6.5.0",
   "description": "A Library for connecting requests to services that can fulfill them.",
   "keywords": [
     "cspell"
@@ -74,5 +74,5 @@
     "jest": "^28.1.3",
     "rimraf": "^3.0.2"
   },
-  "gitHead": "1f7481fd7d6a561de92ba49870da6eb1441a9d20"
+  "gitHead": "65c80b01e17bb0d74b57ef8b29309684a8588e27"
 }