oc 0.50.55 → 0.50.57-beta.0

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

@@ -0,0 +1,196 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = createExpressAdapter;
+const node_http_1 = __importDefault(require("node:http"));
+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 multer_1 = __importDefault(require("multer"));
+const response_time_1 = __importDefault(require("response-time"));
+const expressMiddleware = Symbol('expressMiddleware');
+const ocResponseSym = Symbol('ocResponse');
+const ocParamsSym = Symbol('ocParams');
+function stream(readable) {
+    readable.pipe(this.raw);
+}
+function normaliseParams(raw) {
+    const params = { ...raw };
+    const splat = raw['splat'];
+    if (Array.isArray(splat)) {
+        params['splat'] = splat.join('/');
+    }
+    return params;
+}
+function createExpressAdapter(options) {
+    const adapterOptions = options;
+    return new ExpressHttpServerAdapter(typeof adapterOptions === 'object' ? adapterOptions.port : adapterOptions);
+}
+class ExpressHttpServerAdapter {
+    name = 'express';
+    app;
+    server;
+    serverErrorHandlers = [];
+    constructor(port) {
+        this.app = (0, express_1.default)();
+        if (typeof port !== 'undefined') {
+            this.app.set('port', port);
+        }
+        this.app.set('json spaces', 0);
+        this.app.set('etag', 'strong');
+    }
+    enableBodyParser(opts) {
+        this.app.use(express_1.default.json({
+            inflate: true,
+            limit: opts.limit
+        }));
+        this.app.use(express_1.default.urlencoded({
+            extended: true,
+            limit: opts.limit
+        }));
+    }
+    enableCookies() {
+        this.app.use((0, cookie_parser_1.default)());
+    }
+    enableFileUploads(opts) {
+        const upload = (0, multer_1.default)({
+            limits: {
+                fieldSize: 10
+            },
+            storage: multer_1.default.diskStorage({
+                destination: opts.tempDir,
+                filename: (_req, file, cb) => cb(null, opts.filename(file.originalname))
+            })
+        });
+        this.app.use(upload.any());
+    }
+    enableRequestTiming(onDone) {
+        this.app.use((0, response_time_1.default)((req, res, time) => {
+            onDone(this.toOcRequest(req), this.toOcResponse(res), time);
+        }));
+    }
+    enableLogging(opts) {
+        this.app.use((0, morgan_1.default)('dev', {
+            skip: (req, res) => opts.skip(this.toOcRequest(req), this.toOcResponse(res))
+        }));
+    }
+    enableErrorHandler() {
+        this.app.use((0, errorhandler_1.default)());
+    }
+    use(handler) {
+        this.app.use(this.toExpressHandler(handler, true));
+    }
+    route(method, path, id, handlers) {
+        const setRouteId = (req, _res, next) => {
+            req.routeId = id;
+            next();
+        };
+        this.app[method](path, setRouteId, ...handlers.map((handler) => this.toExpressHandler(handler)));
+    }
+    fromConnect(handler) {
+        const wrapped = (req, res) => new Promise((resolve, reject) => {
+            handler(req.raw ?? req, res.raw ?? res, (err) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve();
+                }
+            });
+        });
+        wrapped[expressMiddleware] = handler;
+        return wrapped;
+    }
+    listen(opts, cb) {
+        this.server = node_http_1.default.createServer(this.app);
+        this.server.timeout = opts.timeout;
+        if (opts.keepAliveTimeout) {
+            this.server.keepAliveTimeout = opts.keepAliveTimeout;
+        }
+        for (const handler of this.serverErrorHandlers) {
+            this.server.on('error', handler);
+        }
+        this.server.listen(opts.port, cb);
+    }
+    onServerError(cb) {
+        this.serverErrorHandlers.push(cb);
+        this.server?.on('error', cb);
+    }
+    close(cb) {
+        this.server?.close(cb);
+    }
+    isListening() {
+        return !!this.server?.listening;
+    }
+    native() {
+        return this.app;
+    }
+    httpServer() {
+        if (!this.server) {
+            throw new Error('HTTP server has not been started');
+        }
+        return this.server;
+    }
+    toExpressHandler(handler, continueWhenNotSent = false) {
+        const native = handler[expressMiddleware];
+        if (native) {
+            return native;
+        }
+        return (req, res, next) => {
+            let result;
+            try {
+                result = handler(this.toOcRequest(req), this.toOcResponse(res));
+            }
+            catch (err) {
+                next(err);
+                return;
+            }
+            if (result && typeof result.then === 'function') {
+                result
+                    .then(() => {
+                    if (continueWhenNotSent && !res.headersSent) {
+                        next();
+                    }
+                })
+                    .catch(next);
+            }
+            else if (continueWhenNotSent && !res.headersSent) {
+                next();
+            }
+        };
+    }
+    toOcRequest(req) {
+        const memo = req[ocParamsSym];
+        const current = (req.params ?? {});
+        if (memo && memo.source === current) {
+            return req;
+        }
+        if (!memo) {
+            Object.assign(req, {
+                raw: req,
+                routeId: req.routeId ?? ''
+            });
+        }
+        const normalized = normaliseParams(current);
+        Object.assign(req, { params: normalized });
+        req[ocParamsSym] = {
+            source: normalized
+        };
+        return req;
+    }
+    toOcResponse(res) {
+        const cached = res[ocResponseSym];
+        if (cached) {
+            return cached;
+        }
+        const ocRes = Object.assign(res, {
+            raw: res,
+            stream
+        });
+        res[ocResponseSym] = ocRes;
+        return ocRes;
+    }
+}

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

@@ -0,0 +1,99 @@
+import type http from 'node:http';
+import type { IncomingHttpHeaders } from 'node:http';
+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 interface HttpServerAdapter {
+    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(): unknown;
+    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/metadata-adapter-options.d.ts

@@ -0,0 +1,6 @@
+import type { MetadataConfig } from '../../types';
+type MetadataOptionsConfig = {
+    metadata?: Pick<MetadataConfig, 'manageSchema' | 'options'>;
+};
+declare const getMetadataAdapterOptions: (conf: MetadataOptionsConfig) => any;
+export default getMetadataAdapterOptions;

package/dist/registry/domain/metadata-adapter-options.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const getMetadataAdapterOptions = (conf) => {
+    if (typeof conf.metadata?.manageSchema === 'undefined') {
+        return conf.metadata?.options;
+    }
+    return {
+        ...(conf.metadata.options || {}),
+        manageSchema: conf.metadata.manageSchema
+    };
+};
+exports.default = getMetadataAdapterOptions;

package/dist/registry/domain/metadata-index.d.ts

@@ -0,0 +1,15 @@
+import type { Component, ComponentRow, ComponentsDetails, ComponentsList, MetadataStore } from '../../types';
+export declare const getComponentsListFromRows: (rows: ComponentRow[]) => ComponentsList;
+export declare const getComponentsDetailsFromRows: (rows: ComponentRow[]) => ComponentsDetails;
+export declare const getComponentRow: (name: string, version: string, component: Component) => ComponentRow;
+export interface MetadataSnapshot {
+    componentsList: ComponentsList;
+    componentsDetails: ComponentsDetails;
+}
+export interface MetadataIndex {
+    get(): MetadataSnapshot | undefined;
+    add(row: ComponentRow): MetadataSnapshot;
+    refresh(): Promise<MetadataSnapshot>;
+    getOrRefresh(): Promise<MetadataSnapshot>;
+}
+export declare const createMetadataIndex: (metadataStore: MetadataStore) => MetadataIndex;

package/dist/registry/domain/metadata-index.js

@@ -0,0 +1,132 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMetadataIndex = exports.getComponentRow = exports.getComponentsDetailsFromRows = exports.getComponentsListFromRows = void 0;
+const semver_1 = __importDefault(require("semver"));
+// Derive `lastEdit` from the data itself (the most recent publish) rather than
+// the wall-clock time the snapshot happened to be built. This keeps the value
+// semantically meaningful (it only advances when something is actually
+// published) so the poll's `data.lastEdit > cached.lastEdit` guard works and
+// the exported legacy `components.json` reflects the real last edit.
+const getLastEditFromRows = (rows) => rows.reduce((max, row) => (row.publishDate > max ? row.publishDate : max), 0);
+const getComponentsListFromRows = (rows) => {
+    const components = {};
+    for (const row of rows) {
+        const versions = components[row.name] || [];
+        versions.push(row.version);
+        components[row.name] = versions;
+    }
+    for (const versions of Object.values(components)) {
+        versions.sort(semver_1.default.compare);
+    }
+    return {
+        lastEdit: getLastEditFromRows(rows),
+        components
+    };
+};
+exports.getComponentsListFromRows = getComponentsListFromRows;
+const getComponentsDetailsFromRows = (rows) => {
+    const components = {};
+    for (const row of rows) {
+        const componentDetails = components[row.name] || {};
+        componentDetails[row.version] = { publishDate: row.publishDate };
+        if (row.templateSize !== undefined) {
+            componentDetails[row.version].templateSize = row.templateSize;
+        }
+        components[row.name] = componentDetails;
+    }
+    return {
+        lastEdit: getLastEditFromRows(rows),
+        components
+    };
+};
+exports.getComponentsDetailsFromRows = getComponentsDetailsFromRows;
+const getComponentRow = (name, version, component) => ({
+    name,
+    version,
+    publishDate: component.oc.date || 0,
+    templateSize: component.oc.files.template.size
+});
+exports.getComponentRow = getComponentRow;
+const FORCED_REFRESH_INTERVAL_MS = 5 * 60 * 1000;
+const buildSnapshot = (rows) => ({
+    componentsList: (0, exports.getComponentsListFromRows)(rows),
+    componentsDetails: (0, exports.getComponentsDetailsFromRows)(rows)
+});
+const createMetadataIndex = (metadataStore) => {
+    let snapshot;
+    let lastChangeToken;
+    let lastForcedRefreshAt = 0;
+    let localAddGeneration = 0;
+    const refresh = async () => {
+        const refreshGeneration = localAddGeneration;
+        const changeToken = metadataStore.getChangeToken
+            ? await metadataStore.getChangeToken()
+            : undefined;
+        const now = Date.now();
+        if (snapshot &&
+            changeToken !== undefined &&
+            changeToken === lastChangeToken &&
+            now - lastForcedRefreshAt < FORCED_REFRESH_INTERVAL_MS) {
+            return snapshot;
+        }
+        const rows = await metadataStore.getAllComponents();
+        if (snapshot && refreshGeneration !== localAddGeneration) {
+            return snapshot;
+        }
+        snapshot = buildSnapshot(rows);
+        lastChangeToken = changeToken;
+        lastForcedRefreshAt = now;
+        return snapshot;
+    };
+    const add = (row) => {
+        // No snapshot yet: build one from the single row.
+        if (!snapshot) {
+            snapshot = buildSnapshot([row]);
+            localAddGeneration += 1;
+            return snapshot;
+        }
+        const { name, version } = row;
+        const prevList = snapshot.componentsList.components;
+        const prevDetails = snapshot.componentsDetails.components;
+        // Already present: keep the snapshot unchanged (mirrors the unique-constraint
+        // guarantee, so a duplicate publish doesn't disturb the cache).
+        if (prevDetails[name]?.[version]) {
+            return snapshot;
+        }
+        // Only the published component is rebuilt; every other component entry is
+        // shared by reference, so the cost is O(versions-of-this-component) rather
+        // than O(registry). New container objects are produced (rather than mutating
+        // in place) so in-flight readers keep a consistent view of the old snapshot.
+        const versions = [...(prevList[name] ?? []), version].sort(semver_1.default.compare);
+        const detail = {
+            ...(prevDetails[name] ?? {}),
+            [version]: { publishDate: row.publishDate }
+        };
+        if (row.templateSize !== undefined) {
+            detail[version].templateSize = row.templateSize;
+        }
+        const lastEdit = Math.max(snapshot.componentsList.lastEdit, row.publishDate);
+        snapshot = {
+            componentsList: {
+                lastEdit,
+                components: { ...prevList, [name]: versions }
+            },
+            componentsDetails: {
+                lastEdit,
+                components: { ...prevDetails, [name]: detail }
+            }
+        };
+        localAddGeneration += 1;
+        return snapshot;
+    };
+    return {
+        get: () => snapshot,
+        add,
+        refresh,
+        getOrRefresh: () => (snapshot ? Promise.resolve(snapshot) : refresh())
+    };
+};
+exports.createMetadataIndex = createMetadataIndex;

package/dist/registry/domain/metadata-migration.d.ts

@@ -0,0 +1,38 @@
+import type { StorageAdapter } from 'oc-storage-adapters-utils';
+import type { ComponentRow, ComponentsDetails, MetadataStore } from '../../types';
+export interface MetadataMigrationResult {
+    scanned: number;
+    inserted: number;
+    skipped: number;
+}
+export interface MetadataExportResult {
+    exported: number;
+    files: string[];
+}
+export declare const getComponentRowsFromComponentsDetails: (componentsDetails: ComponentsDetails) => ComponentRow[];
+export declare const backfillMetadataRows: (metadataStore: MetadataStore, rows: ComponentRow[]) => Promise<MetadataMigrationResult>;
+export declare const backfillMetadataFromComponentsDetails: (metadataStore: MetadataStore, componentsDetails: ComponentsDetails) => Promise<MetadataMigrationResult>;
+export declare const getComponentRowsFromStorageDirectories: (options: {
+    cdn: StorageAdapter;
+    componentsDir: string;
+}) => Promise<ComponentRow[]>;
+export declare const backfillMetadataFromStorageDirectories: (options: {
+    metadataStore: MetadataStore;
+    cdn: StorageAdapter;
+    componentsDir: string;
+}) => Promise<MetadataMigrationResult>;
+export declare const reconcileMetadataFromStorage: (options: {
+    metadataStore: MetadataStore;
+    cdn: StorageAdapter;
+    componentsDir: string;
+}) => Promise<MetadataMigrationResult>;
+export declare const exportLegacyMetadataFiles: (options: {
+    metadataStore: MetadataStore;
+    cdn: StorageAdapter;
+    componentsDir: string;
+}) => Promise<MetadataExportResult>;
+export declare const backfillMetadataFromStorageDetails: (options: {
+    metadataStore: MetadataStore;
+    cdn: StorageAdapter;
+    componentsDir: string;
+}) => Promise<MetadataMigrationResult>;

package/dist/registry/domain/metadata-migration.js

@@ -0,0 +1,128 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.backfillMetadataFromStorageDetails = exports.exportLegacyMetadataFiles = exports.reconcileMetadataFromStorage = exports.backfillMetadataFromStorageDirectories = exports.getComponentRowsFromStorageDirectories = exports.backfillMetadataFromComponentsDetails = exports.backfillMetadataRows = exports.getComponentRowsFromComponentsDetails = void 0;
+const oc_metadata_adapters_utils_1 = require("oc-metadata-adapters-utils");
+const pLimit_1 = __importDefault(require("../../utils/pLimit"));
+const metadata_index_1 = require("./metadata-index");
+const isNotFoundError = (err, code) => err === code || err?.code === code;
+const getTemplateSize = (component) => component.oc.files.template.size;
+const getComponentRowsFromComponentsDetails = (componentsDetails) => {
+    const rows = [];
+    for (const [name, versions] of Object.entries(componentsDetails.components || {})) {
+        for (const [version, details] of Object.entries(versions)) {
+            const row = {
+                name,
+                version,
+                publishDate: details.publishDate
+            };
+            if (details.templateSize !== undefined) {
+                row.templateSize = details.templateSize;
+            }
+            rows.push(row);
+        }
+    }
+    return rows;
+};
+exports.getComponentRowsFromComponentsDetails = getComponentRowsFromComponentsDetails;
+const backfillMetadataRows = async (metadataStore, rows) => {
+    const result = {
+        scanned: rows.length,
+        inserted: 0,
+        skipped: 0
+    };
+    const limit = (0, pLimit_1.default)(10);
+    await Promise.all(rows.map((row) => limit(async () => {
+        try {
+            await metadataStore.addVersion(row);
+            result.inserted += 1;
+        }
+        catch (err) {
+            if (err?.code === oc_metadata_adapters_utils_1.VERSION_ALREADY_EXISTS ||
+                err?.code === oc_metadata_adapters_utils_1.VERSION_PUBLISH_IN_PROGRESS) {
+                result.skipped += 1;
+            }
+            else {
+                throw err;
+            }
+        }
+    })));
+    return result;
+};
+exports.backfillMetadataRows = backfillMetadataRows;
+const backfillMetadataFromComponentsDetails = async (metadataStore, componentsDetails) => (0, exports.backfillMetadataRows)(metadataStore, (0, exports.getComponentRowsFromComponentsDetails)(componentsDetails));
+exports.backfillMetadataFromComponentsDetails = backfillMetadataFromComponentsDetails;
+const getComponentRowsFromStorageDirectories = async (options) => {
+    let components;
+    try {
+        components = await options.cdn.listSubDirectories(options.componentsDir);
+    }
+    catch (err) {
+        if (isNotFoundError(err, 'dir_not_found')) {
+            return [];
+        }
+        throw err;
+    }
+    const maxConcurrentRequests = options.cdn.maxConcurrentRequests || 10;
+    const componentLimit = (0, pLimit_1.default)(maxConcurrentRequests);
+    const packageLimit = (0, pLimit_1.default)(maxConcurrentRequests);
+    const rowsByComponent = await Promise.all(components.map((name) => componentLimit(async () => {
+        const versions = await options.cdn.listSubDirectories(`${options.componentsDir}/${name}`);
+        const rows = await Promise.all(versions.map((version) => packageLimit(async () => {
+            try {
+                const component = await options.cdn.getJson(`${options.componentsDir}/${name}/${version}/package.json`, true);
+                const row = {
+                    name,
+                    version,
+                    publishDate: component.oc.date || 0
+                };
+                const templateSize = getTemplateSize(component);
+                if (templateSize !== undefined) {
+                    row.templateSize = templateSize;
+                }
+                return row;
+            }
+            catch (err) {
+                if (isNotFoundError(err, 'file_not_found')) {
+                    return null;
+                }
+                throw err;
+            }
+        })));
+        return rows.filter((row) => row !== null);
+    })));
+    return rowsByComponent.flat();
+};
+exports.getComponentRowsFromStorageDirectories = getComponentRowsFromStorageDirectories;
+const backfillMetadataFromStorageDirectories = async (options) => (0, exports.backfillMetadataRows)(options.metadataStore, await (0, exports.getComponentRowsFromStorageDirectories)(options));
+exports.backfillMetadataFromStorageDirectories = backfillMetadataFromStorageDirectories;
+exports.reconcileMetadataFromStorage = exports.backfillMetadataFromStorageDirectories;
+const exportLegacyMetadataFiles = async (options) => {
+    const rows = await options.metadataStore.getAllComponents();
+    const componentsListPath = `${options.componentsDir}/components.json`;
+    const componentsDetailsPath = `${options.componentsDir}/components-details.json`;
+    await Promise.all([
+        options.cdn.putFileContent(JSON.stringify((0, metadata_index_1.getComponentsListFromRows)(rows)), componentsListPath, true),
+        options.cdn.putFileContent(JSON.stringify((0, metadata_index_1.getComponentsDetailsFromRows)(rows)), componentsDetailsPath, true)
+    ]);
+    return {
+        exported: rows.length,
+        files: [componentsListPath, componentsDetailsPath]
+    };
+};
+exports.exportLegacyMetadataFiles = exportLegacyMetadataFiles;
+const backfillMetadataFromStorageDetails = async (options) => {
+    try {
+        const componentsDetails = await options.cdn.getJson(`${options.componentsDir}/components-details.json`, true);
+        return (0, exports.backfillMetadataFromComponentsDetails)(options.metadataStore, componentsDetails);
+    }
+    catch (err) {
+        if (isNotFoundError(err, 'file_not_found')) {
+            return (0, exports.backfillMetadataFromStorageDirectories)(options);
+        }
+        throw err;
+    }
+};
+exports.backfillMetadataFromStorageDetails = backfillMetadataFromStorageDetails;

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/repository.d.ts

@@ -28,5 +28,6 @@ export default function repository(conf: Config): {
         dryRun?: boolean;
         user?: string;
     }): Promise<void>;
+    close(): Promise<void>;
 };
 export type Repository = ReturnType<typeof repository>;