oc 0.50.55 → 0.50.56

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/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>;

package/dist/registry/domain/repository.js

@@ -41,11 +41,16 @@ const node_path_1 = __importDefault(require("node:path"));
 const dotenv_1 = __importDefault(require("dotenv"));
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const oc_get_unix_utc_timestamp_1 = __importDefault(require("oc-get-unix-utc-timestamp"));
+const oc_metadata_adapters_utils_1 = require("oc-metadata-adapters-utils");
 const resources_1 = __importDefault(require("../../resources"));
 const settings_1 = __importDefault(require("../../resources/settings"));
 const error_to_string_1 = __importDefault(require("../../utils/error-to-string"));
 const components_cache_1 = __importDefault(require("./components-cache"));
 const components_details_1 = __importDefault(require("./components-details"));
+const events_handler_1 = __importDefault(require("./events-handler"));
+const metadata_adapter_options_1 = __importDefault(require("./metadata-adapter-options"));
+const metadata_index_1 = require("./metadata-index");
+const metadata_migration_1 = require("./metadata-migration");
 const register_templates_1 = __importDefault(require("./register-templates"));
 const storage_adapter_1 = __importDefault(require("./storage-adapter"));
 const validator = __importStar(require("./validators"));
@@ -58,10 +63,56 @@ function repository(conf) {
     const repositorySource = conf.local
         ? 'local repository'
         : cdn.adapterType + ' cdn';
-    const componentsCache = (0, components_cache_1.default)(conf, cdn);
-    const componentsDetails = (0, components_details_1.default)(conf, cdn);
+    const metadataStore = !conf.local && conf.metadata
+        ? conf.metadata.adapter((0, metadata_adapter_options_1.default)(conf))
+        : undefined;
+    const metadataIndex = metadataStore
+        ? (0, metadata_index_1.createMetadataIndex)(metadataStore)
+        : undefined;
+    const componentsCache = (0, components_cache_1.default)(conf, cdn, metadataIndex);
+    const componentsDetails = (0, components_details_1.default)(conf, cdn, metadataIndex);
+    let exportLegacyFilesLoop;
+    let closed = false;
     const getFilePath = (component, version, filePath) => `${options.componentsDir}/${component}/${version}/${filePath}`;
+    const exportLegacyFiles = () => {
+        if (!metadataStore || !conf.metadata?.exportLegacyFiles) {
+            return;
+        }
+        return (0, metadata_migration_1.exportLegacyMetadataFiles)({
+            metadataStore,
+            cdn,
+            componentsDir: options.componentsDir
+        }).catch((err) => events_handler_1.default.fire('error', {
+            code: 'metadata_legacy_files_export',
+            message: err?.message || String(err)
+        }));
+    };
+    // Run the DB→components.json export on a non-overlapping background timer
+    // instead of on the publish path, so a publish stays an O(1) append rather
+    // than triggering a full-registry scan + blob rewrite. The timer only runs
+    // when an interval is explicitly configured.
+    const scheduleLegacyFilesExport = () => {
+        const intervalSeconds = conf.metadata?.exportLegacyFilesInterval;
+        if (closed ||
+            !metadataStore ||
+            !conf.metadata?.exportLegacyFiles ||
+            !intervalSeconds) {
+            return;
+        }
+        exportLegacyFilesLoop = setTimeout(async () => {
+            await exportLegacyFiles();
+            if (!closed) {
+                scheduleLegacyFilesExport();
+            }
+        }, intervalSeconds * 1000);
+    };
     const { templatesHash, templatesInfo } = (0, register_templates_1.default)(conf.templates, conf.local);
+    const throwVersionAlreadyFound = (componentName, componentVersion) => {
+        throw {
+            code: resources_1.default.errors.registry.COMPONENT_VERSION_ALREADY_FOUND_CODE,
+            msg: resources_1.default.errors.registry.COMPONENT_VERSION_ALREADY_FOUND(componentName, componentVersion, repositorySource)
+        };
+    };
     const local = {
         components: undefined,
         getCompiledView(componentName) {
@@ -222,8 +273,21 @@ function repository(conf) {
                 // when in local this won't get called
                 return;
             }
+            if (metadataStore) {
+                await metadataStore.initialise();
+                if (conf.metadata?.reconcileFromStorage) {
+                    await (0, metadata_migration_1.reconcileMetadataFromStorage)({
+                        metadataStore,
+                        cdn,
+                        componentsDir: options.componentsDir
+                    });
+                }
+            }
             const componentsList = await componentsCache.load();
-            return componentsDetails.refresh(componentsList);
+            const details = await componentsDetails.refresh(componentsList);
+            void exportLegacyFiles();
+            scheduleLegacyFilesExport();
+            return details;
         },
         async publishComponent({ componentName, componentVersion, pkgDetails, user, dryRun = false }) {
             if (conf.local) {
@@ -257,21 +321,56 @@ function repository(conf) {
             }
             const componentVersions = await repository.getComponentVersions(componentName);
             if (!versionHandler.validateNewVersion(componentVersion, componentVersions)) {
-                throw {
-                    code: resources_1.default.errors.registry.COMPONENT_VERSION_ALREADY_FOUND_CODE,
-                    msg: resources_1.default.errors.registry.COMPONENT_VERSION_ALREADY_FOUND(componentName, componentVersion, repositorySource)
-                };
+                throwVersionAlreadyFound(componentName, componentVersion);
             }
             pkgDetails.packageJson.oc.date = (0, oc_get_unix_utc_timestamp_1.default)();
             pkgDetails.packageJson.oc.publisher = user;
             if (dryRun)
                 return;
             await fs_extra_1.default.writeJson(node_path_1.default.join(pkgDetails.outputFolder, 'package.json'), pkgDetails.packageJson);
+            if (metadataStore) {
+                const componentRow = (0, metadata_index_1.getComponentRow)(componentName, componentVersion, pkgDetails.packageJson);
+                const { token } = await metadataStore
+                    .reserveVersion(componentRow)
+                    .catch((err) => {
+                    if (err?.code === oc_metadata_adapters_utils_1.VERSION_ALREADY_EXISTS ||
+                        err?.code === oc_metadata_adapters_utils_1.VERSION_PUBLISH_IN_PROGRESS ||
+                        err?.code ===
+                            resources_1.default.errors.registry.COMPONENT_VERSION_ALREADY_FOUND_CODE) {
+                        throwVersionAlreadyFound(componentName, componentVersion);
+                    }
+                    throw err;
+                });
+                try {
+                    await cdn.putDir(pkgDetails.outputFolder, `${options.componentsDir}/${componentName}/${componentVersion}`);
+                    await metadataStore.commitVersion(componentName, componentVersion, token);
+                    metadataIndex.add(componentRow);
+                }
+                catch (err) {
+                    await metadataStore
+                        .abortVersion(componentName, componentVersion, token)
+                        .catch(() => undefined);
+                    throw err;
+                }
+                return;
+            }
             await cdn.putDir(pkgDetails.outputFolder, `${options.componentsDir}/${componentName}/${componentVersion}`);
             void componentsCache
                 .refresh()
                 .then((componentsList) => componentsDetails.refresh(componentsList))
                 .catch(() => undefined);
+        },
+        async close() {
+            closed = true;
+            componentsCache.close?.();
+            componentsDetails.close?.();
+            if (exportLegacyFilesLoop) {
+                clearTimeout(exportLegacyFilesLoop);
+                exportLegacyFilesLoop = undefined;
+            }
+            if (metadataStore?.close) {
+                await metadataStore.close();
+            }
         }
     };
     return repository;

package/dist/registry/domain/validators/registry-configuration.js

@@ -39,6 +39,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = registryConfiguration;
 const resources_1 = __importDefault(require("../../../resources"));
 const auth = __importStar(require("../authentication"));
+const metadata_adapter_options_1 = __importDefault(require("../metadata-adapter-options"));
 function registryConfiguration(conf) {
     const returnError = (message) => {
         return {
@@ -111,6 +112,26 @@ function registryConfiguration(conf) {
             }
         }
     }
+    if (!conf.local && conf.metadata) {
+        if (!conf.metadata.adapter) {
+            return returnError(resources_1.default.errors.registry.CONFIGURATION_METADATA_NOT_VALID('metadata'));
+        }
+        if (typeof conf.metadata.exportLegacyFilesInterval !== 'undefined') {
+            if (!Number.isFinite(conf.metadata.exportLegacyFilesInterval) ||
+                conf.metadata.exportLegacyFilesInterval <= 0) {
+                return returnError(resources_1.default.errors.registry
+                    .CONFIGURATION_METADATA_EXPORT_INTERVAL_NOT_VALID);
+            }
+            if (conf.metadata.exportLegacyFiles !== true) {
+                return returnError(resources_1.default.errors.registry
+                    .CONFIGURATION_METADATA_EXPORT_INTERVAL_WITHOUT_EXPORT_NOT_VALID);
+            }
+        }
+        const metadataStore = conf.metadata.adapter((0, metadata_adapter_options_1.default)(conf));
+        if (!metadataStore.isValid()) {
+            return returnError(resources_1.default.errors.registry.CONFIGURATION_METADATA_NOT_VALID(metadataStore.adapterType));
+        }
+    }
     if (conf.customHeadersToSkipOnWeakVersion) {
         if (!Array.isArray(conf.customHeadersToSkipOnWeakVersion)) {
             return returnError(resources_1.default.errors.registry

package/dist/registry/index.d.ts

@@ -4,7 +4,7 @@ import type { Plugin } from '../types';
 import { RegistryOptions } from './domain/options-sanitiser';
 export { RegistryOptions };
 export default function registry<T = any>(inputOptions: RegistryOptions<T>): {
-    close: (callback: (err?: Error | undefined | string) => void) => void | http.Server<typeof http.IncomingMessage, typeof http.ServerResponse>;
+    close: (callback: (err?: Error | undefined | string) => void) => void;
     on: <T_1 extends keyof {
         error: {
             code: string;

package/dist/registry/index.js

@@ -59,10 +59,14 @@ function registry(inputOptions) {
     let server;
     const repository = (0, repository_1.default)(options);
     const close = (callback) => {
+        const closeMetadataStore = () => Promise.resolve(repository.close?.()).catch(() => undefined);
         if (server?.listening) {
-            return server.close(callback);
+            server.close((err) => {
+                void closeMetadataStore().finally(() => callback(err));
+            });
+            return;
         }
-        return callback('not opened');
+        void closeMetadataStore().finally(() => callback('not opened'));
     };
     const register = (plugin, callback) => {
         plugins.push(Object.assign(plugin, { callback }));

package/dist/resources/index.d.ts

@@ -28,6 +28,9 @@ declare const _default: {
             COMPONENT_SET_COOKIE_PARAMETERS_NOT_VALID: string;
             CONFIGURATION_DEPENDENCIES_MUST_BE_ARRAY: string;
             CONFIGURATION_EMPTY: string;
+            CONFIGURATION_METADATA_NOT_VALID: (adapterType: string) => string;
+            CONFIGURATION_METADATA_EXPORT_INTERVAL_NOT_VALID: string;
+            CONFIGURATION_METADATA_EXPORT_INTERVAL_WITHOUT_EXPORT_NOT_VALID: string;
             CONFIGURATION_ONREQUEST_MUST_BE_FUNCTION: string;
             CONFIGURATION_OFFREQUEST_MUST_BE_FUNCTION: string;
             CONFIGURATION_PUBLISH_BASIC_AUTH_CREDENTIALS_MISSING: string;

package/dist/resources/index.js

@@ -77,6 +77,9 @@ exports.default = {
             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_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',
+            CONFIGURATION_METADATA_EXPORT_INTERVAL_WITHOUT_EXPORT_NOT_VALID: 'Registry configuration is not valid: metadata.exportLegacyFilesInterval requires metadata.exportLegacyFiles to be true',
             CONFIGURATION_ONREQUEST_MUST_BE_FUNCTION: "Registry configuration is not valid: registry.on's callback must be a function",
             CONFIGURATION_OFFREQUEST_MUST_BE_FUNCTION: "Registry configuration is not valid: registry.off's callback must be a function",
             CONFIGURATION_PUBLISH_BASIC_AUTH_CREDENTIALS_MISSING: 'Registry configuration is not valid: basic auth requires username and password',

package/dist/types.d.ts

@@ -1,6 +1,8 @@
 import type { NextFunction, Request, Response } from 'express';
+import type { MetadataStore as MetadataStoreType } from 'oc-metadata-adapters-utils';
 import type { StorageAdapter } from 'oc-storage-adapters-utils';
 import type { PackageJson } from 'type-fest';
+export type { ComponentRow, MetadataStore } from 'oc-metadata-adapters-utils';
 type Middleware = (req: Request, res: Response, next: NextFunction) => void;
 export interface Author {
     email?: string;
@@ -38,6 +40,44 @@ export interface ComponentsList {
     components: Record<string, string[]>;
     lastEdit: number;
 }
+export interface MetadataConfig<T = any> {
+    /**
+     * Factory for the metadata store. It must be side-effect free because config
+     * validation may instantiate a throwaway store before registry startup.
+     */
+    adapter: (options: T) => MetadataStoreType;
+    options: T;
+    /**
+     * Controls whether OC asks the metadata adapter to manage its schema/table.
+     * When omitted, OC behaves as `true` and passes that default to adapter
+     * validation/startup/migration paths.
+     *
+     * @default true
+     */
+    manageSchema?: boolean;
+    /**
+     * When true, startup scans storage and inserts any missing metadata rows
+     * before cache hydration. Existing rows are skipped.
+     *
+     * @default false
+     */
+    reconcileFromStorage?: boolean;
+    /**
+     * When true, startup exports DB-derived `components.json` and
+     * `components-details.json` projections to storage. This is a one-way export
+     * from metadata to storage and is not triggered on each publish.
+     *
+     * @default false
+     */
+    exportLegacyFiles?: boolean;
+    /**
+     * Interval, in seconds, at which the DB→`components.json` legacy export runs
+     * in the background. Only used when `exportLegacyFiles` is true. When omitted,
+     * the export runs once at startup only (no background refresh). The export is
+     * never coupled to the publish path.
+     */
+    exportLegacyFilesInterval?: number;
+}
 export interface OcParameter {
     default?: string | boolean | number;
     description?: string;
@@ -334,6 +374,7 @@ export interface Config<T = any> {
      * @default "/"
      */
     prefix: string;
+    metadata?: MetadataConfig;
     /**
      * Authentication strategy for component publishing.
      */
@@ -491,4 +532,3 @@ declare global {
         }
     }
 }
-export {};

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "oc",
-	"version": "0.50.55",
+	"version": "0.50.56",
 	"description": "A framework for developing and distributing html components",
 	"main": "./dist/index.js",
 	"types": "./dist/index.d.ts",
@@ -98,7 +98,8 @@
 		"oc-client-browser": "*",
 		"oc-empty-response-handler": "^1.0.2",
 		"oc-get-unix-utc-timestamp": "^1.0.6",
-		"oc-s3-storage-adapter": "^2.2.2",
+		"oc-metadata-adapters-utils": "^0.1.1",
+		"oc-s3-storage-adapter": "^2.2.3",
 		"oc-storage-adapters-utils": "^2.1.2",
 		"oc-template-es6": "^2.0.0",
 		"oc-template-es6-compiler": "^7.1.4",