keyv-registry 0.1.0

package/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Kevin Malakoff
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

package/README.md

@@ -0,0 +1,202 @@
+# keyv-registry
+
+Protocol-based Keyv adapter registry with dynamic module installation.
+
+Create Keyv stores from URI strings with automatic adapter resolution and on-demand installation.
+
+## Features
+
+- **URI-based configuration**: Use familiar connection strings like `redis://localhost:6379`
+- **Dynamic installation**: Adapters are installed on-demand, no hard dependencies
+- **Extensible registry**: Register custom protocols or override defaults
+- **Dual-boot API**: Supports both Promise and callback patterns
+- **URI parameter mapping**: Query params automatically converted to adapter options
+- **Store passthrough**: Use pre-instantiated adapters when needed
+
+## Installation
+
+```bash
+npm install keyv-registry
+```
+
+## Usage
+
+### Promise API
+
+```typescript
+import createStore from 'keyv-registry';
+
+// Redis
+const redis = await createStore('redis://localhost:6379');
+
+// PostgreSQL
+const postgres = await createStore('postgresql://user:pass@localhost/db');
+
+// File-based storage
+const file = await createStore('file://~/.cache/myapp/data.json');
+
+// In-memory (built-in, no package needed)
+const memory = await createStore('memory://');
+
+// SQLite
+const sqlite = await createStore('sqlite:///path/to/db.sqlite');
+
+// With options
+const store = await createStore('redis://localhost:6379', {
+  namespace: 'myapp',
+  ttl: 60000
+});
+```
+
+### Callback API
+
+```typescript
+import createStore from 'keyv-registry';
+
+createStore('redis://localhost:6379', (err, store) => {
+  if (err) throw err;
+  // use store
+});
+
+// With options
+createStore('redis://localhost:6379', { namespace: 'myapp' }, (err, store) => {
+  if (err) throw err;
+  // use store
+});
+```
+
+### URI Query Parameters
+
+Query parameters are automatically converted to adapter options:
+
+```typescript
+// Equivalent to { keyPrefix: 'myapp', ttl: 3600 }
+const store = await createStore('redis://localhost:6379?keyPrefix=myapp&ttl=3600');
+
+// Boolean and number conversion is automatic
+const file = await createStore('file://~/data.json?writeDelay=100&pretty=true');
+```
+
+### Custom Adapters
+
+Register custom protocols or override defaults:
+
+```typescript
+import createStore, { registerAdapter } from 'keyv-registry';
+
+// Register a new protocol
+registerAdapter('cloudflare:', { package: 'keyv-cloudflare' });
+const cf = await createStore('cloudflare://my-namespace');
+
+// Override default with custom package
+registerAdapter('file:', {
+  package: '@my-org/keyv-file-encrypted',
+  optionsMapper: (url) => ({
+    filename: url.pathname,
+    encryption: true
+  })
+});
+```
+
+### Pre-instantiated Adapter Passthrough
+
+For advanced configuration, pass a pre-instantiated adapter:
+
+```typescript
+import createStore from 'keyv-registry';
+import KeyvRedis from '@keyv/redis';
+
+const customRedis = new KeyvRedis('redis://localhost:6379', {
+  useUnlink: true,
+  cluster: true
+});
+
+// URI is ignored when store option is provided
+const store = await createStore('redis://ignored', { store: customRedis });
+```
+
+## Supported Protocols
+
+### Official @keyv Adapters
+
+| Protocol | Package | Notes |
+|----------|---------|-------|
+| `redis://`, `rediss://` | `@keyv/redis` | Redis, supports TLS |
+| `postgresql://`, `postgres://` | `@keyv/postgres` | PostgreSQL |
+| `mysql://` | `@keyv/mysql` | MySQL/MariaDB |
+| `sqlite://` | `@keyv/sqlite` | SQLite |
+| `mongodb://`, `mongodb+srv://` | `@keyv/mongo` | MongoDB |
+| `memcache://` | `@keyv/memcache` | Memcached |
+| `etcd://` | `@keyv/etcd` | etcd |
+
+### Third-party Adapters
+
+| Protocol | Package | Notes |
+|----------|---------|-------|
+| `file://` | `keyv-file` | File-based JSON storage |
+| `duckdb://` | `keyv-duckdb` | DuckDB (planned) |
+
+### Built-in
+
+| Protocol | Notes |
+|----------|-------|
+| `memory://` | In-memory Map, no package needed |
+
+## API
+
+### `createStore(uri, [options], [callback])`
+
+Create a Keyv store from a URI string.
+
+**Parameters:**
+- `uri` (string): Connection URI with protocol
+- `options` (object, optional): Keyv options
+  - `store`: Pre-instantiated adapter (bypasses URI loading)
+  - `namespace`: Keyv namespace
+  - `ttl`: Default TTL in milliseconds
+  - Additional options passed to Keyv
+- `callback` (function, optional): Node-style callback `(err, store) => void`
+
+**Returns:** `Promise<Keyv>` if no callback, `undefined` if callback provided
+
+### `registerAdapter(protocol, config)`
+
+Register or override a protocol adapter.
+
+**Parameters:**
+- `protocol` (string): Protocol with or without trailing colon (e.g., `'redis:'` or `'redis'`)
+- `config` (object): Adapter configuration
+  - `package`: npm package name, or `null` for built-in
+  - `exportName`: Named export (default: `'default'`)
+  - `optionsMapper`: Function `(url: URL) => object` to map URL to options
+
+### `getRegistry()`
+
+Get a read-only copy of the current protocol registry.
+
+**Returns:** `Record<string, AdapterConfig>`
+
+### `clearAdapterCache()`
+
+Clear the loaded adapter cache. Useful for testing.
+
+## File Path Shortcuts
+
+The `file://` protocol supports path shortcuts:
+
+```typescript
+// Home directory
+await createStore('file://~/.cache/myapp/data.json');
+
+// Current working directory
+await createStore('file://./data/cache.json');
+
+// Absolute path
+await createStore('file:///var/cache/myapp/data.json');
+```
+
+Directories are created automatically if they don't exist.
+
+## License
+
+MIT

package/dist/cjs/index.d.cts

@@ -0,0 +1,37 @@
+import type Keyv from 'keyv';
+import type { CreateStoreCallback, CreateStoreOptions } from './types.js';
+export { clearAdapterCache } from './loadAdapter.js';
+export { getRegistry, registerAdapter } from './registry.js';
+export type { AdapterConfig, CreateStoreCallback, CreateStoreOptions } from './types.js';
+/**
+ * Create a Keyv store from a URI string
+ *
+ * Supports dual-boot API (callback or Promise):
+ *
+ * @example
+ * // Promise API
+ * const store = await createStore('redis://localhost:6379');
+ * const file = await createStore('file://~/.cache/app/data.json');
+ * const memory = await createStore('memory://');
+ *
+ * @example
+ * // Callback API
+ * createStore('redis://localhost:6379', (err, store) => {
+ *   if (err) throw err;
+ *   // use store
+ * });
+ *
+ * @example
+ * // With options
+ * const store = await createStore('redis://localhost:6379', {
+ *   namespace: 'myapp',
+ *   ttl: 60000
+ * });
+ *
+ * @example
+ * // Pre-instantiated adapter passthrough
+ * import KeyvRedis from '@keyv/redis';
+ * const redis = new KeyvRedis('redis://localhost:6379');
+ * const store = await createStore('redis://ignored', { store: redis });
+ */
+export default function createStore<T>(uri: string, options?: CreateStoreOptions | CreateStoreCallback<T>, callback?: CreateStoreCallback<T>): undefined | Promise<Keyv<T>>;

package/dist/cjs/index.d.ts

@@ -0,0 +1,37 @@
+import type Keyv from 'keyv';
+import type { CreateStoreCallback, CreateStoreOptions } from './types.js';
+export { clearAdapterCache } from './loadAdapter.js';
+export { getRegistry, registerAdapter } from './registry.js';
+export type { AdapterConfig, CreateStoreCallback, CreateStoreOptions } from './types.js';
+/**
+ * Create a Keyv store from a URI string
+ *
+ * Supports dual-boot API (callback or Promise):
+ *
+ * @example
+ * // Promise API
+ * const store = await createStore('redis://localhost:6379');
+ * const file = await createStore('file://~/.cache/app/data.json');
+ * const memory = await createStore('memory://');
+ *
+ * @example
+ * // Callback API
+ * createStore('redis://localhost:6379', (err, store) => {
+ *   if (err) throw err;
+ *   // use store
+ * });
+ *
+ * @example
+ * // With options
+ * const store = await createStore('redis://localhost:6379', {
+ *   namespace: 'myapp',
+ *   ttl: 60000
+ * });
+ *
+ * @example
+ * // Pre-instantiated adapter passthrough
+ * import KeyvRedis from '@keyv/redis';
+ * const redis = new KeyvRedis('redis://localhost:6379');
+ * const store = await createStore('redis://ignored', { store: redis });
+ */
+export default function createStore<T>(uri: string, options?: CreateStoreOptions | CreateStoreCallback<T>, callback?: CreateStoreCallback<T>): undefined | Promise<Keyv<T>>;

package/dist/cjs/index.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get clearAdapterCache () {
+        return _loadAdapterts.clearAdapterCache;
+    },
+    get /**
+ * Create a Keyv store from a URI string
+ *
+ * Supports dual-boot API (callback or Promise):
+ *
+ * @example
+ * // Promise API
+ * const store = await createStore('redis://localhost:6379');
+ * const file = await createStore('file://~/.cache/app/data.json');
+ * const memory = await createStore('memory://');
+ *
+ * @example
+ * // Callback API
+ * createStore('redis://localhost:6379', (err, store) => {
+ *   if (err) throw err;
+ *   // use store
+ * });
+ *
+ * @example
+ * // With options
+ * const store = await createStore('redis://localhost:6379', {
+ *   namespace: 'myapp',
+ *   ttl: 60000
+ * });
+ *
+ * @example
+ * // Pre-instantiated adapter passthrough
+ * import KeyvRedis from '@keyv/redis';
+ * const redis = new KeyvRedis('redis://localhost:6379');
+ * const store = await createStore('redis://ignored', { store: redis });
+ */ default () {
+        return createStore;
+    },
+    get getRegistry () {
+        return _registryts.getRegistry;
+    },
+    get registerAdapter () {
+        return _registryts.registerAdapter;
+    }
+});
+var _workerts = /*#__PURE__*/ _interop_require_default(require("./worker.js"));
+var _loadAdapterts = require("./loadAdapter.js");
+var _registryts = require("./registry.js");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function createStore(uri, options, callback) {
+    // Normalize arguments
+    if (typeof options === 'function') {
+        callback = options;
+        options = {};
+    }
+    options = options || {};
+    // Callback mode
+    if (typeof callback === 'function') {
+        (0, _workerts.default)(uri, options, callback);
+        return undefined;
+    }
+    // Promise mode
+    return new Promise(function(resolve, reject) {
+        (0, _workerts.default)(uri, options, function(err, store) {
+            return err ? reject(err) : resolve(store);
+        });
+    });
+}
+/* CJS INTEROP */ if (exports.__esModule && exports.default) { try { Object.defineProperty(exports.default, '__esModule', { value: true }); for (var key in exports) { exports.default[key] = exports[key]; } } catch (_) {}; module.exports = exports.default; }

package/dist/cjs/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/keyv/keyv-registry/src/index.ts"],"sourcesContent":["import type Keyv from 'keyv';\nimport type { CreateStoreCallback, CreateStoreOptions } from './types.ts';\nimport worker from './worker.ts';\n\nexport { clearAdapterCache } from './loadAdapter.ts';\nexport { getRegistry, registerAdapter } from './registry.ts';\nexport type { AdapterConfig, CreateStoreCallback, CreateStoreOptions } from './types.ts';\n\n/**\n * Create a Keyv store from a URI string\n *\n * Supports dual-boot API (callback or Promise):\n *\n * @example\n * // Promise API\n * const store = await createStore('redis://localhost:6379');\n * const file = await createStore('file://~/.cache/app/data.json');\n * const memory = await createStore('memory://');\n *\n * @example\n * // Callback API\n * createStore('redis://localhost:6379', (err, store) => {\n *   if (err) throw err;\n *   // use store\n * });\n *\n * @example\n * // With options\n * const store = await createStore('redis://localhost:6379', {\n *   namespace: 'myapp',\n *   ttl: 60000\n * });\n *\n * @example\n * // Pre-instantiated adapter passthrough\n * import KeyvRedis from '@keyv/redis';\n * const redis = new KeyvRedis('redis://localhost:6379');\n * const store = await createStore('redis://ignored', { store: redis });\n */\nexport default function createStore<T>(uri: string, options?: CreateStoreOptions | CreateStoreCallback<T>, callback?: CreateStoreCallback<T>): undefined | Promise<Keyv<T>> {\n  // Normalize arguments\n  if (typeof options === 'function') {\n    callback = options;\n    options = {};\n  }\n  options = options || {};\n\n  // Callback mode\n  if (typeof callback === 'function') {\n    worker(uri, options, callback);\n    return undefined;\n  }\n\n  // Promise mode\n  return new Promise((resolve, reject) => {\n    worker(uri, options as CreateStoreOptions, (err, store) => (err ? reject(err) : resolve(store as Keyv<T>)));\n  });\n}\n"],"names":["clearAdapterCache","createStore","getRegistry","registerAdapter","uri","options","callback","worker","undefined","Promise","resolve","reject","err","store"],"mappings":";;;;;;;;;;;QAISA;eAAAA,gCAAiB;;QAI1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8BC,GACD;eAAwBC;;QAlCfC;eAAAA,uBAAW;;QAAEC;eAAAA,2BAAe;;;+DAHlB;6BAEe;0BACW;;;;;;AAkC9B,SAASF,YAAeG,GAAW,EAAEC,OAAqD,EAAEC,QAAiC;IAC1I,sBAAsB;IACtB,IAAI,OAAOD,YAAY,YAAY;QACjCC,WAAWD;QACXA,UAAU,CAAC;IACb;IACAA,UAAUA,WAAW,CAAC;IAEtB,gBAAgB;IAChB,IAAI,OAAOC,aAAa,YAAY;QAClCC,IAAAA,iBAAM,EAACH,KAAKC,SAASC;QACrB,OAAOE;IACT;IAEA,eAAe;IACf,OAAO,IAAIC,QAAQ,SAACC,SAASC;QAC3BJ,IAAAA,iBAAM,EAACH,KAAKC,SAA+B,SAACO,KAAKC;mBAAWD,MAAMD,OAAOC,OAAOF,QAAQG;;IAC1F;AACF"}

package/dist/cjs/loadAdapter.d.cts

@@ -0,0 +1,9 @@
+import type { LoadAdapterCallback } from './types.js';
+/**
+ * Load an adapter, installing it dynamically if needed
+ */
+export default function loadAdapter(packageName: string, exportName: string | undefined, callback: LoadAdapterCallback): void;
+/**
+ * Clear the adapter cache (useful for testing)
+ */
+export declare function clearAdapterCache(): void;

package/dist/cjs/loadAdapter.d.ts

@@ -0,0 +1,9 @@
+import type { LoadAdapterCallback } from './types.js';
+/**
+ * Load an adapter, installing it dynamically if needed
+ */
+export default function loadAdapter(packageName: string, exportName: string | undefined, callback: LoadAdapterCallback): void;
+/**
+ * Clear the adapter cache (useful for testing)
+ */
+export declare function clearAdapterCache(): void;

package/dist/cjs/loadAdapter.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get clearAdapterCache () {
+        return clearAdapterCache;
+    },
+    get /**
+ * Load an adapter, installing it dynamically if needed
+ */ default () {
+        return loadAdapter;
+    }
+});
+var _nodemodule = /*#__PURE__*/ _interop_require_default(require("node:module"));
+var _nodepath = /*#__PURE__*/ _interop_require_default(require("node:path"));
+var _nodeurl = /*#__PURE__*/ _interop_require_default(require("node:url"));
+var _installmodulelinked = /*#__PURE__*/ _interop_require_default(require("install-module-linked"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+// Create require function for ESM compatibility
+var _require = typeof require === 'undefined' ? _nodemodule.default.createRequire(require("url").pathToFileURL(__filename).toString()) : require;
+// Determine node_modules path
+var _dirname = _nodepath.default.dirname(typeof __dirname !== 'undefined' ? __dirname : _nodeurl.default.fileURLToPath(require("url").pathToFileURL(__filename).toString()));
+var nodeModulesPath = _nodepath.default.join(_dirname, '..', '..', 'node_modules');
+// Cache loaded adapters
+var adapterCache = new Map();
+function loadAdapter(packageName, exportName, callback) {
+    var cacheKey = "".concat(packageName, ":").concat(exportName !== null && exportName !== void 0 ? exportName : 'default');
+    // Return cached adapter if available
+    if (adapterCache.has(cacheKey)) {
+        callback(null, adapterCache.get(cacheKey));
+        return;
+    }
+    // Try to require first (may already be installed)
+    try {
+        var mod = _require(packageName);
+        var _mod_default;
+        var Adapter = exportName ? mod[exportName] : (_mod_default = mod.default) !== null && _mod_default !== void 0 ? _mod_default : mod;
+        adapterCache.set(cacheKey, Adapter);
+        callback(null, Adapter);
+        return;
+    } catch (e) {
+        // Not installed - dynamically install then load
+        (0, _installmodulelinked.default)(packageName, nodeModulesPath, {}, function(err) {
+            if (err) {
+                callback(err);
+                return;
+            }
+            try {
+                var mod = _require(packageName);
+                var _mod_default;
+                var Adapter = exportName ? mod[exportName] : (_mod_default = mod.default) !== null && _mod_default !== void 0 ? _mod_default : mod;
+                adapterCache.set(cacheKey, Adapter);
+                callback(null, Adapter);
+            } catch (loadErr) {
+                callback(loadErr);
+            }
+        });
+    }
+}
+function clearAdapterCache() {
+    adapterCache.clear();
+}
+/* CJS INTEROP */ if (exports.__esModule && exports.default) { try { Object.defineProperty(exports.default, '__esModule', { value: true }); for (var key in exports) { exports.default[key] = exports[key]; } } catch (_) {}; module.exports = exports.default; }

package/dist/cjs/loadAdapter.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/keyv/keyv-registry/src/loadAdapter.ts"],"sourcesContent":["import Module from 'node:module';\nimport path from 'node:path';\nimport url from 'node:url';\nimport installModule from 'install-module-linked';\nimport type { LoadAdapterCallback } from './types.ts';\n\n// Create require function for ESM compatibility\nconst _require = typeof require === 'undefined' ? Module.createRequire(import.meta.url) : require;\n\n// Determine node_modules path\nconst _dirname = path.dirname(typeof __dirname !== 'undefined' ? __dirname : url.fileURLToPath(import.meta.url));\nconst nodeModulesPath = path.join(_dirname, '..', '..', 'node_modules');\n\n// Cache loaded adapters\nconst adapterCache = new Map<string, unknown>();\n\n/**\n * Load an adapter, installing it dynamically if needed\n */\nexport default function loadAdapter(packageName: string, exportName: string | undefined, callback: LoadAdapterCallback): void {\n  const cacheKey = `${packageName}:${exportName ?? 'default'}`;\n\n  // Return cached adapter if available\n  if (adapterCache.has(cacheKey)) {\n    callback(null, adapterCache.get(cacheKey));\n    return;\n  }\n\n  // Try to require first (may already be installed)\n  try {\n    const mod = _require(packageName);\n    const Adapter = exportName ? mod[exportName] : (mod.default ?? mod);\n    adapterCache.set(cacheKey, Adapter);\n    callback(null, Adapter);\n    return;\n  } catch {\n    // Not installed - dynamically install then load\n    installModule(packageName, nodeModulesPath, {}, (err: Error | null) => {\n      if (err) {\n        callback(err);\n        return;\n      }\n      try {\n        const mod = _require(packageName);\n        const Adapter = exportName ? mod[exportName] : (mod.default ?? mod);\n        adapterCache.set(cacheKey, Adapter);\n        callback(null, Adapter);\n      } catch (loadErr) {\n        callback(loadErr as Error);\n      }\n    });\n  }\n}\n\n/**\n * Clear the adapter cache (useful for testing)\n */\nexport function clearAdapterCache(): void {\n  adapterCache.clear();\n}\n"],"names":["clearAdapterCache","loadAdapter","_require","require","Module","createRequire","_dirname","path","dirname","__dirname","url","fileURLToPath","nodeModulesPath","join","adapterCache","Map","packageName","exportName","callback","cacheKey","has","get","mod","Adapter","default","set","installModule","err","loadErr","clear"],"mappings":";;;;;;;;;;;QAyDgBA;eAAAA;;QAzChB;;CAEC,GACD;eAAwBC;;;iEAnBL;+DACF;8DACD;0EACU;;;;;;AAG1B,gDAAgD;AAChD,IAAMC,WAAW,OAAOC,YAAY,cAAcC,mBAAM,CAACC,aAAa,CAAC,uDAAmBF;AAE1F,8BAA8B;AAC9B,IAAMG,WAAWC,iBAAI,CAACC,OAAO,CAAC,OAAOC,cAAc,cAAcA,YAAYC,gBAAG,CAACC,aAAa,CAAC;AAC/F,IAAMC,kBAAkBL,iBAAI,CAACM,IAAI,CAACP,UAAU,MAAM,MAAM;AAExD,wBAAwB;AACxB,IAAMQ,eAAe,IAAIC;AAKV,SAASd,YAAYe,WAAmB,EAAEC,UAA8B,EAAEC,QAA6B;IACpH,IAAMC,WAAW,AAAC,GAAiBF,OAAfD,aAAY,KAA2B,OAAxBC,uBAAAA,wBAAAA,aAAc;IAEjD,qCAAqC;IACrC,IAAIH,aAAaM,GAAG,CAACD,WAAW;QAC9BD,SAAS,MAAMJ,aAAaO,GAAG,CAACF;QAChC;IACF;IAEA,kDAAkD;IAClD,IAAI;QACF,IAAMG,MAAMpB,SAASc;YAC2BM;QAAhD,IAAMC,UAAUN,aAAaK,GAAG,CAACL,WAAW,GAAIK,CAAAA,eAAAA,IAAIE,OAAO,cAAXF,0BAAAA,eAAeA;QAC/DR,aAAaW,GAAG,CAACN,UAAUI;QAC3BL,SAAS,MAAMK;QACf;IACF,EAAE,UAAM;QACN,gDAAgD;QAChDG,IAAAA,4BAAa,EAACV,aAAaJ,iBAAiB,CAAC,GAAG,SAACe;YAC/C,IAAIA,KAAK;gBACPT,SAASS;gBACT;YACF;YACA,IAAI;gBACF,IAAML,MAAMpB,SAASc;oBAC2BM;gBAAhD,IAAMC,UAAUN,aAAaK,GAAG,CAACL,WAAW,GAAIK,CAAAA,eAAAA,IAAIE,OAAO,cAAXF,0BAAAA,eAAeA;gBAC/DR,aAAaW,GAAG,CAACN,UAAUI;gBAC3BL,SAAS,MAAMK;YACjB,EAAE,OAAOK,SAAS;gBAChBV,SAASU;YACX;QACF;IACF;AACF;AAKO,SAAS5B;IACdc,aAAae,KAAK;AACpB"}

package/dist/cjs/package.json

@@ -0,0 +1 @@
+{ "type": "commonjs" }

package/dist/cjs/registry.d.cts

@@ -0,0 +1,13 @@
+import type { AdapterConfig } from './types.js';
+/**
+ * Register or override a protocol adapter
+ */
+export declare function registerAdapter(protocol: string, config: AdapterConfig): void;
+/**
+ * Get the current registry (read-only copy)
+ */
+export declare function getRegistry(): Readonly<Record<string, AdapterConfig>>;
+/**
+ * Get adapter config for a protocol
+ */
+export declare function getAdapterConfig(protocol: string): AdapterConfig | undefined;

package/dist/cjs/registry.d.ts

@@ -0,0 +1,13 @@
+import type { AdapterConfig } from './types.js';
+/**
+ * Register or override a protocol adapter
+ */
+export declare function registerAdapter(protocol: string, config: AdapterConfig): void;
+/**
+ * Get the current registry (read-only copy)
+ */
+export declare function getRegistry(): Readonly<Record<string, AdapterConfig>>;
+/**
+ * Get adapter config for a protocol
+ */
+export declare function getAdapterConfig(protocol: string): AdapterConfig | undefined;

package/dist/cjs/registry.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get getAdapterConfig () {
+        return getAdapterConfig;
+    },
+    get getRegistry () {
+        return getRegistry;
+    },
+    get registerAdapter () {
+        return registerAdapter;
+    }
+});
+var _utilsts = require("./utils.js");
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
+/**
+ * Protocol registry mapping URI protocols to adapter configurations
+ */ var PROTOCOL_REGISTRY = {
+    // Official @keyv adapters
+    'redis:': {
+        package: '@keyv/redis'
+    },
+    'rediss:': {
+        package: '@keyv/redis'
+    },
+    'postgresql:': {
+        package: '@keyv/postgres'
+    },
+    'postgres:': {
+        package: '@keyv/postgres'
+    },
+    'mysql:': {
+        package: '@keyv/mysql'
+    },
+    'sqlite:': {
+        package: '@keyv/sqlite'
+    },
+    'mongodb:': {
+        package: '@keyv/mongo'
+    },
+    'mongodb+srv:': {
+        package: '@keyv/mongo'
+    },
+    'memcache:': {
+        package: '@keyv/memcache'
+    },
+    'etcd:': {
+        package: '@keyv/etcd'
+    },
+    // Third-party adapters
+    'file:': {
+        package: 'keyv-file',
+        exportName: 'KeyvFile',
+        optionsMapper: function(url) {
+            return {
+                filename: (0, _utilsts.resolveFilePath)(url)
+            };
+        }
+    },
+    // Built-in (no package needed)
+    'memory:': {
+        package: null
+    },
+    // Future/custom adapters
+    'duckdb:': {
+        package: 'keyv-duckdb',
+        optionsMapper: function(url) {
+            return {
+                filename: (0, _utilsts.resolveFilePath)(url)
+            };
+        }
+    }
+};
+function registerAdapter(protocol, config) {
+    var normalizedProtocol = protocol.endsWith(':') ? protocol : "".concat(protocol, ":");
+    PROTOCOL_REGISTRY[normalizedProtocol] = config;
+}
+function getRegistry() {
+    return _object_spread({}, PROTOCOL_REGISTRY);
+}
+function getAdapterConfig(protocol) {
+    return PROTOCOL_REGISTRY[protocol];
+}
+/* CJS INTEROP */ if (exports.__esModule && exports.default) { try { Object.defineProperty(exports.default, '__esModule', { value: true }); for (var key in exports) { exports.default[key] = exports[key]; } } catch (_) {}; module.exports = exports.default; }

package/dist/cjs/registry.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/keyv/keyv-registry/src/registry.ts"],"sourcesContent":["import type { AdapterConfig } from './types.ts';\nimport { resolveFilePath } from './utils.ts';\n\n/**\n * Protocol registry mapping URI protocols to adapter configurations\n */\nconst PROTOCOL_REGISTRY: Record<string, AdapterConfig> = {\n  // Official @keyv adapters\n  'redis:': { package: '@keyv/redis' },\n  'rediss:': { package: '@keyv/redis' },\n  'postgresql:': { package: '@keyv/postgres' },\n  'postgres:': { package: '@keyv/postgres' },\n  'mysql:': { package: '@keyv/mysql' },\n  'sqlite:': { package: '@keyv/sqlite' },\n  'mongodb:': { package: '@keyv/mongo' },\n  'mongodb+srv:': { package: '@keyv/mongo' },\n  'memcache:': { package: '@keyv/memcache' },\n  'etcd:': { package: '@keyv/etcd' },\n\n  // Third-party adapters\n  'file:': {\n    package: 'keyv-file',\n    exportName: 'KeyvFile',\n    optionsMapper: (url: URL) => ({ filename: resolveFilePath(url) }),\n  },\n\n  // Built-in (no package needed)\n  'memory:': { package: null },\n\n  // Future/custom adapters\n  'duckdb:': {\n    package: 'keyv-duckdb',\n    optionsMapper: (url: URL) => ({ filename: resolveFilePath(url) }),\n  },\n};\n\n/**\n * Register or override a protocol adapter\n */\nexport function registerAdapter(protocol: string, config: AdapterConfig): void {\n  const normalizedProtocol = protocol.endsWith(':') ? protocol : `${protocol}:`;\n  PROTOCOL_REGISTRY[normalizedProtocol] = config;\n}\n\n/**\n * Get the current registry (read-only copy)\n */\nexport function getRegistry(): Readonly<Record<string, AdapterConfig>> {\n  return { ...PROTOCOL_REGISTRY };\n}\n\n/**\n * Get adapter config for a protocol\n */\nexport function getAdapterConfig(protocol: string): AdapterConfig | undefined {\n  return PROTOCOL_REGISTRY[protocol];\n}\n"],"names":["getAdapterConfig","getRegistry","registerAdapter","PROTOCOL_REGISTRY","package","exportName","optionsMapper","url","filename","resolveFilePath","protocol","config","normalizedProtocol","endsWith"],"mappings":";;;;;;;;;;;QAsDgBA;eAAAA;;QAPAC;eAAAA;;QARAC;eAAAA;;;uBAtCgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEhC;;CAEC,GACD,IAAMC,oBAAmD;IACvD,0BAA0B;IAC1B,UAAU;QAAEC,SAAS;IAAc;IACnC,WAAW;QAAEA,SAAS;IAAc;IACpC,eAAe;QAAEA,SAAS;IAAiB;IAC3C,aAAa;QAAEA,SAAS;IAAiB;IACzC,UAAU;QAAEA,SAAS;IAAc;IACnC,WAAW;QAAEA,SAAS;IAAe;IACrC,YAAY;QAAEA,SAAS;IAAc;IACrC,gBAAgB;QAAEA,SAAS;IAAc;IACzC,aAAa;QAAEA,SAAS;IAAiB;IACzC,SAAS;QAAEA,SAAS;IAAa;IAEjC,uBAAuB;IACvB,SAAS;QACPA,SAAS;QACTC,YAAY;QACZC,eAAe,SAACC;mBAAc;gBAAEC,UAAUC,IAAAA,wBAAe,EAACF;YAAK;;IACjE;IAEA,+BAA+B;IAC/B,WAAW;QAAEH,SAAS;IAAK;IAE3B,yBAAyB;IACzB,WAAW;QACTA,SAAS;QACTE,eAAe,SAACC;mBAAc;gBAAEC,UAAUC,IAAAA,wBAAe,EAACF;YAAK;;IACjE;AACF;AAKO,SAASL,gBAAgBQ,QAAgB,EAAEC,MAAqB;IACrE,IAAMC,qBAAqBF,SAASG,QAAQ,CAAC,OAAOH,WAAW,AAAC,GAAW,OAATA,UAAS;IAC3EP,iBAAiB,CAACS,mBAAmB,GAAGD;AAC1C;AAKO,SAASV;IACd,OAAO,mBAAKE;AACd;AAKO,SAASH,iBAAiBU,QAAgB;IAC/C,OAAOP,iBAAiB,CAACO,SAAS;AACpC"}