@deplois/api 0.0.0-stage → 0.0.2

package/dist/index.js

@@ -0,0 +1,40 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.errorPlugin = void 0;
+__exportStar(require("./api.module"), exports);
+__exportStar(require("./options"), exports);
+__exportStar(require("./interface"), exports);
+__exportStar(require("./system/error/app.exception"), exports);
+__exportStar(require("./system/error/error-code.enum"), exports);
+var error_plugin_1 = require("./system/error/error.plugin");
+Object.defineProperty(exports, "errorPlugin", { enumerable: true, get: function () { return __importDefault(error_plugin_1).default; } });
+__exportStar(require("./system/filter/http-exception.filter"), exports);
+__exportStar(require("./system/interceptor/response.interceptor"), exports);
+__exportStar(require("./system/pipe/body-validation.pipe"), exports);
+__exportStar(require("./system/logger/request.logger"), exports);
+__exportStar(require("./system/guard/session.guard"), exports);
+__exportStar(require("./system/decorator/raw-response.decorator"), exports);
+__exportStar(require("./identity/interface"), exports);
+__exportStar(require("./identity/identity.plugin"), exports);
+__exportStar(require("./identity/identity.service"), exports);
+__exportStar(require("./system/guard/user.guard"), exports);
+__exportStar(require("./session.module"), exports);
+__exportStar(require("./create-api"), exports);
+__exportStar(require("./system/logger/file.logger"), exports);

package/dist/interface.d.ts

@@ -0,0 +1,20 @@
+export interface ErrorObject {
+    code: string;
+    message: string;
+}
+export type APIResponse<T = unknown> = {
+    success: true;
+    data: T;
+    error: null;
+} | {
+    success: false;
+    data: null;
+    error: ErrorObject;
+};
+export type PluginResult<T> = {
+    success: true;
+    data: T;
+} | {
+    success: false;
+    error: Error;
+};

package/dist/interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/options.d.ts

@@ -0,0 +1,23 @@
+import type { ModuleMetadata, FactoryProvider } from '@nestjs/common';
+import type { createIdentityPlugins } from './identity/identity.plugin';
+import type { Request } from 'express';
+import type { HTTPLog } from './system/logger/request.logger';
+export declare const API_OPTIONS: unique symbol;
+export interface APIOptions {
+    validation?: boolean;
+    exposeInternalErrors?: boolean;
+    logging?: false | {
+        bodies?: boolean;
+        redact?: string[];
+        write?: (entry: HTTPLog) => void | Promise<void>;
+    };
+    onError?: (error: unknown, requestId: string) => void | Promise<void>;
+    identity?: ReturnType<typeof createIdentityPlugins>;
+    session?: {
+        resolve: (token: string, request: Request) => Promise<unknown | null>;
+    };
+}
+export interface APIAsyncOptions extends Pick<ModuleMetadata, 'imports'> {
+    inject?: FactoryProvider['inject'];
+    useFactory: (...dependencies: any[]) => APIOptions | Promise<APIOptions>;
+}

package/dist/options.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.API_OPTIONS = void 0;
+exports.API_OPTIONS = Symbol('API_OPTIONS');

package/dist/session.module.d.ts

@@ -0,0 +1,2 @@
+export declare class SessionModule {
+}

package/dist/session.module.js

@@ -0,0 +1,18 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionModule = void 0;
+const common_1 = require("@nestjs/common");
+const session_controller_1 = require("./controller/session.controller");
+// Import explicitly to expose the /session HTTP endpoints.
+let SessionModule = class SessionModule {
+};
+exports.SessionModule = SessionModule;
+exports.SessionModule = SessionModule = __decorate([
+    (0, common_1.Module)({ controllers: [session_controller_1.SessionController] })
+], SessionModule);

package/dist/system/decorator/raw-response.decorator.d.ts

@@ -0,0 +1,2 @@
+export declare const RAW_RESPONSE: unique symbol;
+export declare const RawResponse: () => import("@nestjs/common").CustomDecorator<typeof RAW_RESPONSE>;

package/dist/system/decorator/raw-response.decorator.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RawResponse = exports.RAW_RESPONSE = void 0;
+const common_1 = require("@nestjs/common");
+exports.RAW_RESPONSE = Symbol('RAW_RESPONSE');
+const RawResponse = () => (0, common_1.SetMetadata)(exports.RAW_RESPONSE, true);
+exports.RawResponse = RawResponse;

package/dist/system/error/app.exception.d.ts

@@ -0,0 +1,6 @@
+import { HttpException, HttpExceptionOptions } from '@nestjs/common';
+import { ErrorObject } from '../../interface';
+export declare class AppException extends HttpException {
+    error: ErrorObject;
+    constructor(error: ErrorObject, statusCode?: number, options?: HttpExceptionOptions);
+}

package/dist/system/error/app.exception.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppException = void 0;
+const common_1 = require("@nestjs/common");
+class AppException extends common_1.HttpException {
+    error;
+    constructor(error, statusCode = common_1.HttpStatus.BAD_REQUEST, options) {
+        super(error, statusCode, options);
+        this.error = error;
+    }
+}
+exports.AppException = AppException;

package/dist/system/error/error-code.enum.d.ts

@@ -0,0 +1,11 @@
+export declare enum ErrorCode {
+    expired_session = "EXPIRED_SESSION",
+    wrong_parameter = "WRONG_PARAMETER",
+    invalid_request = "INVALID_REQUEST",
+    unauthorized = "UNAUTHORIZED",
+    forbidden = "FORBIDDEN",
+    not_found = "NOT_FOUND",
+    conflict = "CONFLICT",
+    too_many_requests = "TOO_MANY_REQUESTS",
+    internal_server_error = "INTERNAL_SERVER_ERROR"
+}

package/dist/system/error/error-code.enum.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrorCode = void 0;
+var ErrorCode;
+(function (ErrorCode) {
+    ErrorCode["expired_session"] = "EXPIRED_SESSION";
+    ErrorCode["wrong_parameter"] = "WRONG_PARAMETER";
+    ErrorCode["invalid_request"] = "INVALID_REQUEST";
+    ErrorCode["unauthorized"] = "UNAUTHORIZED";
+    ErrorCode["forbidden"] = "FORBIDDEN";
+    ErrorCode["not_found"] = "NOT_FOUND";
+    ErrorCode["conflict"] = "CONFLICT";
+    ErrorCode["too_many_requests"] = "TOO_MANY_REQUESTS";
+    ErrorCode["internal_server_error"] = "INTERNAL_SERVER_ERROR";
+})(ErrorCode || (exports.ErrorCode = ErrorCode = {}));

package/dist/system/error/error.plugin.d.ts

@@ -0,0 +1,14 @@
+import { HttpExceptionOptions } from '@nestjs/common';
+import { AppException } from './app.exception';
+import { ErrorObject } from '../../interface';
+declare const _default: {
+    pluginName: string;
+    createErrorObject: (code: string, message: string) => ErrorObject;
+    createException: (code: string, message: string, statusCode?: number, options?: HttpExceptionOptions) => AppException;
+    getStatusCode: (exception: unknown) => number;
+    fromUnknown: (exception: unknown, exposeInternalErrors?: boolean) => {
+        statusCode: number;
+        error: ErrorObject;
+    };
+};
+export default _default;

package/dist/system/error/error.plugin.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const common_1 = require("@nestjs/common");
+const app_exception_1 = require("./app.exception");
+const error_code_enum_1 = require("./error-code.enum");
+exports.default = {
+    pluginName: 'error.plugin',
+    createErrorObject: (code, message) => {
+        return {
+            code: code,
+            message: message
+        };
+    },
+    createException: (code, message, statusCode = common_1.HttpStatus.BAD_REQUEST, options) => {
+        return new app_exception_1.AppException({
+            code: code,
+            message: message
+        }, statusCode, options);
+    },
+    getStatusCode: (exception) => {
+        if (exception instanceof common_1.HttpException) {
+            return exception.getStatus();
+        }
+        return common_1.HttpStatus.INTERNAL_SERVER_ERROR;
+    },
+    fromUnknown: (exception, exposeInternalErrors = false) => {
+        if (exception instanceof app_exception_1.AppException) {
+            return {
+                statusCode: exception.getStatus(),
+                error: exception.error
+            };
+        }
+        if (exception instanceof common_1.HttpException) {
+            const response = exception.getResponse();
+            if (typeof response == 'object'
+                && response != null
+                && 'code' in response
+                && 'message' in response) {
+                return {
+                    statusCode: exception.getStatus(),
+                    error: {
+                        code: String(response.code),
+                        message: String(response.message)
+                    }
+                };
+            }
+            const message = typeof response == 'string'
+                ? response
+                : (typeof response == 'object'
+                    && response != null
+                    && 'message' in response
+                    ? Array.isArray(response.message)
+                        ? response.message.join(', ')
+                        : String(response.message)
+                    : 'Request failed.');
+            return {
+                statusCode: exception.getStatus(),
+                error: {
+                    code: mapHttpStatusCode(exception.getStatus()),
+                    message: message
+                }
+            };
+        }
+        if (exception instanceof Error) {
+            return {
+                statusCode: common_1.HttpStatus.INTERNAL_SERVER_ERROR,
+                error: {
+                    code: error_code_enum_1.ErrorCode.internal_server_error,
+                    message: exposeInternalErrors ? exception.message : 'An internal server error occurred.'
+                }
+            };
+        }
+        if (typeof exception == 'string') {
+            return {
+                statusCode: common_1.HttpStatus.INTERNAL_SERVER_ERROR,
+                error: {
+                    code: error_code_enum_1.ErrorCode.internal_server_error,
+                    message: exposeInternalErrors ? exception : 'An internal server error occurred.'
+                }
+            };
+        }
+        return {
+            statusCode: common_1.HttpStatus.INTERNAL_SERVER_ERROR,
+            error: {
+                code: error_code_enum_1.ErrorCode.internal_server_error,
+                message: 'An internal server error occurred.'
+            }
+        };
+    }
+};
+function mapHttpStatusCode(statusCode) {
+    switch (statusCode) {
+        case common_1.HttpStatus.BAD_REQUEST:
+            return error_code_enum_1.ErrorCode.invalid_request;
+        case common_1.HttpStatus.UNAUTHORIZED:
+            return error_code_enum_1.ErrorCode.unauthorized;
+        case common_1.HttpStatus.FORBIDDEN:
+            return error_code_enum_1.ErrorCode.forbidden;
+        case common_1.HttpStatus.NOT_FOUND:
+            return error_code_enum_1.ErrorCode.not_found;
+        case common_1.HttpStatus.CONFLICT:
+            return error_code_enum_1.ErrorCode.conflict;
+        case common_1.HttpStatus.TOO_MANY_REQUESTS:
+            return error_code_enum_1.ErrorCode.too_many_requests;
+        default:
+            return error_code_enum_1.ErrorCode.internal_server_error;
+    }
+}

package/dist/system/filter/http-exception.filter.d.ts

@@ -0,0 +1,9 @@
+import { ArgumentsHost, ExceptionFilter } from '@nestjs/common';
+import { APIOptions } from '../../options';
+import { RequestLogger } from '../logger/request.logger';
+export declare class HTTPExceptionFilter implements ExceptionFilter {
+    private readonly options;
+    private readonly logger;
+    constructor(options: APIOptions, logger: RequestLogger);
+    catch(exception: unknown, host: ArgumentsHost): void;
+}

package/dist/system/filter/http-exception.filter.js

@@ -0,0 +1,49 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HTTPExceptionFilter = void 0;
+const common_1 = require("@nestjs/common");
+const options_1 = require("../../options");
+const error_plugin_1 = __importDefault(require("../error/error.plugin"));
+const request_logger_1 = require("../logger/request.logger");
+let HTTPExceptionFilter = class HTTPExceptionFilter {
+    options;
+    logger;
+    constructor(options, logger) {
+        this.options = options;
+        this.logger = logger;
+    }
+    catch(exception, host) {
+        if (host.getType() !== 'http')
+            throw exception;
+        const request = host.switchToHttp().getRequest();
+        const response = host.switchToHttp().getResponse();
+        this.logger.error(request, exception);
+        if (response.headersSent)
+            return;
+        const result = error_plugin_1.default.fromUnknown(exception, this.options.exposeInternalErrors);
+        const body = { success: false, data: null, error: result.error };
+        this.logger.response(request, body);
+        response.status(result.statusCode).json(body);
+    }
+};
+exports.HTTPExceptionFilter = HTTPExceptionFilter;
+exports.HTTPExceptionFilter = HTTPExceptionFilter = __decorate([
+    (0, common_1.Catch)(),
+    __param(0, (0, common_1.Inject)(options_1.API_OPTIONS)),
+    __metadata("design:paramtypes", [Object, request_logger_1.RequestLogger])
+], HTTPExceptionFilter);

package/dist/system/guard/session.guard.d.ts

@@ -0,0 +1,13 @@
+import { CanActivate, ExecutionContext } from '@nestjs/common';
+import type { Request } from 'express';
+import { APIOptions } from '../../options';
+export type SessionRequest<T = unknown> = Request & {
+    session: T;
+};
+export declare function getBearerToken(authorization?: string): string | null;
+export declare class SessionGuard implements CanActivate {
+    private readonly options;
+    private readonly resolutions;
+    constructor(options: APIOptions);
+    canActivate(context: ExecutionContext): Promise<boolean>;
+}

package/dist/system/guard/session.guard.js

@@ -0,0 +1,64 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionGuard = void 0;
+exports.getBearerToken = getBearerToken;
+const common_1 = require("@nestjs/common");
+const options_1 = require("../../options");
+const error_plugin_1 = __importDefault(require("../error/error.plugin"));
+function getBearerToken(authorization) {
+    return /^Bearer\s+(\S+)$/i.exec(authorization ?? '')?.[1] ?? null;
+}
+let SessionGuard = class SessionGuard {
+    options;
+    resolutions = new WeakMap();
+    constructor(options) {
+        this.options = options;
+    }
+    async canActivate(context) {
+        const request = context.switchToHttp().getRequest();
+        const token = getBearerToken(request.headers.authorization);
+        if (!token)
+            throw error_plugin_1.default.createException('WRONG_SESSION', 'Required session.');
+        if (!this.options.session && !this.options.identity)
+            throw error_plugin_1.default.createException('SERVER_ERROR', 'Session authentication is not configured.', 500);
+        let resolution = this.resolutions.get(request);
+        if (!resolution) {
+            resolution = Promise.resolve().then(async () => {
+                if (this.options.session)
+                    return this.options.session.resolve(token, request);
+                const result = await this.options.identity.sessionPlugin.get(token);
+                if (!result.success)
+                    throw result.error;
+                return result.data;
+            });
+            this.resolutions.set(request, resolution);
+        }
+        const session = await resolution;
+        if (session == null)
+            throw error_plugin_1.default.createException('WRONG_SESSION', 'Wrong session.');
+        context.switchToHttp().getResponse().setHeader('Cache-Control', 'no-store');
+        request.session = session;
+        return true;
+    }
+};
+exports.SessionGuard = SessionGuard;
+exports.SessionGuard = SessionGuard = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Inject)(options_1.API_OPTIONS)),
+    __metadata("design:paramtypes", [Object])
+], SessionGuard);

package/dist/system/guard/user.guard.d.ts

@@ -0,0 +1,13 @@
+import { CanActivate, ExecutionContext } from '@nestjs/common';
+import { SessionGuard, SessionRequest } from './session.guard';
+import { IdentityService } from '../../identity/identity.service';
+import type { Session, User } from '../../identity/interface';
+export type UserRequest = SessionRequest<Omit<Session, 'tokenHash'>> & {
+    users: User[];
+};
+export declare class UserGuard implements CanActivate {
+    private readonly sessionGuard;
+    private readonly identity;
+    constructor(sessionGuard: SessionGuard, identity: IdentityService);
+    canActivate(context: ExecutionContext): Promise<boolean>;
+}

package/dist/system/guard/user.guard.js

@@ -0,0 +1,46 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserGuard = void 0;
+const common_1 = require("@nestjs/common");
+const app_exception_1 = require("../error/app.exception");
+const session_guard_1 = require("./session.guard");
+const identity_service_1 = require("../../identity/identity.service");
+const error_plugin_1 = __importDefault(require("../error/error.plugin"));
+let UserGuard = class UserGuard {
+    sessionGuard;
+    identity;
+    constructor(sessionGuard, identity) {
+        this.sessionGuard = sessionGuard;
+        this.identity = identity;
+    }
+    async canActivate(context) {
+        await this.sessionGuard.canActivate(context);
+        const request = context.switchToHttp().getRequest();
+        const results = await Promise.all((request.session.userIds ?? []).map(id => this.identity.userPlugin.get(id)));
+        for (const result of results) {
+            if (!result.success && !(result.error instanceof app_exception_1.AppException && result.error.error.code === 'USER_NOT_FOUND'))
+                throw result.error;
+        }
+        request.users = results.flatMap(result => result.success ? [result.data] : []);
+        if (!request.users.length)
+            throw error_plugin_1.default.createException('REQUIRED_USER', 'A signed-in user is required.', 401);
+        return true;
+    }
+};
+exports.UserGuard = UserGuard;
+exports.UserGuard = UserGuard = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [session_guard_1.SessionGuard, identity_service_1.IdentityService])
+], UserGuard);

package/dist/system/interceptor/response.interceptor.d.ts

@@ -0,0 +1,9 @@
+import { CallHandler, ExecutionContext, NestInterceptor } from '@nestjs/common';
+import { Reflector } from '@nestjs/core';
+import { RequestLogger } from '../logger/request.logger';
+export declare class ResponseInterceptor implements NestInterceptor {
+    private readonly reflector;
+    private readonly logger;
+    constructor(reflector: Reflector, logger: RequestLogger);
+    intercept(context: ExecutionContext, next: CallHandler): import("rxjs").Observable<any>;
+}

package/dist/system/interceptor/response.interceptor.js

@@ -0,0 +1,44 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResponseInterceptor = void 0;
+const common_1 = require("@nestjs/common");
+const core_1 = require("@nestjs/core");
+const rxjs_1 = require("rxjs");
+const raw_response_decorator_1 = require("../decorator/raw-response.decorator");
+const request_logger_1 = require("../logger/request.logger");
+let ResponseInterceptor = class ResponseInterceptor {
+    reflector;
+    logger;
+    constructor(reflector, logger) {
+        this.reflector = reflector;
+        this.logger = logger;
+    }
+    intercept(context, next) {
+        if (context.getType() !== 'http')
+            return next.handle();
+        const request = context.switchToHttp().getRequest();
+        const response = context.switchToHttp().getResponse();
+        const raw = this.reflector.getAllAndOverride(raw_response_decorator_1.RAW_RESPONSE, [context.getHandler(), context.getClass()]);
+        return next.handle().pipe((0, rxjs_1.map)(data => {
+            if (response.headersSent || data instanceof common_1.StreamableFile || response.statusCode === 204 || response.statusCode === 304)
+                return data;
+            const body = raw ? data : { success: true, data: data ?? null, error: null };
+            this.logger.response(request, body);
+            return body;
+        }));
+    }
+};
+exports.ResponseInterceptor = ResponseInterceptor;
+exports.ResponseInterceptor = ResponseInterceptor = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [core_1.Reflector, request_logger_1.RequestLogger])
+], ResponseInterceptor);

package/dist/system/logger/file.logger.d.ts

@@ -0,0 +1,38 @@
+import type { LoggerService } from '@nestjs/common';
+import type { HTTPLog } from './request.logger';
+export interface FileLoggerOptions {
+    directory?: string;
+    maxFileSize?: number;
+    retentionDays?: number;
+}
+export declare class FileLogger implements LoggerService {
+    readonly directory: string;
+    readonly recent: string[];
+    readonly network: HTTPLog[];
+    requests: number;
+    errors: number;
+    warnings: number;
+    failedWrites: number;
+    private durations;
+    private queue;
+    private pending;
+    private day;
+    private part;
+    private size;
+    private closed;
+    private readonly maxFileSize;
+    private readonly retentionDays;
+    constructor(options?: FileLoggerOptions);
+    get median(): number;
+    reset(): void;
+    log(message: unknown, ...details: unknown[]): void;
+    error(message: unknown, ...details: unknown[]): void;
+    warn(message: unknown, ...details: unknown[]): void;
+    debug(message: unknown, ...details: unknown[]): void;
+    verbose(message: unknown, ...details: unknown[]): void;
+    fatal(message: unknown, ...details: unknown[]): void;
+    private write;
+    private path;
+    flush(): Promise<void>;
+    close(): Promise<void>;
+}