@deplois/api 0.0.0-stage → 0.0.2

package/dist/system/logger/file.logger.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileLogger = void 0;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const request_logger_1 = require("./request.logger");
+class FileLogger {
+    directory;
+    recent = [];
+    network = [];
+    requests = 0;
+    errors = 0;
+    warnings = 0;
+    failedWrites = 0;
+    durations = [];
+    queue = Promise.resolve();
+    pending = 0;
+    day = '';
+    part = 0;
+    size = 0;
+    closed = false;
+    maxFileSize;
+    retentionDays;
+    constructor(options = {}) {
+        this.directory = (0, node_path_1.resolve)(options.directory ?? 'logs');
+        this.maxFileSize = options.maxFileSize ?? 10 * 1024 * 1024;
+        this.retentionDays = options.retentionDays ?? 30;
+        if (!Number.isSafeInteger(this.maxFileSize) || this.maxFileSize < 1)
+            throw new Error('Invalid log file size.');
+        if (!Number.isSafeInteger(this.retentionDays) || this.retentionDays < 1)
+            throw new Error('Invalid log retention.');
+    }
+    get median() {
+        const durations = [...this.durations].sort((a, b) => a - b);
+        const middle = Math.floor(durations.length / 2);
+        return durations.length ? (durations.length % 2 ? durations[middle] : (durations[middle - 1] + durations[middle]) / 2) : 0;
+    }
+    reset() {
+        this.requests = this.errors = this.warnings = 0;
+        this.durations = [];
+        this.network.length = 0;
+    }
+    log(message, ...details) {
+        if (message && typeof message === 'object' && 'request' in message && 'response' in message) {
+            const entry = message;
+            if (typeof entry.response?.status_code === 'number' && typeof entry.response.duration_ms === 'number') {
+                this.requests++;
+                this.durations.push(entry.response.duration_ms);
+                if (this.durations.length > 1000)
+                    this.durations.shift();
+                this.network.push(entry);
+                if (this.network.length > 20)
+                    this.network.shift();
+            }
+        }
+        this.write('info', message, details);
+    }
+    error(message, ...details) { this.errors++; this.write('error', message, details); }
+    warn(message, ...details) { this.warnings++; this.write('warn', message, details); }
+    debug(message, ...details) { this.write('debug', message, details); }
+    verbose(message, ...details) { this.write('verbose', message, details); }
+    fatal(message, ...details) { this.errors++; this.write('fatal', message, details); }
+    write(level, message, details) {
+        if (this.closed)
+            return;
+        const timestamp = new Date().toISOString();
+        const normalize = (value) => value instanceof Error
+            ? { name: value.name, message: value.message, stack: value.stack }
+            : value;
+        let line;
+        try {
+            line = JSON.stringify({ timestamp, level, message: (0, request_logger_1.sanitize)(normalize(message)), details: (0, request_logger_1.sanitize)(details.map(normalize)) }, (_, value) => typeof value === 'bigint' ? String(value) : value) + '\n';
+        }
+        catch {
+            line = JSON.stringify({ timestamp, level, message: '[Unserializable log]' }) + '\n';
+        }
+        this.recent.push(line.trim());
+        if (this.recent.length > 20)
+            this.recent.shift();
+        // Bound memory if storage cannot keep up. The CLI exposes dropped/failed writes.
+        if (this.pending >= 10000) {
+            this.failedWrites++;
+            return;
+        }
+        this.pending++;
+        this.queue = this.queue.then(async () => {
+            const day = timestamp.slice(0, 10);
+            if (day !== this.day) {
+                await (0, promises_1.mkdir)(this.directory, { recursive: true, mode: 0o700 });
+                this.day = day;
+                this.part = 0;
+                const files = await (0, promises_1.readdir)(this.directory);
+                const prefix = `api-${process.pid}-${day}-`;
+                for (const file of files) {
+                    if (file.startsWith(prefix) && /^\d+\.jsonl$/.test(file.slice(prefix.length)))
+                        this.part = Math.max(this.part, Number(file.slice(prefix.length, -6)));
+                    const match = /^api-\d+-(\d{4}-\d{2}-\d{2})-\d+\.jsonl$/.exec(file);
+                    if (match && Date.parse(match[1]) < Date.parse(day) - this.retentionDays * 86400000)
+                        await (0, promises_1.unlink)((0, node_path_1.join)(this.directory, file)).catch(() => { });
+                }
+                this.size = await (0, promises_1.stat)(this.path()).then(file => file.size, () => 0);
+            }
+            const size = Buffer.byteLength(line);
+            if (this.size && this.size + size > this.maxFileSize) {
+                this.part++;
+                this.size = 0;
+            }
+            await (0, promises_1.appendFile)(this.path(), line, { mode: 0o600 });
+            this.size += size;
+        }).catch(() => { this.failedWrites++; this.day = ''; }).finally(() => { this.pending--; });
+    }
+    path() { return (0, node_path_1.join)(this.directory, `api-${process.pid}-${this.day}-${this.part}.jsonl`); }
+    async flush() { await this.queue; }
+    async close() { this.closed = true; await this.flush(); }
+}
+exports.FileLogger = FileLogger;

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

@@ -0,0 +1,25 @@
+import type { Request, Response, NextFunction } from 'express';
+import { APIOptions } from '../../options';
+export interface HTTPLog {
+    request: {
+        id: string;
+        method: string;
+        path: string;
+        body?: unknown;
+    };
+    response: {
+        status_code: number;
+        duration_ms: number;
+        body?: unknown;
+    };
+}
+export declare function sanitize(value: unknown, keys?: string[], seen?: WeakSet<object>, depth?: number): unknown;
+export declare class RequestLogger {
+    private readonly options;
+    private readonly requests;
+    private readonly logger;
+    constructor(options: APIOptions);
+    use(request: Request, response: Response, next: NextFunction): void;
+    response(request: Request, body: unknown): void;
+    error(request: Request, error: unknown): void;
+}

package/dist/system/logger/request.logger.js

@@ -0,0 +1,99 @@
+"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); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequestLogger = void 0;
+exports.sanitize = sanitize;
+const node_crypto_1 = require("node:crypto");
+const common_1 = require("@nestjs/common");
+const options_1 = require("../../options");
+function sanitize(value, keys = [], seen = new WeakSet(), depth = 0) {
+    if (depth > 12)
+        return '[Truncated]';
+    if (typeof value === 'string')
+        return value.length > 4000 ? `${value.slice(0, 4000)}…` : value;
+    if (value == null || typeof value !== 'object')
+        return value;
+    if (seen.has(value))
+        return '[Circular]';
+    seen.add(value);
+    if (Array.isArray(value))
+        return value.slice(0, 100).map(item => sanitize(item, keys, seen, depth + 1));
+    const result = {};
+    for (const [key, content] of Object.entries(value).slice(0, 100)) {
+        const normalized = key.replace(/[^a-z0-9]/gi, '').toLowerCase();
+        const sensitive = ['password', 'token', 'secret', 'authorization', 'cookie', 'privatekey', 'salt', 'hash', 'cardnumber', 'cvv', 'cvc', 'codeverifier', 'codechallenge', 'code', ...keys.map(item => item.replace(/[^a-z0-9]/gi, '').toLowerCase())];
+        Object.defineProperty(result, key, {
+            value: sensitive.some(item => normalized.includes(item)) ? '[Filtered]' : sanitize(content, keys, seen, depth + 1),
+            enumerable: true
+        });
+    }
+    return result;
+}
+let RequestLogger = class RequestLogger {
+    options;
+    requests = new WeakMap();
+    logger = new common_1.Logger('HTTP');
+    constructor(options) {
+        this.options = options;
+    }
+    use(request, response, next) {
+        const context = { id: (0, node_crypto_1.randomUUID)(), start: performance.now(), body: undefined };
+        this.requests.set(request, context);
+        response.setHeader('X-Request-ID', context.id);
+        response.once('finish', () => {
+            if (this.options.logging === false)
+                return;
+            const settings = this.options.logging || {};
+            const entry = {
+                request: { id: context.id, method: request.method, path: request.path },
+                response: { status_code: response.statusCode, duration_ms: Math.round(performance.now() - context.start) }
+            };
+            if (settings.bodies) {
+                entry.request.body = sanitize(request.body, settings.redact);
+                entry.response.body = sanitize(context.body, settings.redact);
+            }
+            try {
+                if (settings.write)
+                    Promise.resolve(settings.write(entry)).catch(() => this.logger.warn('HTTP log delivery failed.'));
+                else
+                    this.logger.log(entry);
+            }
+            catch {
+                this.logger.warn('HTTP log delivery failed.');
+            }
+        });
+        next();
+    }
+    response(request, body) {
+        const context = this.requests.get(request);
+        if (context)
+            context.body = body;
+    }
+    error(request, error) {
+        if (this.options.logging !== false)
+            this.logger.error(error instanceof Error ? { name: error.name, message: error.message, stack: error.stack, requestId: this.requests.get(request)?.id } : sanitize(error));
+        try {
+            Promise.resolve(this.options.onError?.(error, this.requests.get(request)?.id ?? '')).catch(() => this.logger.warn('Error reporting failed.'));
+        }
+        catch {
+            this.logger.warn('Error reporting failed.');
+        }
+    }
+};
+exports.RequestLogger = RequestLogger;
+exports.RequestLogger = RequestLogger = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Inject)(options_1.API_OPTIONS)),
+    __metadata("design:paramtypes", [Object])
+], RequestLogger);

package/dist/system/pipe/body-validation.pipe.d.ts

@@ -0,0 +1,7 @@
+import { ArgumentMetadata, ValidationPipe } from '@nestjs/common';
+import { APIOptions } from '../../options';
+export declare class BodyValidationPipe extends ValidationPipe {
+    private readonly options;
+    constructor(options: APIOptions);
+    transform(value: unknown, metadata: ArgumentMetadata): Promise<any>;
+}

package/dist/system/pipe/body-validation.pipe.js

@@ -0,0 +1,71 @@
+"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.BodyValidationPipe = void 0;
+const common_1 = require("@nestjs/common");
+const error_plugin_1 = __importDefault(require("../error/error.plugin"));
+const error_code_enum_1 = require("../error/error-code.enum");
+const options_1 = require("../../options");
+const MISSING_PARAMETER = 'A required parameter is missing.';
+const INVALID_PARAMETER = 'Invalid parameter.';
+let BodyValidationPipe = class BodyValidationPipe extends common_1.ValidationPipe {
+    options;
+    constructor(options) {
+        super({
+            transform: true,
+            transformOptions: { enableImplicitConversion: false },
+            whitelist: true,
+            forbidNonWhitelisted: true,
+            forbidUnknownValues: true,
+            skipMissingProperties: false,
+            validationError: { target: false, value: true },
+            exceptionFactory: (errors) => {
+                const issues = collectIssues(errors);
+                return error_plugin_1.default.createException(error_code_enum_1.ErrorCode.wrong_parameter, issues.some(issue => issue.missing) ? MISSING_PARAMETER : INVALID_PARAMETER, common_1.HttpStatus.BAD_REQUEST, { cause: { validation: issues } });
+            }
+        });
+        this.options = options;
+    }
+    async transform(value, metadata) {
+        if (this.options.validation === false || metadata.type !== 'body' || !this.toValidate(metadata))
+            return value;
+        if (value == null || typeof value !== 'object' || Array.isArray(value)) {
+            throw error_plugin_1.default.createException(error_code_enum_1.ErrorCode.wrong_parameter, value == null ? MISSING_PARAMETER : INVALID_PARAMETER, common_1.HttpStatus.BAD_REQUEST, { cause: { validation: [{ field: metadata.data ?? 'body', missing: value == null }] } });
+        }
+        return super.transform(value, metadata);
+    }
+};
+exports.BodyValidationPipe = BodyValidationPipe;
+exports.BodyValidationPipe = BodyValidationPipe = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Inject)(options_1.API_OPTIONS)),
+    __metadata("design:paramtypes", [Object])
+], BodyValidationPipe);
+function collectIssues(errors, parent = '') {
+    return errors.flatMap(error => {
+        const field = parent ? `${parent}.${error.property}` : error.property;
+        const rules = Object.keys(error.constraints ?? {});
+        return [
+            ...(rules.length ? [{
+                    field,
+                    rules,
+                    missing: error.value == null && !rules.includes('whitelistValidation')
+                }] : []),
+            ...collectIssues(error.children ?? [], field)
+        ];
+    });
+}

package/package.json

@@ -1,6 +1,65 @@
 {
   "name": "@deplois/api",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.0.2",
+  "description": "Shared NestJS API infrastructure for deplois",
+  "type": "commonjs",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./database": {
+      "types": "./dist/database/index.d.ts",
+      "default": "./dist/database/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "check": "tsc -p tsconfig.json --noEmit",
+    "test": "npm run build && node --test test/*.test.cjs",
+    "prepack": "npm test",
+    "publish": "node scripts/publish.mjs",
+    "deploy": "node scripts/publish.mjs"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "peerDependencies": {
+    "@nestjs/common": "^11.0.0 || ^12.0.0",
+    "@nestjs/core": "^11.0.0 || ^12.0.0",
+    "class-transformer": "^0.5.1",
+    "class-validator": "^0.15.0",
+    "reflect-metadata": "^0.2.2",
+    "rxjs": "^7.8.1",
+    "typeorm": "^1.1.0"
+  },
+  "peerDependenciesMeta": {
+    "typeorm": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@nestjs/common": "^11.0.1",
+    "@nestjs/core": "^11.0.1",
+    "@nestjs/platform-express": "^11.0.1",
+    "@types/express": "^5.0.0",
+    "@types/node": "^22.10.7",
+    "class-transformer": "^0.5.1",
+    "class-validator": "^0.15.1",
+    "reflect-metadata": "^0.2.2",
+    "rxjs": "^7.8.1",
+    "typeorm": "^1.1.0",
+    "typescript": "^5.7.3"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "license": "UNLICENSED"
+}