oc 0.50.57 → 0.50.59

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 ## Change Log
 
+## 0.50.59
+
+### Patch Changes
+
+- adae2e2: remove final slash on oc.build
+- Updated dependencies [adae2e2]
+  - oc-client-browser@2.1.12
+
+## 0.50.58
+
+### Patch Changes
+
+- 7a8173d: update oc-client-browser
+
+## 0.50.57
+
+### Patch Changes
+
+- e3dce96: export types for http adapters
+
 ## 0.50.56
 
 ### Patch Changes

package/dist/cli/facade/dev.d.ts

@@ -17,76 +17,7 @@ declare const dev: ({ local, logger }: {
         watch?: boolean;
         verbose?: boolean;
         production?: boolean;
-    }): Promise<{
-        close: (callback: (err?: Error | undefined | string) => void) => void;
-        on: <T extends keyof {
-            error: {
-                code: string;
-                message: string;
-            };
-            start: unknown;
-            'cache-poll': number;
-            request: import("../../registry/domain/events-handler").RequestData;
-            'component-retrieved': {
-                headers: import("node:http").IncomingHttpHeaders;
-                name: string;
-                parameters: import("node: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, listener: (data: {
-            error: {
-                code: string;
-                message: string;
-            };
-            start: unknown;
-            'cache-poll': number;
-            request: import("../../registry/domain/events-handler").RequestData;
-            'component-retrieved': {
-                headers: import("node:http").IncomingHttpHeaders;
-                name: string;
-                parameters: import("node: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]) => void) => void;
-        register: <T = any>(plugin: oc.Plugin<T>, callback?: ((...args: any[]) => void) | undefined) => void;
-        start: (callback: (err: unknown, data?: {
-            app: import("express").Express;
-            server: import("node:http").Server;
-        } | undefined) => void) => Promise<void>;
-        app: import("express").Express;
-    }>;
+    }): Promise<oc.RegistryType<unknown>>;
     (opts: {
         prefix: string;
         dirPath: string;
@@ -99,75 +30,6 @@ declare const dev: ({ local, logger }: {
         watch?: boolean;
         verbose?: boolean;
         production?: boolean;
-    }, arguments__1: (error: unknown, value: {
-        close: (callback: (err?: Error | undefined | string) => void) => void;
-        on: <T extends keyof {
-            error: {
-                code: string;
-                message: string;
-            };
-            start: unknown;
-            'cache-poll': number;
-            request: import("../../registry/domain/events-handler").RequestData;
-            'component-retrieved': {
-                headers: import("node:http").IncomingHttpHeaders;
-                name: string;
-                parameters: import("node: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, listener: (data: {
-            error: {
-                code: string;
-                message: string;
-            };
-            start: unknown;
-            'cache-poll': number;
-            request: import("../../registry/domain/events-handler").RequestData;
-            'component-retrieved': {
-                headers: import("node:http").IncomingHttpHeaders;
-                name: string;
-                parameters: import("node: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]) => void) => void;
-        register: <T = any>(plugin: oc.Plugin<T>, callback?: ((...args: any[]) => void) | undefined) => void;
-        start: (callback: (err: unknown, data?: {
-            app: import("express").Express;
-            server: import("node:http").Server;
-        } | undefined) => void) => Promise<void>;
-        app: import("express").Express;
-    }) => void): void;
+    }, arguments__1: (error: unknown, value: oc.RegistryType<unknown>) => void): void;
 };
 export default dev;

package/dist/components/oc-client/_package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "oc-client",
   "description": "The OpenComponents client-side javascript client",
-  "version": "0.50.57",
+  "version": "0.50.59",
   "repository": "https://github.com/opencomponents/oc/tree/master/components/oc-client",
   "author": "Matteo Figus <matteofigus@gmail.com>",
   "oc": {
@@ -23,14 +23,14 @@
       ],
       "dataProvider": {
         "type": "node.js",
-        "hashKey": "929f4f5eeb101df5642669d7297d70c8ebfcf118",
+        "hashKey": "5ab7cad2df725598783ffb4c946d9db3fd1e65d4",
         "src": "server.js",
         "size": 644
       }
     },
-    "version": "0.50.57",
+    "version": "0.50.59",
     "packaged": true,
-    "date": 1784010521376
+    "date": 1784820712757
   },
   "devDependencies": {
     "oc-template-es6-compiler": "^8.0.0"

package/dist/components/oc-client/_package/server.js

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const o=(t,s)=>{const{staticPath:e,templates:a}=t;return s(null,{staticPath:e,templates:a})},r=(t,s)=>{o(t,(e,a,i={})=>{if(e)return s(e);if(a==null)return s(null,{__oc_emptyResponse:!0});const n=t.action?a:Object.assign({},a,{_staticPath:t.staticPath,_baseUrl:t.baseUrl,_componentName:"oc-client",_componentVersion:"0.50.57"}),c=t.staticPath.indexOf("http")===0?t.staticPath:"https:"+t.staticPath;return s(null,Object.assign({},{component:{key:"c4abb6bf4dc6657fb718a45b64bd6b2cb92e874a",src:c+"template.js",props:n,esm:!1,development:void 0}}))})};exports.data=r;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const o=(t,s)=>{const{staticPath:e,templates:a}=t;return s(null,{staticPath:e,templates:a})},r=(t,s)=>{o(t,(e,a,i={})=>{if(e)return s(e);if(a==null)return s(null,{__oc_emptyResponse:!0});const n=t.action?a:Object.assign({},a,{_staticPath:t.staticPath,_baseUrl:t.baseUrl,_componentName:"oc-client",_componentVersion:"0.50.59"}),c=t.staticPath.indexOf("http")===0?t.staticPath:"https:"+t.staticPath;return s(null,Object.assign({},{component:{key:"c4abb6bf4dc6657fb718a45b64bd6b2cb92e874a",src:c+"template.js",props:n,esm:!1,development:void 0}}))})};exports.data=r;

package/dist/components/oc-client/package.json

@@ -1,7 +1,7 @@
 {
   "name": "oc-client",
   "description": "The OpenComponents client-side javascript client",
-  "version": "0.50.57",
+  "version": "0.50.59",
   "repository": "https://github.com/opencomponents/oc/tree/master/components/oc-client",
   "author": "Matteo Figus <matteofigus@gmail.com>",
   "oc": {

package/dist/index.d.ts

@@ -1,4 +1,6 @@
 export { default as Client } from 'oc-client';
 export { default as cli } from './cli/programmatic-api';
+export type { RegistryType } from './registry';
 export { default as Registry, RegistryOptions } from './registry';
+export type { CookieOptions, ExpressMiddleware, HttpServerAdapter, HttpServerAdapterFactory, Method, NativeApp, OcHandler, OcRequest, OcResponse, UploadedFile } from './registry/domain/http-server/types';
 export type { Plugin, PluginContext } from './types';

package/dist/registry/domain/events-handler.d.ts

@@ -47,6 +47,7 @@ type Events = {
 };
 type EventsHandler = {
     fire<T extends keyof Events>(eventName: T, data: Events[T]): void;
+    hasListeners<T extends keyof Events>(eventName: T): boolean;
     on<T extends keyof Events>(eventName: T, listener: Subscription<Events[T]>): void;
     off<T extends keyof Events>(eventName: T, listener: Subscription<Events[T]>): void;
     reset(): void;

package/dist/registry/domain/events-handler.js

@@ -13,6 +13,9 @@ const eventsHandler = {
             }
         }
     },
+    hasListeners(eventName) {
+        return Boolean(subscriptions[eventName]?.length);
+    },
     on(eventName, callback) {
         if (typeof callback !== 'function') {
             throw resources_1.default.errors.registry.CONFIGURATION_ONREQUEST_MUST_BE_FUNCTION;

package/dist/registry/domain/extract-package.d.ts

@@ -1,6 +1,7 @@
 import type { Component } from '../../types';
-export default function extractPackage(files: Express.Multer.File[] | {
-    [fieldname: string]: Express.Multer.File[];
+import type { UploadedFile } from './http-server/types';
+export default function extractPackage(files: UploadedFile[] | {
+    [fieldname: string]: UploadedFile[];
 }, tarExtractMode: number): Promise<{
     outputFolder: string;
     packageJson: Component;

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

@@ -0,0 +1,3 @@
+import { type Express } from 'express';
+import type { HttpServerAdapter } from './types';
+export default function createExpressAdapter(options?: unknown): HttpServerAdapter<Express>;

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

@@ -0,0 +1,202 @@
+"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))
+            })
+        });
+        const parseUpload = upload.any();
+        this.app.use((req, res, next) => {
+            if (req.method !== 'PUT') {
+                return next();
+            }
+            parseUpload(req, res, next);
+        });
+    }
+    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,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/nested-renderer.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = nestedRenderer;
 const resources_1 = __importDefault(require("../../resources"));
 const settings_1 = __importDefault(require("../../resources/settings"));
+const pLimit_1 = __importDefault(require("../../utils/pLimit"));
 function nestedRenderer(rendererWithCallback, conf) {
     const renderer = (options) => new Promise((res, rej) => {
         rendererWithCallback(options, (result) => {
@@ -38,22 +39,21 @@ function nestedRenderer(rendererWithCallback, conf) {
             if (!components?.length) {
                 throw new Error(resources_1.default.errors.registry.NESTED_RENDERER_COMPONENTS_IS_NOT_VALID);
             }
-            return Promise.all(components.map((component) => {
-                return renderer({
-                    conf: conf,
-                    headers: {
-                        ...options.headers,
-                        accept: settings_1.default.registry.acceptRenderedHeader
-                    },
-                    ip: component.ip || '',
-                    name: component.name,
-                    parameters: {
-                        ...options.parameters,
-                        ...component.parameters
-                    },
-                    version: component.version || ''
-                }).catch((err) => new Error(err));
-            }));
+            const limit = (0, pLimit_1.default)(10);
+            return Promise.all(components.map((component) => limit(() => renderer({
+                conf: conf,
+                headers: {
+                    ...options.headers,
+                    accept: settings_1.default.registry.acceptRenderedHeader
+                },
+                ip: component.ip || '',
+                name: component.name,
+                parameters: {
+                    ...options.parameters,
+                    ...component.parameters
+                },
+                version: component.version || ''
+            }).catch((err) => new Error(err)))));
         }
     };
 }

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'),