oc 0.50.60 → 0.50.62

package/dist/registry/index.js

@@ -38,6 +38,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = registry;
 const colors_1 = __importDefault(require("../utils/colors"));
+const deprecate_1 = __importDefault(require("../utils/deprecate"));
 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"));
@@ -47,6 +48,20 @@ 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");
+const SERVER_ERROR_CODE = 'SERVER_ERROR';
+const warnAboutCallback = () => (0, deprecate_1.default)({
+    id: 'registry-lifecycle-callbacks',
+    subject: 'Registry lifecycle callbacks',
+    replacement: 'the returned promises'
+});
+const toError = (error) => {
+    if (error instanceof Error) {
+        return error;
+    }
+    const errorLike = error;
+    const message = errorLike?.message ?? errorLike?.msg ?? error;
+    return new Error(String(message));
+};
 function registry(inputOptions) {
     const validationResult = validator.validateRegistryConfiguration(inputOptions);
     if (!validationResult.isValid) {
@@ -57,56 +72,120 @@ function registry(inputOptions) {
     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 (adapter.isListening()) {
+    const listenAdapter = (serverOptions) => {
+        if (adapter.supportsPromiseLifecycle) {
+            return adapter.listen(serverOptions);
+        }
+        return new Promise((resolve, reject) => {
+            adapter.listen(serverOptions, (err) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve();
+                }
+            });
+        });
+    };
+    const closeAdapter = () => {
+        if (adapter.supportsPromiseLifecycle) {
+            return adapter.close();
+        }
+        return new Promise((resolve, reject) => {
             adapter.close((err) => {
-                void closeMetadataStore().finally(() => callback(err));
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve();
+                }
             });
-            return;
+        });
+    };
+    const closePromise = () => {
+        const closeMetadataStore = () => Promise.resolve(repository.close?.()).catch(() => undefined);
+        const closeServer = new Promise((resolve, reject) => {
+            if (!adapter.isListening()) {
+                reject('not opened');
+                return;
+            }
+            closeAdapter().then(resolve, reject);
+        });
+        return closeServer.finally(closeMetadataStore);
+    };
+    const close = (callback) => {
+        const promise = closePromise();
+        if (!callback) {
+            return promise;
         }
-        void closeMetadataStore().finally(() => callback('not opened'));
+        warnAboutCallback();
+        const callbackPromise = promise.then(() => callback(), (error) => {
+            callback(error);
+            throw error;
+        });
+        void callbackPromise.catch(() => undefined);
+        return callbackPromise;
     };
     const register = (plugin, callback) => {
+        if (callback) {
+            warnAboutCallback();
+        }
         plugins.push(Object.assign(plugin, { callback }));
+        return Promise.resolve();
     };
-    const start = async (callback) => {
+    const startPromise = async () => {
         const ok = (msg) => console.log(colors_1.default.green(msg));
         try {
             options.plugins = await pluginsInitialiser.init(plugins);
             (0, router_1.create)(adapter, options, repository);
             const componentsInfo = await repository.init();
             await (0, app_start_1.default)(repository, options);
-            adapter.listen({
+            const listenPromise = listenAdapter({
                 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:${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: adapter.httpServer() });
             });
-            adapter.onServerError((error) => {
-                events_handler_1.default.fire('error', {
-                    code: 'EXPRESS_ERROR',
-                    message: error?.message ?? String(error)
+            const serverError = new Promise((_resolve, reject) => {
+                adapter.onServerError((error) => {
+                    events_handler_1.default.fire('error', {
+                        code: SERVER_ERROR_CODE,
+                        message: error?.message ?? String(error)
+                    });
+                    reject(toError(error));
                 });
-                callback(error);
             });
+            void serverError.catch(() => undefined);
+            await Promise.race([listenPromise, serverError]);
+            events_handler_1.default.fire('start', {});
+            if (options.verbosity) {
+                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.`);
+                }
+            }
+            return { app, server: adapter.httpServer() };
         }
         catch (err) {
-            callback(err?.msg || err);
+            throw toError(err);
+        }
+    };
+    const start = (callback) => {
+        const promise = startPromise();
+        if (!callback) {
+            return promise;
         }
+        warnAboutCallback();
+        const callbackPromise = promise.then((result) => {
+            callback(null, result);
+            return result;
+        }, (error) => {
+            callback(error);
+            throw error;
+        });
+        void callbackPromise.catch(() => undefined);
+        return callbackPromise;
     };
     return {
         close,

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

@@ -1,3 +1,7 @@
+import type { CorsConfig, CorsOptions } from '../../types';
 import type { OcHandler } from '../domain/http-server/types';
+export declare const DEFAULT_CORS_CONFIG: CorsConfig;
+export declare const normaliseCorsConfig: (options?: CorsOptions | null) => CorsConfig;
+export declare const validateCorsConfig: (options: unknown) => string | undefined;
 declare const cors: OcHandler;
 export default cors;

package/dist/registry/middleware/cors.js

@@ -1,10 +1,68 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateCorsConfig = exports.normaliseCorsConfig = exports.DEFAULT_CORS_CONFIG = void 0;
+const resources_1 = __importDefault(require("../../resources"));
+exports.DEFAULT_CORS_CONFIG = {
+    origin: '*',
+    credentials: true,
+    allowedHeaders: 'Origin, X-Requested-With, Content-Type, Accept, traceparent',
+    methods: 'GET, OPTIONS, PUT, POST'
+};
+const asHeaderValue = (value, fallback) => (Array.isArray(value) ? value.join(', ') : (value ?? fallback));
+const normaliseCorsConfig = (options) => ({
+    origin: options?.origin ?? exports.DEFAULT_CORS_CONFIG.origin,
+    credentials: options?.credentials ?? exports.DEFAULT_CORS_CONFIG.credentials,
+    allowedHeaders: asHeaderValue(options?.allowedHeaders, exports.DEFAULT_CORS_CONFIG.allowedHeaders),
+    methods: asHeaderValue(options?.methods, exports.DEFAULT_CORS_CONFIG.methods)
+});
+exports.normaliseCorsConfig = normaliseCorsConfig;
+const isStringArray = (value) => Array.isArray(value) && value.every((item) => typeof item === 'string');
+const validateCorsConfig = (options) => {
+    if (typeof options === 'undefined') {
+        return undefined;
+    }
+    if (options === null ||
+        typeof options !== 'object' ||
+        Array.isArray(options)) {
+        return resources_1.default.errors.registry.CONFIGURATION_CORS_MUST_BE_OBJECT;
+    }
+    const config = options;
+    if (typeof config.origin !== 'undefined' &&
+        (typeof config.origin !== 'string' || config.origin.length === 0)) {
+        return resources_1.default.errors.registry.CONFIGURATION_CORS_ORIGIN_MUST_BE_STRING;
+    }
+    if (typeof config.credentials !== 'undefined' &&
+        typeof config.credentials !== 'boolean') {
+        return resources_1.default.errors.registry
+            .CONFIGURATION_CORS_CREDENTIALS_MUST_BE_BOOLEAN;
+    }
+    if (typeof config.allowedHeaders !== 'undefined' &&
+        typeof config.allowedHeaders !== 'string' &&
+        !isStringArray(config.allowedHeaders)) {
+        return resources_1.default.errors.registry
+            .CONFIGURATION_CORS_ALLOWED_HEADERS_MUST_BE_STRING_ARRAY;
+    }
+    if (typeof config.methods !== 'undefined' &&
+        typeof config.methods !== 'string' &&
+        !isStringArray(config.methods)) {
+        return resources_1.default.errors.registry
+            .CONFIGURATION_CORS_METHODS_MUST_BE_STRING_ARRAY;
+    }
+    return undefined;
+};
+exports.validateCorsConfig = validateCorsConfig;
 const cors = (_req, res) => {
+    const options = (0, exports.normaliseCorsConfig)(res.conf?.cors);
     res.removeHeader('X-Powered-By');
-    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');
+    res.removeHeader('Access-Control-Allow-Credentials');
+    if (options.credentials) {
+        res.set('Access-Control-Allow-Credentials', 'true');
+    }
+    res.set('Access-Control-Allow-Origin', options.origin);
+    res.set('Access-Control-Allow-Headers', options.allowedHeaders);
+    res.set('Access-Control-Allow-Methods', options.methods);
 };
 exports.default = cors;

package/dist/registry/router.js

@@ -11,6 +11,7 @@ const component_info_1 = __importDefault(require("./routes/component-info"));
 const component_preview_1 = __importDefault(require("./routes/component-preview"));
 const components_1 = __importDefault(require("./routes/components"));
 const dependencies_1 = __importDefault(require("./routes/dependencies"));
+const get_component_1 = __importDefault(require("./routes/helpers/get-component"));
 const history_1 = __importDefault(require("./routes/history"));
 const plugins_1 = __importDefault(require("./routes/plugins"));
 const publish_1 = __importDefault(require("./routes/publish"));
@@ -18,9 +19,10 @@ const static_redirector_1 = __importDefault(require("./routes/static-redirector"
 const validate_1 = __importDefault(require("./routes/validate"));
 function create(adapter, conf, repository) {
     const route = (method, path, id, ...handlers) => adapter.route(method, path, id, handlers);
+    const renderComponent = (0, get_component_1.default)(conf, repository);
     const routes = {
-        component: (0, component_1.default)(conf, repository),
-        components: (0, components_1.default)(conf, repository),
+        component: (0, component_1.default)(conf, repository, renderComponent),
+        components: (0, components_1.default)(conf, repository, renderComponent),
         componentInfo: (0, component_info_1.default)(conf, repository),
         componentPreview: (0, component_preview_1.default)(conf, repository),
         index: (0, routes_1.default)(repository),

package/dist/registry/routes/component-info.js

@@ -100,9 +100,10 @@ function componentInfo(err, req, res, component, componentDetail) {
         });
     }
     else if (res.conf.discovery.api) {
-        res.status(200).json(Object.assign(component, {
+        res.status(200).json({
+            ...component,
             requestVersion: req.params['componentVersion'] || ''
-        }));
+        });
     }
     else {
         res.status(401);

package/dist/registry/routes/component-preview.js

@@ -71,9 +71,10 @@ function componentPreview(err, req, res, component, templates) {
         }));
     }
     else {
-        res.status(200).json(Object.assign(component, {
+        res.status(200).json({
+            ...component,
             requestVersion: req.params['componentVersion'] || ''
-        }));
+        });
     }
 }
 function componentPreviewRoute(conf, repository) {

package/dist/registry/routes/component.d.ts

@@ -1,4 +1,5 @@
 import type { Config } from '../../types';
 import type { OcHandler } from '../domain/http-server/types';
 import type { Repository } from '../domain/repository';
-export default function component(conf: Config, repository: Repository): OcHandler;
+import { type RenderComponent } from './helpers/get-component';
+export default function component(conf: Config, repository: Repository, getComponent?: RenderComponent): OcHandler;

package/dist/registry/routes/component.js

@@ -42,8 +42,7 @@ const turbo_stream_1 = require("@rdevis/turbo-stream");
 const serialize_error_1 = require("serialize-error");
 const resources_1 = __importDefault(require("../../resources"));
 const get_component_1 = __importStar(require("./helpers/get-component"));
-function component(conf, repository) {
-    const getComponent = (0, get_component_1.default)(conf, repository);
+function component(conf, repository, getComponent = (0, get_component_1.default)(conf, repository)) {
     return (req, res) => {
         let parameters = req.query;
         if (req.method === 'POST') {

package/dist/registry/routes/components.d.ts

@@ -1,4 +1,5 @@
 import type { Config } from '../../types';
 import type { OcHandler } from '../domain/http-server/types';
 import type { Repository } from '../domain/repository';
-export default function components(conf: Config, repository: Repository): OcHandler;
+import { type RenderComponent } from './helpers/get-component';
+export default function components(conf: Config, repository: Repository, getComponent?: RenderComponent): OcHandler;

package/dist/registry/routes/components.js

@@ -7,8 +7,7 @@ exports.default = components;
 const resources_1 = __importDefault(require("../../resources"));
 const pLimit_1 = __importDefault(require("../../utils/pLimit"));
 const get_component_1 = __importDefault(require("./helpers/get-component"));
-function components(conf, repository) {
-    const getComponent = (0, get_component_1.default)(conf, repository);
+function components(conf, repository, getComponent = (0, get_component_1.default)(conf, repository)) {
     const setHeaders = (results, res) => {
         if (results?.length !== 1 || !results[0] || !res.set) {
             return;

package/dist/registry/routes/helpers/get-component.d.ts

@@ -39,5 +39,6 @@ export interface GetComponentResult {
         missingDependencies?: string[];
     };
 }
+export type RenderComponent = (options: RendererOptions, cb: (result: GetComponentResult) => void) => void;
 export declare const stream: unique symbol;
-export default function getComponent(conf: Config, repository: Repository): (options: RendererOptions, cb: (result: GetComponentResult) => void) => Promise<void>;
+export default function getComponent(conf: Config, repository: Repository): RenderComponent;

package/dist/registry/routes/helpers/get-component.js

@@ -42,12 +42,12 @@ const node_crypto_1 = require("node:crypto");
 const node_domain_1 = __importDefault(require("node:domain"));
 const node_vm_1 = __importDefault(require("node:vm"));
 const accept_language_parser_1 = __importDefault(require("accept-language-parser"));
-const nice_cache_1 = __importDefault(require("nice-cache"));
 const oc_client_1 = __importDefault(require("oc-client"));
 const oc_empty_response_handler_1 = __importDefault(require("oc-empty-response-handler"));
 const universalify_1 = require("universalify");
 const resources_1 = __importDefault(require("../../../resources"));
 const settings_1 = __importDefault(require("../../../resources/settings"));
+const bounded_cache_1 = __importDefault(require("../../../utils/bounded-cache"));
 const is_template_legacy_1 = __importDefault(require("../../../utils/is-template-legacy"));
 const events_handler_1 = __importDefault(require("../../domain/events-handler"));
 const nested_renderer_1 = __importDefault(require("../../domain/nested-renderer"));
@@ -61,6 +61,7 @@ const format_error_stack_1 = require("./format-error-stack");
 const getComponentFallback = __importStar(require("./get-component-fallback"));
 const get_component_retrieving_info_1 = __importDefault(require("./get-component-retrieving-info"));
 exports.stream = Symbol('stream');
+const MAX_ARTIFACT_CACHE_ENTRIES = 1000;
 const noop = () => { };
 const noopConsole = Object.fromEntries(Object.keys(console).map((key) => [key, noop]));
 const parseTemplatesHeader = (templates) => {
@@ -118,10 +119,7 @@ function pluginConverter(plugins = {}) {
 }
 function getComponent(conf, repository) {
     const client = (0, oc_client_1.default)({ templates: conf.templates });
-    const cache = new nice_cache_1.default({
-        verbose: !!conf.verbosity,
-        refreshInterval: conf.refreshInterval
-    });
+    const cache = new bounded_cache_1.default(MAX_ARTIFACT_CACHE_ENTRIES);
     const convertPlugins = pluginConverter(conf.plugins);
     const customHeadersByConfig = new WeakMap();
     const pluginNamesByConfig = new WeakMap();
@@ -156,7 +154,7 @@ function getComponent(conf, repository) {
     const getEnv = async (component) => {
         const cacheKey = `${component.name}/${component.version}/.env`;
         const cached = cache.get('file-contents', cacheKey);
-        if (cached)
+        if (cached !== undefined)
             return cached;
         return singleFlight(cacheKey, async () => {
             const env = component.oc.files.env
@@ -437,7 +435,7 @@ function getComponent(conf, repository) {
                             });
                         });
                     };
-                    if (cached && !conf.hotReloading) {
+                    if (cached !== undefined && !conf.hotReloading) {
                         returnResult(cached);
                     }
                     else {
@@ -538,7 +536,7 @@ function getComponent(conf, repository) {
                             }, executionTimeout * 1000);
                         }
                     };
-                    if (cached && !conf.hotReloading) {
+                    if (cached !== undefined && !conf.hotReloading) {
                         domain.on('error', returnComponent);
                         try {
                             domain.run(() => {
@@ -589,6 +587,7 @@ function getComponent(conf, repository) {
                                 exports: {},
                                 console: conf.local ? console : noopConsole,
                                 setTimeout,
+                                clearTimeout,
                                 Buffer,
                                 Error,
                                 AbortController: globalThis?.AbortController,

package/dist/registry/routes/index.js

@@ -16,7 +16,16 @@ const getParsedAuthor = (author) => {
     author = author || {};
     return typeof author === 'string' ? (0, parse_author_1.default)(author) : author;
 };
-const mapComponentDetails = (component) => Object.assign(component, { author: getParsedAuthor(component.author) });
+const mapComponentDetails = (component) => ({
+    ...component,
+    author: getParsedAuthor(component.author),
+    oc: component.oc.date
+        ? {
+            ...component.oc,
+            stringifiedDate: (0, date_stringify_1.default)(new Date(component.oc.date))
+        }
+        : component.oc
+});
 const isHtmlRequest = (headers) => !!headers.accept && headers.accept.indexOf('text/html') >= 0;
 const excludedMeta = ['dependencies', 'devDependencies'];
 function default_1(repository) {
@@ -37,12 +46,7 @@ function default_1(repository) {
         };
         const componentDetails = await Promise.all(componentNames.map((componentName) => repository.getComponent(componentName, undefined)));
         if (isHtmlRequest(req.headers) && res.conf.discovery.ui) {
-            const processedComponents = componentDetails.map((component) => {
-                if (component.oc?.date) {
-                    component.oc.stringifiedDate = (0, date_stringify_1.default)(new Date(component.oc.date));
-                }
-                return mapComponentDetails(component);
-            });
+            const processedComponents = componentDetails.map(mapComponentDetails);
             const totalReleases = componentDetails.reduce((sum, component) => sum + component.allVersions.length, 0);
             const stateCounts = {};
             const componentsList = processedComponents.map((component) => {

package/dist/resources/index.d.ts

@@ -27,6 +27,11 @@ declare const _default: {
             COMPONENT_SET_HEADER_PARAMETERS_NOT_VALID: string;
             COMPONENT_SET_COOKIE_PARAMETERS_NOT_VALID: string;
             CONFIGURATION_DEPENDENCIES_MUST_BE_ARRAY: string;
+            CONFIGURATION_CORS_MUST_BE_OBJECT: string;
+            CONFIGURATION_CORS_ORIGIN_MUST_BE_STRING: string;
+            CONFIGURATION_CORS_CREDENTIALS_MUST_BE_BOOLEAN: string;
+            CONFIGURATION_CORS_ALLOWED_HEADERS_MUST_BE_STRING_ARRAY: string;
+            CONFIGURATION_CORS_METHODS_MUST_BE_STRING_ARRAY: string;
             CONFIGURATION_EMPTY: string;
             CONFIGURATION_METADATA_NOT_VALID: (adapterType: string) => string;
             CONFIGURATION_METADATA_EXPORT_INTERVAL_NOT_VALID: string;
@@ -108,7 +113,6 @@ declare const _default: {
             initSuccess: (componentName: string, componentPath: string) => string;
             installCompiler: (compiler: string) => string;
             installCompilerSuccess: (template: string, compiler: string, version: string) => string;
-            legacyTemplateDeprecationWarning: (legacyType: string, newType: string) => string;
             CHANGES_DETECTED: (file: string) => string;
             CHECKING_DEPENDENCIES: string;
             COMPRESSING: (path: string) => string;

package/dist/resources/index.js

@@ -76,6 +76,11 @@ exports.default = {
             COMPONENT_SET_HEADER_PARAMETERS_NOT_VALID: 'context.setHeader parameters must be strings',
             COMPONENT_SET_COOKIE_PARAMETERS_NOT_VALID: 'context.setCookie parameters are not valid',
             CONFIGURATION_DEPENDENCIES_MUST_BE_ARRAY: 'Registry configuration is not valid: dependencies must be an array',
+            CONFIGURATION_CORS_MUST_BE_OBJECT: 'Registry configuration is not valid: cors must be an object',
+            CONFIGURATION_CORS_ORIGIN_MUST_BE_STRING: 'Registry configuration is not valid: cors.origin must be a non-empty string',
+            CONFIGURATION_CORS_CREDENTIALS_MUST_BE_BOOLEAN: 'Registry configuration is not valid: cors.credentials must be a boolean',
+            CONFIGURATION_CORS_ALLOWED_HEADERS_MUST_BE_STRING_ARRAY: 'Registry configuration is not valid: cors.allowedHeaders must be a string or an array of strings',
+            CONFIGURATION_CORS_METHODS_MUST_BE_STRING_ARRAY: 'Registry configuration is not valid: cors.methods must be a string or an array of strings',
             CONFIGURATION_EMPTY: 'Registry configuration is empty',
             CONFIGURATION_METADATA_NOT_VALID: (adapterType) => `Registry configuration is not valid: ${adapterType} is not a valid metadata adapter`,
             CONFIGURATION_METADATA_EXPORT_INTERVAL_NOT_VALID: 'Registry configuration is not valid: metadata.exportLegacyFilesInterval must be a positive number',
@@ -157,7 +162,6 @@ exports.default = {
             initSuccess,
             installCompiler: (compiler) => `Installing ${compiler} from npm...`,
             installCompilerSuccess: (template, compiler, version) => `${(0, colors_1.green)('✔')} Installed ${compiler} [${template} v${version}]`,
-            legacyTemplateDeprecationWarning: (legacyType, newType) => `Template-type "${legacyType}" has been deprecated and is now replaced by "${newType}"`,
             CHANGES_DETECTED: (file) => `Changes detected on file: ${file}`,
             CHECKING_DEPENDENCIES: 'Ensuring dependencies are loaded...',
             COMPRESSING: (path) => `Compressing -> ${path}`,

package/dist/types.d.ts

@@ -5,6 +5,27 @@ import type { PackageJson } from 'type-fest';
 import type { HttpServerAdapterFactory, HttpServerAdapterOptions } from './registry/domain/http-server/types';
 export type { ComponentRow, MetadataStore } from 'oc-metadata-adapters-utils';
 type Middleware = (req: Request, res: Response, next: NextFunction) => void;
+export interface RegistryErrorEvent {
+    /**
+     * Stable registry error category. Server adapter failures use
+     * `SERVER_ERROR`, regardless of the configured adapter.
+     */
+    code: string;
+    /** The original error message reported by the failing registry operation. */
+    message: string;
+}
+export interface CorsConfig {
+    origin: string;
+    credentials: boolean;
+    allowedHeaders: string;
+    methods: string;
+}
+export interface CorsOptions {
+    origin?: string;
+    credentials?: boolean;
+    allowedHeaders?: string | string[];
+    methods?: string | string[];
+}
 export interface Author {
     email?: string;
     name?: string;
@@ -192,6 +213,12 @@ export interface Config<T = any, TServerAdapter extends HttpServerAdapterFactory
      * @example "https://components.mycompany.com/"
      */
     baseUrl: string;
+    /**
+     * CORS response headers sent by the registry.
+     *
+     * @default Existing registry CORS headers
+     */
+    cors?: CorsConfig;
     /**
      * Pre-compiled version of the `oc-client` library generated automatically
      * at runtime when `compileClient` is enabled (default).
@@ -296,11 +323,12 @@ export interface Config<T = any, TServerAdapter extends HttpServerAdapterFactory
         secure: boolean;
     }) => boolean;
     /**
-     * Environment variables passed to components in `context.env`.
+     * Environment values passed to components in `context.env` and the data
+     * provider's `process.env` shim.
      *
      * @default {}
      */
-    env: Record<string, string>;
+    env: Record<string, any>;
     /**
      * Maximum execution time of a component’s server-side logic, expressed in
      * seconds. When the timeout elapses the registry returns a 500 error.
@@ -485,12 +513,13 @@ export interface Template {
     getInfo: () => TemplateInfo;
     render: (options: any, cb: (err: Error | null, data: string) => void) => void;
 }
+export type PluginRegistration<T = any> = (options: T, dependencies: any, next: (error?: Error) => void) => void | Promise<void>;
 interface BasePLugin<T = any> {
     description?: string;
     name: string;
     options?: T;
     register: {
-        register: (options: T, dependencies: any, next: (error?: Error) => void) => void;
+        register: PluginRegistration<T>;
         dependencies?: string[];
     };
 }
@@ -514,7 +543,7 @@ export type Plugin<T = any> = BasePLugin<T> & ({
      */
     context?: false | undefined;
     register: {
-        register: (options: T, dependencies: any, next: (error?: Error) => void) => void;
+        register: PluginRegistration<T>;
         execute: (...args: any[]) => any;
         dependencies?: string[];
     };
@@ -533,7 +562,7 @@ export type Plugin<T = any> = BasePLugin<T> & ({
      */
     context: true;
     register: {
-        register: (options: T, dependencies: any, next: (error?: Error) => void) => void;
+        register: PluginRegistration<T>;
         execute: (context: PluginContext) => (params: any) => any;
         dependencies?: string[];
     };

package/dist/utils/bounded-cache.d.ts

@@ -0,0 +1,10 @@
+export default class BoundedCache {
+    private readonly cache;
+    constructor(maxEntries: number);
+    get<T>(namespace: string, key: string): T | undefined;
+    set<T>(namespace: string, key: string, value: T): void;
+    delete(namespace: string, key: string): boolean;
+    clear(): void;
+    get size(): number;
+    private toKey;
+}

package/dist/utils/bounded-cache.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const lru_cache_1 = require("lru-cache");
+class BoundedCache {
+    cache;
+    constructor(maxEntries) {
+        if (!Number.isInteger(maxEntries) || maxEntries <= 0) {
+            throw new Error('Cache capacity must be a positive integer');
+        }
+        this.cache = new lru_cache_1.LRUCache({ max: maxEntries });
+    }
+    get(namespace, key) {
+        return this.cache.get(this.toKey(namespace, key));
+    }
+    set(namespace, key, value) {
+        this.cache.set(this.toKey(namespace, key), value);
+    }
+    delete(namespace, key) {
+        return this.cache.delete(this.toKey(namespace, key));
+    }
+    clear() {
+        this.cache.clear();
+    }
+    get size() {
+        return this.cache.size;
+    }
+    toKey(namespace, key) {
+        return JSON.stringify([namespace, key]);
+    }
+}
+exports.default = BoundedCache;