@silenteer/natsu - npm Package Compare versions

Comparing version 1.0.13 to 1.0.14

dist/index.d.ts

 import NatsClient from './nats-client';
-export type { NatsRequest, NatsResponse, NatsInjection, NatsHandleResult, NatsAuthorizationResult, NatsValidationResult, NatsValidate, NatsAuthorize, NatsHandle, NatsHandler, } from './type';
-export { NatsValidationResultUtil, NatsAuthorizationResultUtil, NatsHandleResultUtil, } from './utility';
+export type { NatsRequest, NatsResponse, NatsInjection, NatsValidationResult, NatsAuthorizationResult, NatsHandleResult, NatsMiddlewareValidationResult, NatsMiddlewareAuthorizationResult, NatsMiddlewareHandleResult, NatsValidate, NatsAfterValidate, NatsBeforeAuthorize, NatsAuthorize, NatsAfterAuthorize, NatsBeforeHandle, NatsHandle, NatsAfterHandle, NatsHandler, NatsBeforeValidateMiddleware, NatsAfterValidateMiddleware, NatsBeforeAuthorizeMiddleware, NatsAfterAuthorizeMiddleware, NatsBeforeHandleMiddleware, NatsAfterHandleMiddleware, } from './type';
+export { NatsValidationResultUtil, NatsAuthorizationResultUtil, NatsHandleResultUtil, NatsMiddlewareValidationResultUtil, NatsMiddlewareAuthorizationResultUtil, NatsMiddlewareHandleResultUtil, } from './utility';
 export default NatsClient;

dist/index.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.NatsHandleResultUtil = exports.NatsAuthorizationResultUtil = exports.NatsValidationResultUtil = void 0;
+exports.NatsMiddlewareHandleResultUtil = exports.NatsMiddlewareAuthorizationResultUtil = exports.NatsMiddlewareValidationResultUtil = exports.NatsHandleResultUtil = exports.NatsAuthorizationResultUtil = exports.NatsValidationResultUtil = void 0;
 const tslib_1 = require("tslib");
@@ -10,3 +10,6 @@ const nats_client_1 = (0, tslib_1.__importDefault)(require("./nats-client"));
 Object.defineProperty(exports, "NatsHandleResultUtil", { enumerable: true, get: function () { return utility_1.NatsHandleResultUtil; } });
+Object.defineProperty(exports, "NatsMiddlewareValidationResultUtil", { enumerable: true, get: function () { return utility_1.NatsMiddlewareValidationResultUtil; } });
+Object.defineProperty(exports, "NatsMiddlewareAuthorizationResultUtil", { enumerable: true, get: function () { return utility_1.NatsMiddlewareAuthorizationResultUtil; } });
+Object.defineProperty(exports, "NatsMiddlewareHandleResultUtil", { enumerable: true, get: function () { return utility_1.NatsMiddlewareHandleResultUtil; } });
 exports.default = nats_client_1.default;
 //# sourceMappingURL=index.js.map

dist/nats-client.d.ts

@@ -1,4 +0,2 @@
-import * as Sentry from '@sentry/node';
-import type { NatsService } from './type';
-import type { NatsRequest, NatsHandler } from './type';
+import type { NatsService, NatsHandler } from './type';
 declare const _default: {
@@ -15,6 +13,2 @@ setup: <TInjection extends Record<string, unknown>>(params: {
         };
-        sentry?: {
-            options: Pick<Sentry.NodeOptions, 'dsn' | 'tracesSampleRate' | 'environment' | 'release' | 'enabled' | 'serverName'>;
-            getUser: (data: NatsRequest<unknown>) => Sentry.User;
-        };
     }) => {
@@ -21,0 +15,0 @@ start: () => Promise<void>;

dist/nats-client.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
-/* eslint-disable @typescript-eslint/ban-types */
-const Sentry = (0, tslib_1.__importStar)(require("@sentry/node"));
-const tracing_1 = require("@sentry/tracing");
 const nats_1 = require("nats");
+const requestCodec = (0, nats_1.JSONCodec)();
+const responseCodec = (0, nats_1.JSONCodec)();
 const clients = {};
@@ -17,3 +16,3 @@ function start(params) {
         }
-        const { urls, user, pass, verbose, sentry } = params;
+        const { urls, user, pass, verbose } = params;
         const key = getClientKey(urls);
@@ -24,5 +23,2 @@ if (!clients[key]) {
         if (!clients[key].natsService) {
-            if (sentry) {
-                Sentry.init(Object.assign({ integrations: [new Sentry.Integrations.Http({ tracing: true })], tracesSampleRate: 1.0 }, sentry.options));
-            }
             const client = yield (0, nats_1.connect)({
@@ -37,4 +33,2 @@ servers: urls,
             clients[key] = Object.assign(Object.assign({}, clients[key]), { natsService: createNatsService({ client, namespace: params.namespace }) });
-            const requestCodec = (0, nats_1.JSONCodec)();
-            const responseCodec = (0, nats_1.JSONCodec)();
             Object.entries(clients[key].handlers).forEach(([subject, handler]) => {
@@ -51,3 +45,3 @@ const natsService = clients[key].natsService;
                                 : undefined;
-                            let transaction;
+                            let injection;
                             try {
@@ -64,103 +58,107 @@ if (!data) {
                                 }
-                                Sentry.setUser(sentry.getUser(data));
-                                transaction = Sentry.startTransaction({
-                                    name: subject,
-                                    traceId: data.headers['trace-id'],
+                                injection = Object.assign(Object.assign({}, params.injections), { subject,
+                                    message,
+                                    natsService });
+                                //#region Validate
+                                const beforeValidateResult = yield beforeValidate({
+                                    message,
+                                    data,
+                                    injection,
+                                    handler,
                                 });
-                                Sentry.getCurrentHub().configureScope((scope) => scope.setSpan(transaction));
-                                const injection = Object.assign(Object.assign({}, params.injections), { message,
-                                    natsService });
-                                if (handler.validate) {
-                                    const validateSpan = transaction.startChild({
-                                        description: `${subject} - validate`,
-                                    });
-                                    try {
-                                        const validationResult = yield handler.validate(data, injection);
-                                        if (validationResult.code !== 'OK') {
-                                            respond({
-                                                message,
-                                                data: responseCodec.encode(Object.assign(Object.assign({}, data), { code: validationResult.code, body: encodeBody(validationResult.errors) })),
-                                            });
-                                            validateSpan.setStatus((0, tracing_1.spanStatusfromHttpCode)(validationResult.code));
-                                            validateSpan.finish();
-                                            transaction.finish();
-                                            continue;
-                                        }
-                                        else {
-                                            validateSpan.setStatus('ok');
-                                            validateSpan.finish();
-                                        }
-                                    }
-                                    catch (error) {
-                                        validateSpan.setStatus('internal_error');
-                                        validateSpan.finish();
-                                        throw error;
-                                    }
+                                if (beforeValidateResult && beforeValidateResult.code !== 'OK') {
+                                    continue;
                                 }
-                                if (handler.authorize) {
-                                    const authorizeSpan = transaction.startChild({
-                                        description: `${subject} - authorize`,
-                                    });
-                                    try {
-                                        const authorizationResult = yield handler.authorize(data, injection);
-                                        if (authorizationResult.code !== 'OK') {
-                                            respond({
-                                                message,
-                                                data: responseCodec.encode(Object.assign(Object.assign({}, data), { code: authorizationResult.code, body: encodeBody(authorizationResult.message) })),
-                                            });
-                                            authorizeSpan.setStatus((0, tracing_1.spanStatusfromHttpCode)(authorizationResult.code));
-                                            authorizeSpan.finish();
-                                            transaction.finish();
-                                            continue;
-                                        }
-                                        else {
-                                            authorizeSpan.setStatus('ok');
-                                            authorizeSpan.finish();
-                                        }
-                                    }
-                                    catch (error) {
-                                        authorizeSpan.setStatus('internal_error');
-                                        authorizeSpan.finish();
-                                        throw error;
-                                    }
+                                else if (beforeValidateResult) {
+                                    data = beforeValidateResult.data;
                                 }
-                                if (handler.handle) {
-                                    const handleSpan = transaction.startChild({
-                                        description: `${subject} - handle`,
-                                    });
-                                    try {
-                                        const handleResult = yield handler.handle(data, injection);
-                                        if (handleResult.code !== 200) {
-                                            respond({
-                                                message,
-                                                data: responseCodec.encode(Object.assign(Object.assign({}, data), { code: handleResult.code, body: encodeBody(handleResult.errors) })),
-                                            });
-                                            const _b = data.headers, { cookie } = _b, headers = (0, tslib_1.__rest)(_b, ["cookie"]);
-                                            Sentry.captureMessage(`${subject} [${handleResult.code}]`, {
-                                                extra: {
-                                                    body: data.body,
-                                                    headers,
-                                                    errors: handleResult.errors,
-                                                },
-                                            });
-                                            handleSpan.setStatus((0, tracing_1.spanStatusfromHttpCode)(handleResult.code));
-                                        }
-                                        else {
-                                            respond({
-                                                message,
-                                                data: responseCodec.encode(Object.assign(Object.assign({}, data), { headers: handleResult.headers
-                                                        ? Object.assign(Object.assign({}, data.headers), handleResult.headers) : data.headers, code: handleResult.code, body: encodeBody(handleResult.body) })),
-                                            });
-                                            handleSpan.setStatus('ok');
-                                        }
+                                const validateResult = yield validate({
+                                    message,
+                                    data,
+                                    injection,
+                                    handler,
+                                });
+                                if (validateResult && validateResult.code !== 'OK') {
+                                    continue;
+                                }
+                                const afterValidateResult = yield afterValidate({
+                                    message,
+                                    data,
+                                    injection,
+                                    handler,
+                                });
+                                if (afterValidateResult && afterValidateResult.code !== 'OK') {
+                                    continue;
+                                }
+                                else if (afterValidateResult) {
+                                    data = afterValidateResult.data;
+                                }
+                                //#endregion
+                                //#region Authorize
+                                const beforeAuthorizeResult = yield beforeAuthorize({
+                                    message,
+                                    data,
+                                    injection,
+                                    handler,
+                                });
+                                if (beforeAuthorizeResult && beforeAuthorizeResult.code !== 'OK') {
+                                    continue;
+                                }
+                                else if (beforeAuthorizeResult) {
+                                    data = beforeAuthorizeResult.data;
+                                }
+                                const authorizeResult = yield authorize({
+                                    message,
+                                    data,
+                                    injection,
+                                    handler,
+                                });
+                                if (authorizeResult && authorizeResult.code !== 'OK') {
+                                    continue;
+                                }
+                                const afterAuthorizeResult = yield afterAuthorize({
+                                    message,
+                                    data,
+                                    injection,
+                                    handler,
+                                });
+                                if (afterAuthorizeResult && afterAuthorizeResult.code !== 'OK') {
+                                    continue;
+                                }
+                                else if (afterAuthorizeResult) {
+                                    data = afterAuthorizeResult.data;
+                                }
+                                //#endregion
+                                //#region Handle
+                                const beforeHandleResult = yield beforeHandle({
+                                    message,
+                                    data,
+                                    injection,
+                                    handler,
+                                });
+                                if (beforeHandleResult && beforeHandleResult.code !== 'OK') {
+                                    continue;
+                                }
+                                else if (beforeHandleResult) {
+                                    data = beforeHandleResult.data;
+                                }
+                                const handleResult = yield handle({
+                                    message,
+                                    data,
+                                    injection,
+                                    handler,
+                                });
+                                if (handleResult) {
+                                    if (handleResult.code === 200) {
+                                        yield afterHandle({
+                                            message,
+                                            data,
+                                            result: handleResult,
+                                            injection,
+                                            handler,
+                                        });
                                     }
-                                    catch (error) {
-                                        handleSpan.setStatus('internal_error');
-                                        handleSpan.finish();
-                                        throw error;
-                                    }
-                                    handleSpan.finish();
-                                    transaction.finish();
                                     continue;
                                 }
+                                //#endregion
                                 respond({ message });
@@ -170,19 +168,10 @@ }
                                 console.error(error);
-                                const _c = data.headers, { cookie } = _c, headers = (0, tslib_1.__rest)(_c, ["cookie"]);
-                                Sentry.captureException(error, {
-                                    extra: {
-                                        subject,
-                                        body: data.body,
-                                        headers,
-                                        code: 500,
-                                    },
-                                });
-                                respond({
+                                yield respondUnhandledError({
                                     message,
-                                    data: responseCodec.encode(Object.assign(Object.assign({}, data), { body: data === null || data === void 0 ? void 0 : data.body, code: 500 })),
+                                    data,
+                                    error,
+                                    injection,
+                                    handler,
                                 });
                             }
-                            finally {
-                                transaction === null || transaction === void 0 ? void 0 : transaction.finish();
-                            }
                         }
@@ -278,2 +267,282 @@ }
 }
+function beforeValidate(params) {
+    var _a;
+    return (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
+        const { message, data, injection, handler } = params;
+        let validationResult;
+        if (((_a = handler.beforeValidateMiddlewares) === null || _a === void 0 ? void 0 : _a.length) > 0) {
+            for (const validateMiddleware of handler.beforeValidateMiddlewares) {
+                validationResult = yield validateMiddleware.handle(validationResult ? validationResult.data : data, injection);
+                if (validationResult.code !== 'OK') {
+                    yield handleErrorResponse({
+                        data: validationResult.data,
+                        error: {
+                            code: validationResult.code,
+                            errors: validationResult.errors,
+                        },
+                        injection,
+                        handler,
+                    });
+                    respond({
+                        message,
+                        data: responseCodec.encode(Object.assign(Object.assign({}, validationResult.data), { code: validationResult.code, body: encodeBody(validationResult.errors) })),
+                    });
+                    break;
+                }
+            }
+        }
+        return validationResult;
+    });
+}
+function validate(params) {
+    return (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
+        const { message, data, injection, handler } = params;
+        let validationResult;
+        if (handler.validate) {
+            validationResult = yield handler.validate(data, injection);
+            if (validationResult.code !== 'OK') {
+                yield handleErrorResponse({
+                    data,
+                    error: {
+                        code: validationResult.code,
+                        errors: validationResult.errors,
+                    },
+                    injection,
+                    handler,
+                });
+                respond({
+                    message,
+                    data: responseCodec.encode(Object.assign(Object.assign({}, data), { code: validationResult.code, body: encodeBody(validationResult.errors) })),
+                });
+            }
+        }
+        return validationResult;
+    });
+}
+function afterValidate(params) {
+    var _a;
+    return (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
+        const { message, data, injection, handler } = params;
+        let validationResult;
+        if (((_a = handler.afterValidateMiddlewares) === null || _a === void 0 ? void 0 : _a.length) > 0) {
+            for (const validateMiddleware of handler.afterValidateMiddlewares) {
+                validationResult = yield validateMiddleware.handle(validationResult ? validationResult.data : data, injection);
+                if (validationResult.code !== 'OK') {
+                    yield handleErrorResponse({
+                        data: validationResult.data,
+                        error: {
+                            code: validationResult.code,
+                            errors: validationResult.errors,
+                        },
+                        injection,
+                        handler,
+                    });
+                    respond({
+                        message,
+                        data: responseCodec.encode(Object.assign(Object.assign({}, validationResult.data), { code: validationResult.code, body: encodeBody(validationResult.errors) })),
+                    });
+                    break;
+                }
+            }
+        }
+        return validationResult;
+    });
+}
+function beforeAuthorize(params) {
+    var _a;
+    return (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
+        const { message, data, injection, handler } = params;
+        let authorizationResult;
+        if (((_a = handler.beforeAuthorizeMiddlewares) === null || _a === void 0 ? void 0 : _a.length) > 0) {
+            for (const authorizeMiddleware of handler.beforeAuthorizeMiddlewares) {
+                authorizationResult = yield authorizeMiddleware.handle(authorizationResult ? authorizationResult.data : data, injection);
+                if (authorizationResult.code !== 'OK') {
+                    yield handleErrorResponse({
+                        data: authorizationResult.data,
+                        error: {
+                            code: authorizationResult.code,
+                            errors: authorizationResult.errors,
+                        },
+                        injection,
+                        handler,
+                    });
+                    respond({
+                        message,
+                        data: responseCodec.encode(Object.assign(Object.assign({}, authorizationResult.data), { code: authorizationResult.code, body: encodeBody(authorizationResult.errors) })),
+                    });
+                    break;
+                }
+            }
+        }
+        return authorizationResult;
+    });
+}
+function authorize(params) {
+    return (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
+        const { message, data, injection, handler } = params;
+        let authorizationResult;
+        if (handler.authorize) {
+            authorizationResult = yield handler.authorize(data, injection);
+            if (authorizationResult.code !== 'OK') {
+                yield handleErrorResponse({
+                    data,
+                    error: {
+                        code: authorizationResult.code,
+                        errors: authorizationResult.errors,
+                    },
+                    injection,
+                    handler,
+                });
+                respond({
+                    message,
+                    data: responseCodec.encode(Object.assign(Object.assign({}, data), { code: authorizationResult.code, body: encodeBody(authorizationResult.errors) })),
+                });
+            }
+        }
+        return authorizationResult;
+    });
+}
+function afterAuthorize(params) {
+    var _a;
+    return (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
+        const { message, data, injection, handler } = params;
+        let authorizationResult;
+        if (((_a = handler.afterAuthorizeMiddlewares) === null || _a === void 0 ? void 0 : _a.length) > 0) {
+            for (const authorizeMiddleware of handler.afterAuthorizeMiddlewares) {
+                authorizationResult = yield authorizeMiddleware.handle(authorizationResult ? authorizationResult.data : data, injection);
+                if (authorizationResult.code !== 'OK') {
+                    yield handleErrorResponse({
+                        data: authorizationResult.data,
+                        error: {
+                            code: authorizationResult.code,
+                            errors: authorizationResult.errors,
+                        },
+                        injection,
+                        handler,
+                    });
+                    respond({
+                        message,
+                        data: responseCodec.encode(Object.assign(Object.assign({}, authorizationResult.data), { code: authorizationResult.code, body: encodeBody(authorizationResult.errors) })),
+                    });
+                    break;
+                }
+            }
+        }
+        return authorizationResult;
+    });
+}
+function beforeHandle(params) {
+    var _a;
+    return (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
+        const { message, data, injection, handler } = params;
+        let handleResult;
+        if (((_a = handler.beforeHandleMiddlewares) === null || _a === void 0 ? void 0 : _a.length) > 0) {
+            for (const handleMiddleware of handler.beforeHandleMiddlewares) {
+                handleResult = yield handleMiddleware.handle(handleResult ? handleResult.data : data, injection);
+                if (handleResult.code != 'OK') {
+                    yield handleErrorResponse({
+                        data: handleResult.data,
+                        error: {
+                            code: handleResult.code,
+                            errors: handleResult.errors,
+                        },
+                        injection,
+                        handler,
+                    });
+                    respond({
+                        message,
+                        data: responseCodec.encode(Object.assign(Object.assign({}, handleResult.data), { code: handleResult.code, body: encodeBody(handleResult.errors) })),
+                    });
+                    break;
+                }
+            }
+        }
+        return handleResult;
+    });
+}
+function handle(params) {
+    return (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
+        const { message, data, injection, handler } = params;
+        let handleResult;
+        if (handler.handle) {
+            handleResult = yield handler.handle(data, injection);
+            if (handleResult.code !== 200) {
+                yield handleErrorResponse({
+                    data,
+                    error: {
+                        code: handleResult.code,
+                        errors: handleResult.errors,
+                    },
+                    injection,
+                    handler,
+                });
+                respond({
+                    message,
+                    data: responseCodec.encode(Object.assign(Object.assign({}, data), { code: handleResult.code, body: encodeBody(handleResult.errors) })),
+                });
+            }
+        }
+        return handleResult;
+    });
+}
+function afterHandle(params) {
+    var _a;
+    return (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
+        const { message, data, result, injection, handler } = params;
+        let handleResult;
+        if (((_a = handler.afterHandleMiddlewares) === null || _a === void 0 ? void 0 : _a.length) > 0) {
+            for (const handleMiddleware of handler.afterHandleMiddlewares) {
+                handleResult = yield handleMiddleware.handle(handleResult ? handleResult.data : data, handleResult ? handleResult.result : result, injection);
+                if (handleResult.code !== 'OK') {
+                    yield handleErrorResponse({
+                        data: handleResult.data,
+                        error: {
+                            code: handleResult.code,
+                            errors: handleResult.errors,
+                        },
+                        injection,
+                        handler,
+                    });
+                    respond({
+                        message,
+                        data: responseCodec.encode(Object.assign(Object.assign({}, handleResult.data), { code: handleResult.code, body: encodeBody(handleResult.errors) })),
+                    });
+                    return;
+                }
+            }
+        }
+        const lastData = handleResult ? handleResult.data : data;
+        const lastResult = handleResult ? handleResult.result : result;
+        respond({
+            message,
+            data: responseCodec.encode(Object.assign(Object.assign({}, lastData), { headers: (lastResult === null || lastResult === void 0 ? void 0 : lastResult.headers)
+                    ? Object.assign(Object.assign({}, lastData === null || lastData === void 0 ? void 0 : lastData.headers), lastResult === null || lastResult === void 0 ? void 0 : lastResult.headers) : lastData === null || lastData === void 0 ? void 0 : lastData.headers, code: (lastResult === null || lastResult === void 0 ? void 0 : lastResult.code) || 200, body: encodeBody(lastResult === null || lastResult === void 0 ? void 0 : lastResult.body) })),
+        });
+    });
+}
+function handleErrorResponse(params) {
+    return (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
+        const { data, error, injection, handler } = params;
+        if (handler.respondError) {
+            yield handler.respondError(data, error, injection);
+        }
+    });
+}
+function respondUnhandledError(params) {
+    return (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
+        const { message, data, error, injection, handler } = params;
+        if (handler.respondUnhandledError) {
+            try {
+                yield handler.respondUnhandledError(data, error, injection);
+            }
+            catch (error) {
+                console.error(`[${handler.subject}]respondUnhandledError`, error);
+            }
+        }
+        respond({
+            message,
+            data: responseCodec.encode(Object.assign(Object.assign({}, data), { body: encodeBody(data === null || data === void 0 ? void 0 : data.body), code: 500 })),
+        });
+    });
+}
 function respond(params) {
@@ -295,3 +564,3 @@ const { message, data } = params;
     setup: (params) => {
-        const { urls, injections, user, pass, verbose, namespace, sentry } = params;
+        const { urls, injections, user, pass, verbose, namespace } = params;
         const client = {
@@ -305,3 +574,2 @@ start: () => start({
                 namespace,
-                sentry,
             }),
@@ -308,0 +576,0 @@ stop: () => stop(urls),

dist/type.d.ts

 import type { Msg, NatsConnection, PublishOptions, RequestOptions } from 'nats';
 import type { NatsService, NatsRequest, NatsResponse } from '@silenteer/natsu-type';
 declare type NatsInjection = {
+    subject: string;
     message: Msg;
@@ -12,2 +13,10 @@ natsService: {
 };
+declare type NatsValidationResult = {
+    code: 'OK' | 400 | 404;
+    errors?: unknown;
+};
+declare type NatsAuthorizationResult = {
+    code: 'OK' | 403;
+    errors?: unknown;
+};
 declare type NatsHandleResult<TBody> = {
@@ -21,13 +30,51 @@ code: number;
 };
-declare type NatsAuthorizationResult = {
-    code: 'OK' | 403;
-    message?: string;
+declare type NatsMiddlewareValidationResult<TRequest = unknown> = {
+    code: 'OK' | number;
+    data?: NatsRequest<TRequest>;
+    errors?: unknown;
 };
-declare type NatsValidationResult = {
-    code: 'OK' | 400 | 404;
+declare type NatsMiddlewareAuthorizationResult<TRequest = unknown> = {
+    code: 'OK' | number;
+    data?: NatsRequest<TRequest>;
     errors?: unknown;
 };
+declare type NatsMiddlewareHandleResult<TRequest = unknown, TResponse = unknown> = {
+    code: 'OK' | number;
+    data?: NatsRequest<TRequest>;
+    result?: NatsHandleResult<TResponse>;
+    errors?: unknown;
+};
+declare type NatsBeforeValidate<TService extends NatsService<string, unknown, unknown>, TInjection extends Record<string, unknown> = Record<string, unknown>> = (data: NatsRequest<TService['request']>, injection: TInjection & NatsInjection) => Promise<NatsMiddlewareValidationResult>;
 declare type NatsValidate<TService extends NatsService<string, unknown, unknown>, TInjection extends Record<string, unknown> = Record<string, unknown>> = (data: NatsRequest<TService['request']>, injection: TInjection & NatsInjection) => Promise<NatsValidationResult>;
+declare type NatsAfterValidate<TService extends NatsService<string, unknown, unknown>, TInjection extends Record<string, unknown> = Record<string, unknown>> = (data: NatsRequest<TService['request']>, injection: TInjection & NatsInjection) => Promise<NatsMiddlewareValidationResult>;
+declare type NatsBeforeAuthorize<TService extends NatsService<string, unknown, unknown>, TInjection extends Record<string, unknown> = Record<string, unknown>> = (data: NatsRequest<TService['request']>, injection: TInjection & NatsInjection) => Promise<NatsMiddlewareAuthorizationResult>;
 declare type NatsAuthorize<TService extends NatsService<string, unknown, unknown>, TInjection extends Record<string, unknown> = Record<string, unknown>> = (data: NatsRequest<TService['request']>, injection: TInjection & NatsInjection) => Promise<NatsAuthorizationResult>;
+declare type NatsAfterAuthorize<TService extends NatsService<string, unknown, unknown>, TInjection extends Record<string, unknown> = Record<string, unknown>> = (data: NatsRequest<TService['request']>, injection: TInjection & NatsInjection) => Promise<NatsMiddlewareAuthorizationResult>;
+declare type NatsBeforeHandle<TService extends NatsService<string, unknown, unknown>, TInjection extends Record<string, unknown> = Record<string, unknown>> = (data: NatsRequest<TService['request']>, injection: TInjection & NatsInjection) => Promise<NatsMiddlewareHandleResult>;
 declare type NatsHandle<TService extends NatsService<string, unknown, unknown>, TInjection extends Record<string, unknown> = Record<string, unknown>> = (data: NatsRequest<TService['request']>, injection: TInjection & NatsInjection) => Promise<NatsHandleResult<TService['response']>>;
+declare type NatsAfterHandle<TService extends NatsService<string, unknown, unknown>, TInjection extends Record<string, unknown> = Record<string, unknown>> = (data: NatsRequest<TService['request']>, result: NatsHandleResult<TService['response']>, injection: TInjection & NatsInjection) => Promise<NatsMiddlewareHandleResult>;
+declare type NatsBeforeValidateMiddleware<TService extends NatsService<string, unknown, unknown>, TInjection extends Record<string, unknown> = Record<string, unknown>> = {
+    id: string;
+    handle: NatsBeforeValidate<TService, TInjection>;
+};
+declare type NatsAfterValidateMiddleware<TService extends NatsService<string, unknown, unknown>, TInjection extends Record<string, unknown> = Record<string, unknown>> = {
+    id: string;
+    handle: NatsAfterValidate<TService, TInjection>;
+};
+declare type NatsBeforeAuthorizeMiddleware<TService extends NatsService<string, unknown, unknown>, TInjection extends Record<string, unknown> = Record<string, unknown>> = {
+    id: string;
+    handle: NatsBeforeAuthorize<TService, TInjection>;
+};
+declare type NatsAfterAuthorizeMiddleware<TService extends NatsService<string, unknown, unknown>, TInjection extends Record<string, unknown> = Record<string, unknown>> = {
+    id: string;
+    handle: NatsAfterAuthorize<TService, TInjection>;
+};
+declare type NatsBeforeHandleMiddleware<TService extends NatsService<string, unknown, unknown>, TInjection extends Record<string, unknown> = Record<string, unknown>> = {
+    id: string;
+    handle: NatsBeforeHandle<TService, TInjection>;
+};
+declare type NatsAfterHandleMiddleware<TService extends NatsService<string, unknown, unknown>, TInjection extends Record<string, unknown> = Record<string, unknown>> = {
+    id: string;
+    handle: NatsAfterHandle<TService, TInjection>;
+};
 declare type NatsHandler<TService extends NatsService<string, unknown, unknown>, TInjection extends Record<string, unknown> = Record<string, unknown>> = {
@@ -38,3 +85,14 @@ subject: TService['subject'];
     handle: NatsHandle<TService, TInjection>;
+    beforeValidateMiddlewares?: Array<NatsBeforeValidateMiddleware<TService, TInjection>>;
+    afterValidateMiddlewares?: Array<NatsAfterValidateMiddleware<TService, TInjection>>;
+    beforeAuthorizeMiddlewares?: Array<NatsBeforeAuthorizeMiddleware<TService, TInjection>>;
+    afterAuthorizeMiddlewares?: Array<NatsAfterAuthorizeMiddleware<TService, TInjection>>;
+    beforeHandleMiddlewares?: Array<NatsBeforeHandleMiddleware<TService, TInjection>>;
+    afterHandleMiddlewares?: Array<NatsAfterHandleMiddleware<TService, TInjection>>;
+    respondError?: (data: NatsRequest<TService['request']>, error: {
+        code: number;
+        errors?: unknown;
+    }, injection: TInjection & NatsInjection) => Promise<void>;
+    respondUnhandledError?: (data: NatsRequest<TService['request']>, error: Error, injection: TInjection & NatsInjection) => Promise<void>;
 };
-export type { NatsService, NatsRequest, NatsResponse, NatsInjection, NatsHandleResult, NatsAuthorizationResult, NatsValidationResult, NatsValidate, NatsAuthorize, NatsHandle, NatsHandler, };
+export type { NatsService, NatsRequest, NatsResponse, NatsInjection, NatsValidationResult, NatsAuthorizationResult, NatsHandleResult, NatsMiddlewareValidationResult, NatsMiddlewareAuthorizationResult, NatsMiddlewareHandleResult, NatsBeforeValidate, NatsValidate, NatsAfterValidate, NatsBeforeAuthorize, NatsAuthorize, NatsAfterAuthorize, NatsBeforeHandle, NatsHandle, NatsAfterHandle, NatsHandler, NatsBeforeValidateMiddleware, NatsAfterValidateMiddleware, NatsBeforeAuthorizeMiddleware, NatsAfterAuthorizeMiddleware, NatsBeforeHandleMiddleware, NatsAfterHandleMiddleware, };

dist/utility.d.ts

@@ -1,2 +0,2 @@
-import type { NatsAuthorizationResult, NatsHandleResult, NatsValidationResult } from './type';
+import type { NatsAuthorizationResult, NatsHandleResult, NatsValidationResult, NatsMiddlewareAuthorizationResult, NatsMiddlewareHandleResult, NatsMiddlewareValidationResult, NatsRequest } from './type';
 declare const NatsValidationResultUtil: {
@@ -9,3 +9,3 @@ ok: () => NatsValidationResult;
     ok: () => NatsAuthorizationResult;
-    error: (message?: string) => NatsAuthorizationResult;
+    error: (errors?: unknown) => NatsAuthorizationResult;
 };
@@ -16,3 +16,3 @@ declare const NatsHandleResultUtil: {
     }) => NatsHandleResult<T>;
-    error: <T_1>(params: {
+    error: <T_1>(params?: {
         code: number;
@@ -22,2 +22,26 @@ errors?: unknown;
 };
-export { NatsValidationResultUtil, NatsAuthorizationResultUtil, NatsHandleResultUtil, };
+declare const NatsMiddlewareValidationResultUtil: {
+    ok: <TRequest>(data: NatsRequest<TRequest>) => NatsMiddlewareValidationResult;
+    error: (params?: {
+        code: number;
+        errors: unknown;
+    }) => NatsMiddlewareValidationResult;
+};
+declare const NatsMiddlewareAuthorizationResultUtil: {
+    ok: <TRequest>(data: NatsRequest<TRequest>) => NatsMiddlewareAuthorizationResult;
+    error: (params?: {
+        code: number;
+        errors: unknown;
+    }) => NatsMiddlewareAuthorizationResult;
+};
+declare const NatsMiddlewareHandleResultUtil: {
+    ok: <TRequest, TResponse>(params: {
+        data: NatsRequest<TRequest>;
+        result?: NatsHandleResult<TResponse>;
+    }) => NatsMiddlewareHandleResult<TRequest, TResponse>;
+    error: (params?: {
+        code: number;
+        errors?: unknown;
+    }) => NatsMiddlewareHandleResult;
+};
+export { NatsValidationResultUtil, NatsAuthorizationResultUtil, NatsHandleResultUtil, NatsMiddlewareValidationResultUtil, NatsMiddlewareAuthorizationResultUtil, NatsMiddlewareHandleResultUtil, };

dist/utility.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.NatsHandleResultUtil = exports.NatsAuthorizationResultUtil = exports.NatsValidationResultUtil = void 0;
+exports.NatsMiddlewareHandleResultUtil = exports.NatsMiddlewareAuthorizationResultUtil = exports.NatsMiddlewareValidationResultUtil = exports.NatsHandleResultUtil = exports.NatsAuthorizationResultUtil = exports.NatsValidationResultUtil = void 0;
 const NatsValidationResultUtil = {
@@ -12,5 +12,5 @@ ok: () => ({ code: 'OK' }),
     ok: () => ({ code: 'OK' }),
-    error: (message) => ({
+    error: (errors) => ({
         code: 403,
-        message,
+        errors,
     }),
@@ -21,5 +21,51 @@ };
     ok: (body, headers) => ({ code: 200, headers, body }),
-    error: (params) => params,
+    error: (params) => {
+        const { code = 500, errors } = params || {};
+        return {
+            code,
+            errors,
+        };
+    },
 };
 exports.NatsHandleResultUtil = NatsHandleResultUtil;
+const NatsMiddlewareValidationResultUtil = {
+    ok: (data) => ({ code: 'OK', data }),
+    error: (params) => {
+        const { code = 400, errors } = params || {};
+        return {
+            code,
+            errors,
+        };
+    },
+};
+exports.NatsMiddlewareValidationResultUtil = NatsMiddlewareValidationResultUtil;
+const NatsMiddlewareAuthorizationResultUtil = {
+    ok: (data) => ({ code: 'OK', data }),
+    error: (params) => {
+        const { code = 403, errors } = params || {};
+        return {
+            code,
+            errors,
+        };
+    },
+};
+exports.NatsMiddlewareAuthorizationResultUtil = NatsMiddlewareAuthorizationResultUtil;
+const NatsMiddlewareHandleResultUtil = {
+    ok: (params) => {
+        const { data, result } = params || {};
+        return {
+            code: 'OK',
+            data,
+            result,
+        };
+    },
+    error: (params) => {
+        const { code = 500, errors } = params || {};
+        return {
+            code,
+            errors,
+        };
+    },
+};
+exports.NatsMiddlewareHandleResultUtil = NatsMiddlewareHandleResultUtil;
 //# sourceMappingURL=utility.js.map

package.json

 {
   "name": "@silenteer/natsu",
-  "version": "1.0.13",
+  "version": "1.0.14",
   "license": "MIT",
@@ -16,6 +16,7 @@ "private": false,
   "scripts": {
-    "build": "rm -rf dist && tsc"
+    "build": "rm -rf dist && tsc -p tsconfig.lib.json",
+    "test": "jest",
+    "test:coverage": "jest --coverage=true"
   },
   "dependencies": {
-    "@sentry/node": "6.17.5",
     "@silenteer/natsu-type": "0.0.10",
@@ -25,3 +26,6 @@ "nats": "^2.2.0"
   "devDependencies": {
+    "@types/jest": "27.4.0",
     "@types/node": "16.9.1",
+    "jest": "27.5.1",
+    "ts-jest": "27.1.3",
     "ts-node": "10.2.1",
@@ -28,0 +32,0 @@ "tslib": "2.3.1",

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

85000

increased by129.42%

Dependency count

2

decreased by-33.33%

Number of package files

23

increased by4.55%

Lines of code

906

increased by80.12%

Worsened metrics

Dev dependency count

7

increased by75%

Dependency changes

• - Removed@sentry/node@6.17.5

• - Removed@sentry/core@6.17.5(transitive)

• - Removed@sentry/hub@6.17.5(transitive)

• - Removed@sentry/minimal@6.17.5(transitive)

• - Removed@sentry/node@6.17.5(transitive)

• - Removed@sentry/tracing@6.17.5(transitive)

• - Removed@sentry/types@6.17.5(transitive)

• - Removed@sentry/utils@6.17.5(transitive)

• - Removedagent-base@6.0.2(transitive)

• - Removedcookie@0.4.2(transitive)

• - Removeddebug@4.4.0(transitive)

• - Removedhttps-proxy-agent@5.0.1(transitive)

• - Removedlru_map@0.3.3(transitive)

• - Removedms@2.1.3(transitive)

• - Removedtslib@1.14.1(transitive)