oc 0.50.57 → 0.50.58

package/dist/registry/domain/http-server/types.d.ts

@@ -0,0 +1,108 @@
+import type http from 'node:http';
+import type { IncomingHttpHeaders } from 'node:http';
+import type express from 'express';
+import type { Config } from '../../../types';
+export interface CookieOptions {
+    domain?: string;
+    encode?: (value: string) => string;
+    expires?: Date;
+    httpOnly?: boolean;
+    maxAge?: number;
+    partitioned?: boolean;
+    path?: string;
+    priority?: 'low' | 'medium' | 'high';
+    sameSite?: boolean | 'lax' | 'strict' | 'none';
+    secure?: boolean;
+    signed?: boolean;
+}
+export type Method = 'get' | 'post' | 'put' | 'patch' | 'head' | 'delete';
+export interface UploadedFile {
+    fieldname: string;
+    originalname: string;
+    encoding: string;
+    mimetype: string;
+    size: number;
+    destination: string;
+    filename: string;
+    path: string;
+    buffer?: Buffer;
+    stream?: NodeJS.ReadableStream;
+    truncated?: boolean;
+}
+export interface OcRequest {
+    method: string;
+    url: string;
+    path: string;
+    originalUrl: string;
+    protocol: string;
+    secure: boolean;
+    ip: string;
+    headers: IncomingHttpHeaders;
+    params: Record<string, string>;
+    query: Record<string, unknown>;
+    body: any;
+    cookies: Record<string, string>;
+    files?: UploadedFile[] | Record<string, UploadedFile[]>;
+    user?: string;
+    routeId: string;
+    get(header: string): string | undefined;
+    raw: http.IncomingMessage;
+}
+export interface OcResponse {
+    conf: Config;
+    errorCode?: string;
+    errorDetails?: string;
+    statusCode: number;
+    status(code: number): this;
+    json(body: unknown): void;
+    send(body: unknown): void;
+    set(field: string | Record<string, string>, value?: string): this;
+    header(name: string, value: string): this;
+    setHeader(name: string, value: string): this;
+    removeHeader(name: string): this;
+    type(mime: string): this;
+    cookie(name: string, value: string, opts?: CookieOptions): this;
+    redirect(url: string): void;
+    end(chunk?: unknown): void;
+    stream(readable: NodeJS.ReadableStream): void;
+    raw: http.ServerResponse;
+}
+export type OcHandler = (req: OcRequest, res: OcResponse) => void | Promise<void>;
+export type ExpressMiddleware = (req: any, res: any, next: (err?: unknown) => void) => void;
+export type HttpServerAdapterFactory<TOptions = unknown, TNative = unknown> = {
+    (options?: unknown): HttpServerAdapter<TNative>;
+    readonly __serverAdapterOptions?: TOptions;
+};
+export type HttpServerAdapterOptions<TAdapter> = TAdapter extends {
+    readonly __serverAdapterOptions?: infer TOptions;
+} ? TOptions : TAdapter extends (options?: infer TOptions) => HttpServerAdapter ? TOptions : unknown;
+export type NativeApp<TAdapter> = TAdapter extends (...args: any[]) => HttpServerAdapter<infer TNative> ? unknown extends TNative ? express.Express : TNative : TAdapter extends HttpServerAdapter<infer TNative> ? unknown extends TNative ? express.Express : TNative : express.Express;
+export interface HttpServerAdapter<TNative = unknown> {
+    name: string;
+    enableBodyParser(opts: {
+        limit?: number | string;
+    }): void;
+    enableCookies(): void;
+    enableFileUploads(opts: {
+        tempDir: string;
+        filename: (originalName: string) => string;
+    }): void;
+    enableRequestTiming(onDone: (req: OcRequest, res: OcResponse, ms: number) => void): void;
+    enableLogging(opts: {
+        skip: (req: OcRequest, res: OcResponse) => boolean;
+    }): void;
+    enableErrorHandler(): void;
+    use(handler: OcHandler): void;
+    route(method: Method, path: string, id: string, handlers: OcHandler[]): void;
+    fromConnect(handler: ExpressMiddleware): OcHandler;
+    listen(opts: {
+        port: number | string;
+        timeout: number;
+        keepAliveTimeout?: number;
+    }, cb: (err?: Error) => void): void;
+    onServerError(cb: (err: Error) => void): void;
+    close(cb: (err?: Error) => void): void;
+    isListening(): boolean;
+    native(): TNative;
+    httpServer(): http.Server;
+}

package/dist/registry/domain/http-server/types.js

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

package/dist/registry/domain/options-sanitiser.d.ts

@@ -1,7 +1,8 @@
 import { compileSync } from 'oc-client-browser';
 import type { Config } from '../../types';
+import type { HttpServerAdapterFactory } from './http-server/types';
 type CompileOptions = Omit<Exclude<Parameters<typeof compileSync>[0], undefined>, 'templates'>;
-export interface RegistryOptions<T = any> extends Partial<Omit<Config<T>, 'beforePublish' | 'discovery' | 'plugins'>> {
+export interface RegistryOptions<T = any, TServerAdapter extends HttpServerAdapterFactory = HttpServerAdapterFactory> extends Partial<Omit<Config<T, TServerAdapter>, 'beforePublish' | 'discovery' | 'plugins'>> {
     /**
      * Configuration object to enable/disable the HTML discovery page and the API
      *
@@ -28,5 +29,5 @@ export interface RegistryOptions<T = any> extends Partial<Omit<Config<T>, 'befor
      */
     compileClient?: boolean | CompileOptions;
 }
-export default function optionsSanitiser(input: RegistryOptions): Config;
+export default function optionsSanitiser<T = any, TServerAdapter extends HttpServerAdapterFactory = HttpServerAdapterFactory>(input: RegistryOptions<T, TServerAdapter>): Config;
 export {};

package/dist/registry/domain/options-sanitiser.js

@@ -41,6 +41,7 @@ const node_zlib_1 = __importDefault(require("node:zlib"));
 const oc_client_browser_1 = require("oc-client-browser");
 const settings_1 = __importDefault(require("../../resources/settings"));
 const auth = __importStar(require("./authentication"));
+const express_adapter_1 = __importDefault(require("./http-server/express-adapter"));
 const DEFAULT_NODE_KEEPALIVE_MS = 5000;
 function optionsSanitiser(input) {
     const options = { ...input };
@@ -165,6 +166,18 @@ function optionsSanitiser(input) {
     options.timeout = options.timeout || 1000 * 60 * 2;
     options.keepAliveTimeout =
         options.keepAliveTimeout || DEFAULT_NODE_KEEPALIVE_MS;
+    if (!options.server) {
+        options.server = {
+            adapter: express_adapter_1.default,
+            options: { port: options.port }
+        };
+    }
+    if (!options.server.adapter) {
+        options.server.adapter = express_adapter_1.default;
+    }
+    if (typeof options.server.options === 'undefined') {
+        options.server.options = { port: options.port };
+    }
     if (options.s3) {
         options.storage = {
             adapter: require('oc-s3-storage-adapter'),

package/dist/registry/domain/server-adapter.d.ts

@@ -0,0 +1,4 @@
+import type { HttpServerAdapter } from './http-server/types';
+type HttpServerAdapterFactory<T = unknown> = (options?: T) => HttpServerAdapter;
+export default function getHttpServerAdapter<T = unknown>(adapter: HttpServerAdapter | HttpServerAdapterFactory<T>, options?: T): HttpServerAdapter;
+export {};

package/dist/registry/domain/server-adapter.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = getHttpServerAdapter;
+function isHttpServerAdapter(adapter) {
+    return (!!adapter &&
+        typeof adapter === 'object' &&
+        typeof adapter.native === 'function' &&
+        typeof adapter.listen === 'function' &&
+        typeof adapter.httpServer === 'function');
+}
+function getHttpServerAdapter(adapter, options) {
+    if (isHttpServerAdapter(adapter)) {
+        return adapter;
+    }
+    const instance = adapter(options);
+    if (!isHttpServerAdapter(instance)) {
+        throw new Error('Invalid HTTP server adapter');
+    }
+    return instance;
+}

package/dist/registry/domain/validators/uploaded-package.d.ts

@@ -1,13 +1,14 @@
+import type { UploadedFile } from '../http-server/types';
 type ValidationResponse = {
     isValid: true;
-    files: Express.Multer.File[] | {
-        [fieldname: string]: Express.Multer.File[];
+    files: UploadedFile[] | {
+        [fieldname: string]: UploadedFile[];
     };
 } | {
     isValid: false;
     message: string;
 };
-export default function uploadedPackage(input?: Express.Multer.File[] | {
-    [fieldname: string]: Express.Multer.File[];
+export default function uploadedPackage(input?: UploadedFile[] | {
+    [fieldname: string]: UploadedFile[];
 }): ValidationResponse;
 export {};

package/dist/registry/index.d.ts

@@ -1,75 +1,17 @@
-import http from 'node:http';
-import express from 'express';
+import type http from 'node:http';
 import type { Plugin } from '../types';
+import eventsHandler from './domain/events-handler';
+import type { HttpServerAdapterFactory, NativeApp } from './domain/http-server/types';
 import { RegistryOptions } from './domain/options-sanitiser';
 export { RegistryOptions };
-export default function registry<T = any>(inputOptions: RegistryOptions<T>): {
+export interface RegistryType<TApp = NativeApp<HttpServerAdapterFactory>> {
     close: (callback: (err?: Error | undefined | string) => void) => void;
-    on: <T_1 extends keyof {
-        error: {
-            code: string;
-            message: string;
-        };
-        start: unknown;
-        'cache-poll': number;
-        request: import("./domain/events-handler").RequestData;
-        'component-retrieved': {
-            headers: http.IncomingHttpHeaders;
-            name: string;
-            parameters: http.IncomingHttpHeaders;
-            requestVersion: string;
-            duration: number;
-        };
-        'data-provider-error': {
-            name: string;
-            version: string;
-            parameters: Record<string, string | boolean | number>;
-            requestVersion: string;
-            status: number;
-            error: Error;
-        };
-        'component-published': {
-            componentName: string;
-            componentVersion: string;
-            packageJson: import("../types").Component;
-            componentFolder: string;
-            user?: string;
-        };
-    }>(eventName: T_1, listener: (data: {
-        error: {
-            code: string;
-            message: string;
-        };
-        start: unknown;
-        'cache-poll': number;
-        request: import("./domain/events-handler").RequestData;
-        'component-retrieved': {
-            headers: http.IncomingHttpHeaders;
-            name: string;
-            parameters: http.IncomingHttpHeaders;
-            requestVersion: string;
-            duration: number;
-        };
-        'data-provider-error': {
-            name: string;
-            version: string;
-            parameters: Record<string, string | boolean | number>;
-            requestVersion: string;
-            status: number;
-            error: Error;
-        };
-        'component-published': {
-            componentName: string;
-            componentVersion: string;
-            packageJson: import("../types").Component;
-            componentFolder: string;
-            user?: string;
-        };
-    }[T_1]) => void) => void;
-    register: <T_1 = any>(plugin: Plugin<T_1>, callback?: (...args: any[]) => void) => void;
+    on: typeof eventsHandler.on;
+    register: <T = any>(plugin: Plugin<T>, callback?: (...args: any[]) => void) => void;
     start: (callback: (err: unknown, data?: {
-        app: express.Express;
+        app: TApp;
         server: http.Server;
     }) => void) => Promise<void>;
-    app: express.Express;
-};
+    app: TApp;
+}
+export default function registry<T = any, TServerAdapter extends HttpServerAdapterFactory = HttpServerAdapterFactory, TApp = NativeApp<TServerAdapter>>(inputOptions: RegistryOptions<T, TServerAdapter>): RegistryType<TApp>;

package/dist/registry/index.js

@@ -37,14 +37,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = registry;
-const node_http_1 = __importDefault(require("node:http"));
 const safe_1 = __importDefault(require("colors/safe"));
-const express_1 = __importDefault(require("express"));
 const app_start_1 = __importDefault(require("./app-start"));
 const events_handler_1 = __importDefault(require("./domain/events-handler"));
 const options_sanitiser_1 = __importDefault(require("./domain/options-sanitiser"));
 const pluginsInitialiser = __importStar(require("./domain/plugins-initialiser"));
 const repository_1 = __importDefault(require("./domain/repository"));
+const server_adapter_1 = __importDefault(require("./domain/server-adapter"));
 const validator = __importStar(require("./domain/validators"));
 const middleware = __importStar(require("./middleware"));
 const router_1 = require("./router");
@@ -55,13 +54,13 @@ function registry(inputOptions) {
     }
     const options = (0, options_sanitiser_1.default)(inputOptions);
     const plugins = [];
-    const app = middleware.bind((0, express_1.default)(), options);
-    let server;
+    const adapter = middleware.bind((0, server_adapter_1.default)(options.server.adapter, options.server.options), options);
+    const app = adapter.native();
     const repository = (0, repository_1.default)(options);
     const close = (callback) => {
         const closeMetadataStore = () => Promise.resolve(repository.close?.()).catch(() => undefined);
-        if (server?.listening) {
-            server.close((err) => {
+        if (adapter.isListening()) {
+            adapter.close((err) => {
                 void closeMetadataStore().finally(() => callback(err));
             });
             return;
@@ -75,30 +74,29 @@ function registry(inputOptions) {
         const ok = (msg) => console.log(safe_1.default.green(msg));
         try {
             options.plugins = await pluginsInitialiser.init(plugins);
-            (0, router_1.create)(app, options, repository);
+            (0, router_1.create)(adapter, options, repository);
             const componentsInfo = await repository.init();
             await (0, app_start_1.default)(repository, options);
-            server = node_http_1.default.createServer(app);
-            server.timeout = options.timeout;
-            if (options.keepAliveTimeout) {
-                server.keepAliveTimeout = options.keepAliveTimeout;
-            }
-            server.listen(options.port, (err) => {
+            adapter.listen({
+                port: options.port,
+                timeout: options.timeout,
+                keepAliveTimeout: options.keepAliveTimeout
+            }, (err) => {
                 if (err) {
                     return callback(err);
                 }
                 events_handler_1.default.fire('start', {});
                 if (options.verbosity) {
-                    ok(`Registry started at port http://localhost:${app.get('port')}${options.prefix}`);
+                    ok(`Registry started at port http://localhost:${options.port}${options.prefix}`);
                     if (componentsInfo) {
                         const componentsNumber = Object.keys(componentsInfo.components).length;
                         const componentsReleases = Object.values(componentsInfo.components).reduce((acc, component) => acc + Object.keys(component).length, 0);
                         ok(`Registry serving ${componentsNumber} components for a total of ${componentsReleases} releases.`);
                     }
                 }
-                callback(null, { app, server });
+                callback(null, { app, server: adapter.httpServer() });
             });
-            server.on('error', (error) => {
+            adapter.onServerError((error) => {
                 events_handler_1.default.fire('error', {
                     code: 'EXPRESS_ERROR',
                     message: error?.message ?? String(error)

package/dist/registry/middleware/base-url-handler.d.ts

@@ -1,2 +1,3 @@
-import type { NextFunction, Request, Response } from 'express';
-export default function baseUrlHandler(req: Request, res: Response, next: NextFunction): void;
+import type { OcHandler } from '../domain/http-server/types';
+declare const baseUrlHandler: OcHandler;
+export default baseUrlHandler;

package/dist/registry/middleware/base-url-handler.js

@@ -1,12 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = baseUrlHandler;
-function baseUrlHandler(req, res, next) {
+const baseUrlHandler = (req, res) => {
     if (res.conf.baseUrlFunc) {
         res.conf.baseUrl = res.conf.baseUrlFunc({
             host: req.headers.host,
             secure: req.secure
         });
     }
-    next();
-}
+};
+exports.default = baseUrlHandler;

package/dist/registry/middleware/compression.d.ts

@@ -1,6 +1,6 @@
-import type { Request, Response } from 'express';
+import type { OcRequest, OcResponse } from '../domain/http-server/types';
 export default function compress(data: {
     uncompressed: string;
     brotli: Buffer;
     gzip: Buffer;
-}, req: Request, res: Response): void;
+}, req: OcRequest, res: OcResponse): void;

package/dist/registry/middleware/compression.js

@@ -9,7 +9,7 @@ function compress(data, req, res) {
         res.send(data.uncompressed);
         return;
     }
-    res.setHeader('Content-Encoding', encoding);
+    res.set('Content-Encoding', encoding);
     const compressed = encoding === 'br' ? data.brotli : data.gzip;
     res.send(compressed);
 }

package/dist/registry/middleware/cors.d.ts

@@ -1,2 +1,3 @@
-import type { NextFunction, Request, Response } from 'express';
-export default function cors(_req: Request, res: Response, next: NextFunction): void;
+import type { OcHandler } from '../domain/http-server/types';
+declare const cors: OcHandler;
+export default cors;

package/dist/registry/middleware/cors.js

@@ -1,11 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = cors;
-function cors(_req, res, next) {
+const cors = (_req, res) => {
     res.removeHeader('X-Powered-By');
-    res.header('Access-Control-Allow-Credentials', 'true');
-    res.header('Access-Control-Allow-Origin', '*');
-    res.header('Access-Control-Allow-Headers', 'Origin, X-Requested-With, Content-Type, Accept, traceparent');
-    res.header('Access-Control-Allow-Methods', 'GET, OPTIONS, PUT, POST');
-    next();
-}
+    res.set('Access-Control-Allow-Credentials', 'true');
+    res.set('Access-Control-Allow-Origin', '*');
+    res.set('Access-Control-Allow-Headers', 'Origin, X-Requested-With, Content-Type, Accept, traceparent');
+    res.set('Access-Control-Allow-Methods', 'GET, OPTIONS, PUT, POST');
+};
+exports.default = cors;

package/dist/registry/middleware/discovery-handler.d.ts

@@ -1,2 +1,3 @@
-import type { NextFunction, Request, Response } from 'express';
-export default function discoveryHandler(req: Request, res: Response, next: NextFunction): void;
+import type { OcHandler } from '../domain/http-server/types';
+declare const discoveryHandler: OcHandler;
+export default discoveryHandler;

package/dist/registry/middleware/discovery-handler.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = discoveryHandler;
-function discoveryHandler(req, res, next) {
+const discoveryHandler = (req, res) => {
     res.conf.discoveryFunc =
         res.conf.discoveryFunc ||
             (typeof res.conf.discovery === 'function' ? res.conf.discovery : undefined);
@@ -11,5 +10,5 @@ function discoveryHandler(req, res, next) {
             secure: req.secure
         });
     }
-    next();
-}
+};
+exports.default = discoveryHandler;

package/dist/registry/middleware/index.d.ts

@@ -1,3 +1,3 @@
-import { type Express } from 'express';
 import type { Config } from '../../types';
-export declare const bind: (app: Express, options: Config) => Express;
+import type { HttpServerAdapter } from '../domain/http-server/types';
+export declare const bind: (adapter: HttpServerAdapter, options: Config) => HttpServerAdapter;

package/dist/registry/middleware/index.js

@@ -4,54 +4,57 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.bind = void 0;
-const cookie_parser_1 = __importDefault(require("cookie-parser"));
-const errorhandler_1 = __importDefault(require("errorhandler"));
-const express_1 = __importDefault(require("express"));
-const morgan_1 = __importDefault(require("morgan"));
+const events_handler_1 = __importDefault(require("../domain/events-handler"));
 const base_url_handler_1 = __importDefault(require("./base-url-handler"));
 const cors_1 = __importDefault(require("./cors"));
 const discovery_handler_1 = __importDefault(require("./discovery-handler"));
-const file_uploads_1 = __importDefault(require("./file-uploads"));
-const request_handler_1 = __importDefault(require("./request-handler"));
-const bodyParserJsonArgument = {
-    inflate: true
-};
-const bodyParserUrlEncodedArgument = {
-    extended: true
-};
-const bind = (app, options) => {
-    app.set('port', options.port);
-    app.set('json spaces', 0);
-    app.set('etag', 'strong');
-    app.use((_req, res, next) => {
+const normaliseFileName = (x) => x.replace('.tar.gz', '').replace(/\W+/g, '-').toLowerCase();
+const bind = (adapter, options) => {
+    adapter.use((_req, res) => {
         res.conf = options;
-        next();
     });
-    app.use((0, request_handler_1.default)());
-    app.use((0, cookie_parser_1.default)());
-    if (options.postRequestPayloadSize) {
-        // Type is incorrect since limit can be a string like '50mb'
-        bodyParserJsonArgument.limit = options.postRequestPayloadSize;
-        bodyParserUrlEncodedArgument.limit =
-            options.postRequestPayloadSize;
+    adapter.enableRequestTiming((req, res, time) => {
+        const data = {
+            body: req.body,
+            duration: time,
+            headers: req.headers,
+            method: req.method,
+            path: req.path,
+            relativeUrl: req.originalUrl,
+            query: req.query,
+            url: req.protocol + '://' + req.get('host') + req.originalUrl,
+            statusCode: res.statusCode
+        };
+        if (res.errorDetails) {
+            data.errorDetails = res.errorDetails;
+        }
+        if (res.errorCode) {
+            data.errorCode = res.errorCode;
+        }
+        events_handler_1.default.fire('request', data);
+    });
+    adapter.enableCookies();
+    adapter.enableBodyParser({ limit: options.postRequestPayloadSize });
+    adapter.use(cors_1.default);
+    if (!options.local) {
+        adapter.enableFileUploads({
+            tempDir: options.tempDir,
+            filename: (originalName) => `${normaliseFileName(originalName)}-${Date.now()}.tar.gz`
+        });
     }
-    app.use(express_1.default.json(bodyParserJsonArgument));
-    app.use(express_1.default.urlencoded(bodyParserUrlEncodedArgument));
-    app.use(cors_1.default);
-    app.use(file_uploads_1.default);
-    app.use(base_url_handler_1.default);
-    app.use(discovery_handler_1.default);
+    adapter.use(base_url_handler_1.default);
+    adapter.use(discovery_handler_1.default);
     if (options.verbosity) {
-        app.use((0, morgan_1.default)('dev', {
+        adapter.enableLogging({
             skip: (req, res) => {
                 // Hide logging development console calls
-                return req.url.startsWith(`${res.conf.prefix}~actions/$$__oc__server___console__$$`);
+                return req.url.startsWith(`${res.conf?.prefix ?? ''}~actions/$$__oc__server___console__$$`);
             }
-        }));
+        });
     }
     if (options.local) {
-        app.use((0, errorhandler_1.default)());
+        adapter.enableErrorHandler();
     }
-    return app;
+    return adapter;
 };
 exports.bind = bind;

package/dist/registry/router.d.ts

@@ -1,4 +1,4 @@
-import type { Express } from 'express';
 import type { Repository } from '../registry/domain/repository';
 import type { Config } from '../types';
-export declare function create(app: Express, conf: Config, repository: Repository): void;
+import type { HttpServerAdapter } from './domain/http-server/types';
+export declare function create(adapter: HttpServerAdapter, conf: Config, repository: Repository): void;