@cspell/cspell-service-bus 6.2.4-alpha.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 Jason Dent
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,3 @@
+# `@cspell/cspell-service-bus`
+
+A Library for connecting requests to services that can fulfill them.

package/dist/bus.d.ts

@@ -0,0 +1,33 @@
+import { IsARequest, RequestResponseType, ServiceRequest } from './request';
+export interface Dispatcher {
+    dispatch<R extends ServiceRequest>(request: R): R['__r'];
+}
+export declare class ServiceBus implements Dispatcher {
+    readonly handlers: Handler[];
+    constructor(handlers: Handler[]);
+    addHandler(handler: Handler): void;
+    dispatch<R extends ServiceRequest>(request: R): RequestResponseType<R>;
+}
+export declare function createServiceBus(handlers?: Handler[]): ServiceBus;
+export declare type HandleRequestFn<R extends ServiceRequest> = (request: R) => RequestResponseType<R>;
+export interface HandleRequest {
+    <R extends ServiceRequest>(request: R): RequestResponseType<any>;
+}
+interface HandlerNext {
+    (next: HandleRequest): HandleRequest;
+}
+export interface Handler {
+    (dispatcher: Dispatcher): HandlerNext;
+}
+export declare function createRequestHandler<T extends ServiceRequest>(isA: IsARequest<T>, fn: HandleRequestFn<T>): Handler;
+export declare class ErrorUnhandledRequest extends Error {
+    readonly request: ServiceRequest;
+    constructor(request: ServiceRequest);
+}
+export declare class ErrorServiceRequestDepthExceeded extends Error {
+    readonly request: ServiceRequest;
+    readonly depth: number;
+    constructor(request: ServiceRequest, depth: number);
+}
+export {};
+//# sourceMappingURL=bus.d.ts.map

package/dist/bus.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrorServiceRequestDepthExceeded = exports.ErrorUnhandledRequest = exports.createRequestHandler = exports.createServiceBus = exports.ServiceBus = void 0;
+const request_1 = require("./request");
+const MAX_DEPTH = 10;
+class ServiceBus {
+    constructor(handlers) {
+        this.handlers = handlers;
+    }
+    addHandler(handler) {
+        this.handlers.push(handler);
+    }
+    dispatch(request) {
+        let depth = 0;
+        const dispatcher = {
+            dispatch,
+        };
+        const unhandledHandler = (request) => {
+            return (0, request_1.createResponseFail)(request, new ErrorUnhandledRequest(request));
+        };
+        const handlers = this.handlers.reverse().map((m) => m(dispatcher));
+        function dispatch(request) {
+            ++depth;
+            if (depth >= MAX_DEPTH) {
+                return (0, request_1.createResponseFail)(request, new ErrorServiceRequestDepthExceeded(request, depth));
+            }
+            const defaultHandler = unhandledHandler;
+            const handler = handlers.reduce((next, h) => h(next), defaultHandler);
+            const response = handler(request);
+            --depth;
+            return response;
+        }
+        return dispatch(request);
+    }
+}
+exports.ServiceBus = ServiceBus;
+function createServiceBus(handlers = []) {
+    return new ServiceBus(handlers);
+}
+exports.createServiceBus = createServiceBus;
+function createRequestHandler(isA, fn) {
+    return (_service) => (next) => (request) => isA(request) ? fn(request) : next(request);
+}
+exports.createRequestHandler = createRequestHandler;
+class ErrorUnhandledRequest extends Error {
+    constructor(request) {
+        super(`Unhandled Request: ${request.type}`);
+        this.request = request;
+    }
+}
+exports.ErrorUnhandledRequest = ErrorUnhandledRequest;
+class ErrorServiceRequestDepthExceeded extends Error {
+    constructor(request, depth) {
+        super(`Service Request Depth ${depth} Exceeded: ${request.type}`);
+        this.request = request;
+        this.depth = depth;
+    }
+}
+exports.ErrorServiceRequestDepthExceeded = ErrorServiceRequestDepthExceeded;
+//# sourceMappingURL=bus.js.map

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { ServiceRequest, ServiceRequestAsync, ServiceRequestSync } from './request';
+export { ServiceBus, createServiceBus } from './bus';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createServiceBus = exports.ServiceBus = exports.ServiceRequestSync = exports.ServiceRequestAsync = void 0;
+var request_1 = require("./request");
+Object.defineProperty(exports, "ServiceRequestAsync", { enumerable: true, get: function () { return request_1.ServiceRequestAsync; } });
+Object.defineProperty(exports, "ServiceRequestSync", { enumerable: true, get: function () { return request_1.ServiceRequestSync; } });
+var bus_1 = require("./bus");
+Object.defineProperty(exports, "ServiceBus", { enumerable: true, get: function () { return bus_1.ServiceBus; } });
+Object.defineProperty(exports, "createServiceBus", { enumerable: true, get: function () { return bus_1.createServiceBus; } });
+//# sourceMappingURL=index.js.map

package/dist/request.d.ts

@@ -0,0 +1,43 @@
+export interface ServiceRequest<T = string, R = unknown> {
+    readonly type: T;
+    __r?: ServiceResponseBase<R>;
+}
+export declare class BaseServiceRequest<T extends string, R> implements ServiceRequest<T, R> {
+    readonly type: T;
+    readonly __r?: ServiceResponseBase<R>;
+    constructor(type: T);
+}
+export declare class ServiceRequestSync<T extends string, R> extends BaseServiceRequest<T, R> {
+    readonly sync = true;
+    constructor(type: T);
+}
+export declare class ServiceRequestAsync<T extends string, R> extends BaseServiceRequest<T, R> {
+    constructor(type: T);
+}
+interface ServiceResponseBase<T> {
+    ___T?: T;
+}
+export interface ServiceResponseSuccess<T> extends ServiceResponseBase<T> {
+    value: T;
+    error?: undefined;
+}
+export interface ServiceResponseFailure<T> extends ServiceResponseBase<T> {
+    error: Error;
+}
+export declare type ServiceResponse<T> = ServiceResponseSuccess<T> | ServiceResponseFailure<T>;
+export declare type IsARequest<T extends ServiceRequest> = (r: ServiceRequest) => r is T;
+export declare function createResponse<T>(value: T): ServiceResponseSuccess<T>;
+declare type VT<T> = T extends {
+    ___T?: infer R;
+} ? R : never;
+export declare type RequestResponseType<T> = T extends {
+    __r?: infer R;
+} ? R : never;
+export declare function createResponseFail<R extends ServiceRequest, E extends Error>(_request: R, error: E): ServiceResponseFailure<VT<RequestResponseType<R>>>;
+export declare function isServiceResponseSuccess<T>(res: ServiceResponseBase<T>): res is ServiceResponseSuccess<T>;
+export declare function isServiceResponseFailure<T>(res: ServiceResponseBase<T>): res is ServiceResponseFailure<T>;
+export declare function isInstanceOfFn<T>(constructor: {
+    new (): T;
+}): (t: unknown) => t is T;
+export {};
+//# sourceMappingURL=request.d.ts.map

package/dist/request.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isInstanceOfFn = exports.isServiceResponseFailure = exports.isServiceResponseSuccess = exports.createResponseFail = exports.createResponse = exports.ServiceRequestAsync = exports.ServiceRequestSync = exports.BaseServiceRequest = void 0;
+class BaseServiceRequest {
+    constructor(type) {
+        this.type = type;
+    }
+}
+exports.BaseServiceRequest = BaseServiceRequest;
+class ServiceRequestSync extends BaseServiceRequest {
+    constructor(type) {
+        super(type);
+        this.sync = true;
+    }
+}
+exports.ServiceRequestSync = ServiceRequestSync;
+class ServiceRequestAsync extends BaseServiceRequest {
+    constructor(type) {
+        super(type);
+    }
+}
+exports.ServiceRequestAsync = ServiceRequestAsync;
+function createResponse(value) {
+    return { value };
+}
+exports.createResponse = createResponse;
+function createResponseFail(_request, error) {
+    return { error };
+}
+exports.createResponseFail = createResponseFail;
+function isServiceResponseSuccess(res) {
+    return 'value' in res && res.error === undefined;
+}
+exports.isServiceResponseSuccess = isServiceResponseSuccess;
+function isServiceResponseFailure(res) {
+    return res.error !== undefined;
+}
+exports.isServiceResponseFailure = isServiceResponseFailure;
+function isInstanceOfFn(constructor) {
+    return (t) => t instanceof constructor;
+}
+exports.isInstanceOfFn = isInstanceOfFn;
+//# sourceMappingURL=request.js.map

package/package.json

@@ -0,0 +1,78 @@
+{
+  "name": "@cspell/cspell-service-bus",
+  "publishConfig": {
+    "access": "public"
+  },
+  "version": "6.2.4-alpha.0",
+  "description": "A Library for connecting requests to services that can fulfill them.",
+  "keywords": [
+    "cspell"
+  ],
+  "author": "Jason Dent <jason@streetsidesoftware.nl>",
+  "homepage": "https://github.com/streetsidesoftware/cspell/tree/main/packages/cspell-service-bus#readme",
+  "license": "MIT",
+  "main": "dist/index.js",
+  "directories": {
+    "dist": "dist"
+  },
+  "exports": {
+    ".": {
+      "require": "./dist/index.js"
+    },
+    "./*": {
+      "require": "./dist/*.js"
+    },
+    "./index": "./dist/index.js",
+    "./index.js": "./dist/index.js",
+    "./index.d.ts": "./dist/index.d.ts"
+  },
+  "typings": "dist/index.d.ts",
+  "typesVersions": {
+    "*": {
+      "index.d.ts": [
+        "dist/index.d.ts"
+      ],
+      "dist/index.d.ts": [
+        "dist/index.d.ts"
+      ],
+      "*": [
+        "dist/*",
+        "dist/*/index.d.ts"
+      ]
+    }
+  },
+  "files": [
+    "dist",
+    "!**/__mocks__",
+    "!**/*.spec.*",
+    "!**/*.test.*",
+    "!**/test/**",
+    "!**/*.map"
+  ],
+  "scripts": {
+    "build": "tsc -p .",
+    "build-dev": "tsc -p tsconfig.dev.json",
+    "watch": "tsc -p . -w",
+    "clean": "rimraf dist coverage .tsbuildinfo",
+    "clean-build": "npm run clean && npm run build",
+    "coverage": "jest --coverage",
+    "test-watch": "jest --watch",
+    "test": "jest"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/streetsidesoftware/cspell.git"
+  },
+  "bugs": {
+    "url": "https://github.com/streetsidesoftware/cspell/labels/cspell-service-bus"
+  },
+  "engines": {
+    "node": ">=14"
+  },
+  "devDependencies": {
+    "@types/node": "^18.0.3",
+    "jest": "^28.1.2",
+    "rimraf": "^3.0.2"
+  },
+  "gitHead": "3509b9fb14722e573713ba1828af6da6088a24e8"
+}