oc 0.50.55 → 0.50.56

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 ## Change Log
 
+## 0.50.56
+
+### Patch Changes
+
+- Add storage metadata adapter
+- Updated dependencies
+  - oc-metadata-adapters-utils@0.1.1
+
 ## 0.50.55
 
 ### Patch Changes

package/README.md

@@ -32,6 +32,186 @@ We have been using it for more than two years in production at OpenTable, for sh
 - [Troubleshooting](../../CONTRIBUTING.md#troubleshooting)
 - [Gitter chat](https://gitter.im/opentable/oc)
 
+## Registry metadata stores
+
+By default, an OC registry keeps its component index in storage files:
+`components.json` and `components-details.json`. A registry can instead read and
+write that index through a metadata adapter by adding a `metadata` block to the
+registry configuration.
+
+Storage is still required in metadata mode. The metadata store contains only the
+component name, version, publish date, and template size. Component static files
+and version `package.json` files continue to live in the configured storage
+adapter.
+
+```js
+const azureSqlMetadataAdapter = require('oc-azure-sql-metadata-adapter').default;
+const s3StorageAdapter = require('oc-s3-storage-adapter');
+
+registry.configure({
+  storage: {
+    adapter: s3StorageAdapter,
+    options: {
+      bucket: process.env.OC_STORAGE_BUCKET,
+      region: process.env.OC_STORAGE_REGION,
+      componentsDir: 'components',
+      path: process.env.OC_STORAGE_BASE_URL
+    }
+  },
+  metadata: {
+    adapter: azureSqlMetadataAdapter,
+    options: {
+      connectionString: process.env.OC_METADATA_SQL_CONNECTION_STRING
+    },
+    manageSchema: true,
+    reconcileFromStorage: false,
+    exportLegacyFiles: false
+  }
+});
+```
+
+`metadata.manageSchema` defaults to `true`. Set it to `false` when operators
+manage the metadata schema/table separately; OC passes the value through to the
+configured metadata adapter during validation, startup, and migration.
+
+The registry initialises the metadata store during startup. If startup succeeds,
+reads are served from OC's in-memory cache, and cache polling refreshes from the
+metadata store. Publishing reserves the metadata row first, uploads package files
+to storage only after the reservation succeeds, then commits the row. Duplicate
+or in-progress metadata rows are treated as the existing "component version
+already exists" publish error. When the registry is shut down via
+`registry.close(callback)`, the metadata adapter's optional `close()` hook is
+invoked so the adapter can release its connection pool.
+
+Custom metadata adapters should implement the shared contract exported by
+`oc-metadata-adapters-utils`:
+
+```ts
+import type { ComponentRow, MetadataStore } from 'oc-metadata-adapters-utils';
+import {
+  VERSION_ALREADY_EXISTS,
+  VERSION_PUBLISH_IN_PROGRESS
+} from 'oc-metadata-adapters-utils';
+```
+
+### Migrating existing registries
+
+Use the CLI backfill command before enabling metadata mode in production:
+
+```sh
+oc registry migrate-metadata ./registry.config.js
+```
+
+The argument is a path to a module that exports the same registry config object you would pass to `registry.configure()`. It must include both `storage` and `metadata`, and it must pass registry config validation. The module can be CommonJS, an ES module `default` export, or an async function returning the config — all three are accepted:
+
+```js
+// registry.config.js — CommonJS
+const azureSqlMetadataAdapter = require('oc-azure-sql-metadata-adapter').default;
+const s3StorageAdapter = require('oc-s3-storage-adapter');
+
+module.exports = {
+  baseUrl: 'http://my-registry.example.com/',
+  storage: {
+    adapter: s3StorageAdapter,
+    options: {
+      bucket: 'my-bucket',
+      region: 'us-east-1',
+      componentsDir: 'components',
+      path: 'https://cdn.example.com/'
+    }
+  },
+  metadata: {
+    adapter: azureSqlMetadataAdapter,
+    options: {
+      connectionString: process.env.OC_METADATA_SQL_CONNECTION_STRING
+    }
+  }
+};
+```
+
+```ts
+// registry.config.ts — ES module (transpiled or run with a native ESM loader)
+import azureSqlMetadataAdapter from 'oc-azure-sql-metadata-adapter';
+import s3StorageAdapter from 'oc-s3-storage-adapter';
+
+export default {
+  baseUrl: 'http://my-registry.example.com/',
+  storage: {
+    adapter: s3StorageAdapter,
+    options: {
+      bucket: 'my-bucket',
+      region: 'us-east-1',
+      componentsDir: 'components',
+      path: 'https://cdn.example.com/'
+    }
+  },
+  metadata: {
+    adapter: azureSqlMetadataAdapter,
+    options: {
+      connectionString: process.env.OC_METADATA_SQL_CONNECTION_STRING
+    }
+  }
+};
+```
+
+```js
+// registry.config.js — async factory (e.g. to resolve secrets first)
+module.exports = async () => {
+  const azureSqlMetadataAdapter = require('oc-azure-sql-metadata-adapter').default;
+  const s3StorageAdapter = require('oc-s3-storage-adapter');
+  const connectionString = await getSecret('oc-metadata-sql');
+
+  return {
+    baseUrl: 'http://my-registry.example.com/',
+    storage: {
+      adapter: s3StorageAdapter,
+      options: {
+        bucket: 'my-bucket',
+        region: 'us-east-1',
+        componentsDir: 'components',
+        path: 'https://cdn.example.com/'
+      }
+    },
+    metadata: {
+      adapter: azureSqlMetadataAdapter,
+      options: { connectionString }
+    }
+  };
+};
+```
+
+The command initialises the configured metadata adapter and backfills rows from
+`${componentsDir}/components-details.json`. If that file is missing, it falls back
+to scanning `${componentsDir}/<component>/<version>/package.json`. Existing rows
+are skipped, so the command is idempotent.
+
+A safe migration sequence is:
+
+1. Deploy the metadata adapter configuration to a non-serving environment.
+2. Run `oc registry migrate-metadata ./registry.config.js`.
+3. Start one registry instance with metadata mode enabled and verify reads.
+4. Roll out metadata mode to the remaining registry instances.
+
+### Bake-in and rollback options
+
+Two optional flags help run storage and metadata side by side during migration:
+
+- `metadata.reconcileFromStorage: true` scans storage on registry startup and
+  inserts missing metadata rows before cache hydration. Existing rows are skipped.
+- `metadata.exportLegacyFiles: true` writes DB-derived `components.json` and
+  `components-details.json` projections to storage once on registry startup. It
+  is **not** triggered per publish, so publishing stays an O(1) append rather
+  than a full-registry scan + blob rewrite.
+- `metadata.exportLegacyFilesInterval: <seconds>` additionally refreshes those
+  projections on a background timer (non-overlapping) when `exportLegacyFiles`
+  is enabled. Config validation rejects setting an interval without
+  `metadata.exportLegacyFiles: true`. Omit it to export at startup only. The
+  timer is stopped on `registry.close()`.
+
+These files are one-way projections from the metadata store. They can help with
+rollback to storage mode, but they do not replace the storage adapter because
+component statics remain in storage.
+
 ## Requirements and build status
 
 Disclaimer: This project is still under heavy development and the API is likely to change at any time. In case you would find any issues, check the [troubleshooting page](../../CONTRIBUTING.md#troubleshooting).

package/dist/cli/commands.d.ts

@@ -173,6 +173,14 @@ declare const _default: {
                     description: string;
                     usage: string;
                 };
+                'migrate-metadata': {
+                    cmd: string;
+                    example: {
+                        cmd: string;
+                    };
+                    description: string;
+                    usage: string;
+                };
                 remove: {
                     cmd: string;
                     example: {

package/dist/cli/commands.js

@@ -173,6 +173,14 @@ exports.default = {
                     description: 'Show oc registries added to the current project',
                     usage: 'Usage: $0 registry ls'
                 },
+                'migrate-metadata': {
+                    cmd: 'migrate-metadata <configPath>',
+                    example: {
+                        cmd: '$0 registry migrate-metadata ./registry.config.js'
+                    },
+                    description: 'Backfill a configured metadata store from existing registry metadata files',
+                    usage: 'Usage: $0 registry migrate-metadata <configPath>'
+                },
                 remove: {
                     cmd: 'remove <registryUrl>',
                     example: {

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

@@ -18,7 +18,7 @@ declare const dev: ({ local, logger }: {
         verbose?: boolean;
         production?: boolean;
     }): Promise<{
-        close: (callback: (err?: Error | undefined | string) => void) => void | import("node:http").Server<typeof import("node:http").IncomingMessage, typeof import("node:http").ServerResponse>;
+        close: (callback: (err?: Error | undefined | string) => void) => void;
         on: <T extends keyof {
             error: {
                 code: string;
@@ -100,7 +100,7 @@ declare const dev: ({ local, logger }: {
         verbose?: boolean;
         production?: boolean;
     }, arguments__1: (error: unknown, value: {
-        close: (callback: (err?: Error | undefined | string) => void) => void | import("node:http").Server<typeof import("node:http").IncomingMessage, typeof import("node:http").ServerResponse>;
+        close: (callback: (err?: Error | undefined | string) => void) => void;
         on: <T extends keyof {
             error: {
                 code: string;

package/dist/cli/facade/registry-migrate-metadata.d.ts

@@ -0,0 +1,20 @@
+import type { Logger } from '../logger';
+declare const registryMigrateMetadata: ({ logger }: {
+    logger: Logger;
+}) => {
+    (opts: {
+        configPath: string;
+    }): Promise<{
+        scanned: number;
+        inserted: number;
+        skipped: number;
+    }>;
+    (opts: {
+        configPath: string;
+    }, arguments__1: (error: unknown, value: {
+        scanned: number;
+        inserted: number;
+        skipped: number;
+    }) => void): void;
+};
+export default registryMigrateMetadata;

package/dist/cli/facade/registry-migrate-metadata.js

@@ -0,0 +1,105 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_path_1 = __importDefault(require("node:path"));
+const node_url_1 = require("node:url");
+const universalify_1 = require("universalify");
+const metadata_adapter_options_1 = __importDefault(require("../../registry/domain/metadata-adapter-options"));
+const metadata_migration_1 = require("../../registry/domain/metadata-migration");
+const options_sanitiser_1 = __importDefault(require("../../registry/domain/options-sanitiser"));
+const storage_adapter_1 = __importDefault(require("../../registry/domain/storage-adapter"));
+const validator = __importStar(require("../../registry/domain/validators"));
+const dynamicImport = new Function('specifier', 'return import(specifier)');
+const loadConfigModule = async (resolvedConfigPath) => {
+    try {
+        const resolvedRequirePath = require.resolve(resolvedConfigPath);
+        delete require.cache[resolvedRequirePath];
+        return require(resolvedRequirePath);
+    }
+    catch (err) {
+        if (err?.code !== 'ERR_REQUIRE_ESM') {
+            throw err;
+        }
+        return dynamicImport(`${(0, node_url_1.pathToFileURL)(resolvedConfigPath).href}?t=${Date.now()}`);
+    }
+};
+const loadRegistryOptions = async (configPath) => {
+    const resolvedConfigPath = node_path_1.default.resolve(configPath);
+    const configModule = await loadConfigModule(resolvedConfigPath);
+    const candidate = configModule?.default ?? configModule;
+    const options = typeof candidate === 'function' ? await candidate() : candidate;
+    if (!options || typeof options !== 'object') {
+        throw new Error('Registry config must export an options object');
+    }
+    return options;
+};
+const registryMigrateMetadata = ({ logger }) => (0, universalify_1.fromPromise)(async (opts) => {
+    try {
+        const inputOptions = await loadRegistryOptions(opts.configPath);
+        const validationResult = validator.validateRegistryConfiguration(inputOptions);
+        if (!validationResult.isValid) {
+            throw new Error(validationResult.message);
+        }
+        const conf = (0, options_sanitiser_1.default)(inputOptions);
+        if (!conf.metadata) {
+            throw new Error('Registry config must include metadata options');
+        }
+        const metadataStore = conf.metadata.adapter((0, metadata_adapter_options_1.default)(conf));
+        const cdn = (0, storage_adapter_1.default)(conf.storage.adapter(conf.storage.options));
+        try {
+            await metadataStore.initialise();
+            const result = await (0, metadata_migration_1.backfillMetadataFromStorageDetails)({
+                metadataStore,
+                cdn,
+                componentsDir: conf.storage.options.componentsDir
+            });
+            logger.ok(`Metadata migration completed: ${result.scanned} scanned, ${result.inserted} inserted, ${result.skipped} skipped`);
+            return result;
+        }
+        finally {
+            if (metadataStore.close) {
+                await metadataStore.close();
+            }
+        }
+    }
+    catch (err) {
+        logger.err(String(err?.message || err));
+        throw err;
+    }
+});
+exports.default = registryMigrateMetadata;

package/dist/cli/index.js

@@ -19,6 +19,7 @@ const publish_1 = __importDefault(require("./facade/publish"));
 const registry_2 = __importDefault(require("./facade/registry"));
 const registry_add_1 = __importDefault(require("./facade/registry-add"));
 const registry_ls_1 = __importDefault(require("./facade/registry-ls"));
+const registry_migrate_metadata_1 = __importDefault(require("./facade/registry-migrate-metadata"));
 const registry_remove_1 = __importDefault(require("./facade/registry-remove"));
 const validate_1 = __importDefault(require("./facade/validate"));
 const logger_1 = __importDefault(require("./logger"));
@@ -34,6 +35,7 @@ const cliFunctions = {
     registry: registry_2.default,
     'registry-add': registry_add_1.default,
     'registry-ls': registry_ls_1.default,
+    'registry-migrate-metadata': registry_migrate_metadata_1.default,
     'registry-remove': registry_remove_1.default,
     validate: validate_1.default
 };

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.55",
+  "version": "0.50.56",
   "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": "ebd4132fcd55c1f8bfa966365e0f2b496a9505b4",
+        "hashKey": "620aa4d6457f2972e6d53d8b8b572b9fcb5aa0d3",
         "src": "server.js",
         "size": 644
       }
     },
-    "version": "0.50.55",
+    "version": "0.50.56",
     "packaged": true,
-    "date": 1783073481627
+    "date": 1783178172523
   },
   "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.55"}),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.56"}),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.55",
+  "version": "0.50.56",
   "repository": "https://github.com/opencomponents/oc/tree/master/components/oc-client",
   "author": "Matteo Figus <matteofigus@gmail.com>",
   "oc": {

package/dist/registry/domain/components-cache/index.d.ts

@@ -1,7 +1,9 @@
 import { type StorageAdapter } from 'oc-storage-adapters-utils';
 import type { ComponentsList, Config } from '../../../types';
-export default function componentsCache(conf: Config, cdn: StorageAdapter): {
+import type { MetadataIndex } from '../metadata-index';
+export default function componentsCache(conf: Config, cdn: StorageAdapter, metadataIndex?: MetadataIndex): {
     get(): ComponentsList;
     load(): Promise<ComponentsList>;
     refresh(): Promise<ComponentsList>;
+    close(): void;
 };

package/dist/registry/domain/components-cache/index.js

@@ -9,14 +9,18 @@ const oc_get_unix_utc_timestamp_1 = __importDefault(require("oc-get-unix-utc-tim
 const oc_storage_adapters_utils_1 = require("oc-storage-adapters-utils");
 const events_handler_1 = __importDefault(require("../events-handler"));
 const components_list_1 = __importDefault(require("./components-list"));
-function componentsCache(conf, cdn) {
+function componentsCache(conf, cdn, metadataIndex) {
     let cachedComponentsList;
     let refreshLoop;
+    let closed = false;
     const componentsList = (0, components_list_1.default)(conf, cdn);
+    const getFromMetadataIndex = async () => (await metadataIndex.refresh()).componentsList;
     const poll = () => {
         return setTimeout(async () => {
             try {
-                const data = await componentsList.getFromJson();
+                const data = metadataIndex
+                    ? await getFromMetadataIndex()
+                    : await componentsList.getFromJson();
                 events_handler_1.default.fire('cache-poll', (0, oc_get_unix_utc_timestamp_1.default)());
                 if (data.lastEdit > cachedComponentsList.lastEdit) {
                     cachedComponentsList = data;
@@ -28,12 +32,16 @@ function componentsCache(conf, cdn) {
                     message: err?.message || String(err)
                 });
             }
-            refreshLoop = poll();
+            if (!closed) {
+                refreshLoop = poll();
+            }
         }, conf.pollingInterval * 1000);
     };
     const cacheDataAndStartPolling = (data) => {
         cachedComponentsList = data;
-        refreshLoop = poll();
+        if (!closed) {
+            refreshLoop = poll();
+        }
         return data;
     };
     const throwError = (code, message) => {
@@ -42,12 +50,21 @@ function componentsCache(conf, cdn) {
     };
     return {
         get() {
+            const metadataSnapshot = metadataIndex?.get();
+            if (metadataSnapshot) {
+                cachedComponentsList = metadataSnapshot.componentsList;
+            }
             if (!cachedComponentsList) {
                 return throwError('components_cache_empty', `The component's cache was empty`);
             }
             return cachedComponentsList;
         },
         async load() {
+            if (metadataIndex) {
+                const components = await getFromMetadataIndex().catch((err) => throwError('components_list_get', err));
+                cacheDataAndStartPolling(components);
+                return components;
+            }
             const jsonComponents = await componentsList.getFromJson().catch((err) => {
                 if (err?.code === oc_storage_adapters_utils_1.strings.errors.STORAGE.FILE_NOT_FOUND_CODE)
                     return null;
@@ -69,13 +86,19 @@ function componentsCache(conf, cdn) {
             clearTimeout(refreshLoop);
             try {
                 // Passing components that we know are fine, so it doesn't refresh invalid components
-                const components = await componentsList.refresh(cachedComponentsList);
+                const components = metadataIndex
+                    ? await getFromMetadataIndex()
+                    : await componentsList.refresh(cachedComponentsList);
                 cacheDataAndStartPolling(components);
                 return components;
             }
             catch (err) {
                 return throwError('components_cache_refresh', err);
             }
+        },
+        close() {
+            closed = true;
+            clearTimeout(refreshLoop);
         }
     };
 }

package/dist/registry/domain/components-details.d.ts

@@ -1,6 +1,8 @@
 import type { StorageAdapter } from 'oc-storage-adapters-utils';
 import type { ComponentsDetails, ComponentsList, Config } from '../../types';
-export default function componentsDetails(conf: Config, cdn: StorageAdapter): {
+import type { MetadataIndex } from './metadata-index';
+export default function componentsDetails(conf: Config, cdn: StorageAdapter, metadataIndex?: MetadataIndex): {
     get: () => Promise<ComponentsDetails>;
     refresh: (componentsList: ComponentsList) => Promise<ComponentsDetails>;
+    close: () => void;
 };

package/dist/registry/domain/components-details.js

@@ -8,9 +8,10 @@ const lodash_isequal_1 = __importDefault(require("lodash.isequal"));
 const oc_get_unix_utc_timestamp_1 = __importDefault(require("oc-get-unix-utc-timestamp"));
 const pLimit_1 = __importDefault(require("../../utils/pLimit"));
 const events_handler_1 = __importDefault(require("./events-handler"));
-function componentsDetails(conf, cdn) {
+function componentsDetails(conf, cdn, metadataIndex) {
     let cachedComponentsDetails;
     let refreshLoop;
+    let closed = false;
     const returnError = (code, message) => {
         events_handler_1.default.fire('error', {
             code,
@@ -20,10 +21,13 @@ function componentsDetails(conf, cdn) {
     };
     const filePath = () => `${conf.storage.options.componentsDir}/components-details.json`;
     const getFromJson = () => cdn.getJson(filePath(), true);
+    const getFromMetadataIndex = async () => (await metadataIndex.getOrRefresh()).componentsDetails;
     const poll = () => {
         return setTimeout(async () => {
             try {
-                const data = await getFromJson();
+                const data = metadataIndex
+                    ? await getFromMetadataIndex()
+                    : await getFromJson();
                 events_handler_1.default.fire('cache-poll', (0, oc_get_unix_utc_timestamp_1.default)());
                 if (!cachedComponentsDetails ||
                     data.lastEdit > cachedComponentsDetails.lastEdit) {
@@ -36,12 +40,16 @@ function componentsDetails(conf, cdn) {
                     message: err?.message || String(err)
                 });
             }
-            refreshLoop = poll();
+            if (!closed) {
+                refreshLoop = poll();
+            }
         }, conf.pollingInterval * 1000);
     };
     const cacheDataAndStartPolling = (data) => {
         cachedComponentsDetails = data;
-        refreshLoop = poll();
+        if (!metadataIndex && !closed) {
+            refreshLoop = poll();
+        }
         return data;
     };
     const getFromDirectories = async (options) => {
@@ -74,6 +82,10 @@ function componentsDetails(conf, cdn) {
     };
     const save = (data) => cdn.putFileContent(JSON.stringify(data), filePath(), true);
     const get = async () => {
+        if (metadataIndex) {
+            cachedComponentsDetails = await getFromMetadataIndex();
+            return cachedComponentsDetails;
+        }
         if (cachedComponentsDetails) {
             return cachedComponentsDetails;
         }
@@ -82,6 +94,10 @@ function componentsDetails(conf, cdn) {
     };
     const refresh = async (componentsList) => {
         clearTimeout(refreshLoop);
+        if (metadataIndex) {
+            const details = await getFromMetadataIndex().catch((err) => returnError('components_details_get', err));
+            return cacheDataAndStartPolling(details);
+        }
         const jsonDetails = await getFromJson().catch(() => undefined);
         const dirDetails = await getFromDirectories({
             componentsList,
@@ -94,8 +110,13 @@ function componentsDetails(conf, cdn) {
         }
         return cacheDataAndStartPolling(jsonDetails);
     };
+    const close = () => {
+        closed = true;
+        clearTimeout(refreshLoop);
+    };
     return {
         get,
-        refresh
+        refresh,
+        close
     };
 }

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;