@dexto/core 1.4.0 → 1.5.1

package/dist/storage/cache/registry.cjs

@@ -0,0 +1,50 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var registry_exports = {};
+__export(registry_exports, {
+  CacheRegistry: () => CacheRegistry,
+  cacheRegistry: () => cacheRegistry
+});
+module.exports = __toCommonJS(registry_exports);
+var import_errors = require("../errors.js");
+var import_base_registry = require("../../providers/base-registry.js");
+const cacheErrorFactory = {
+  alreadyRegistered: (type) => import_errors.StorageError.cacheProviderAlreadyRegistered(type),
+  notFound: (type, availableTypes) => import_errors.StorageError.unknownCacheProvider(type, availableTypes)
+};
+class CacheRegistry extends import_base_registry.BaseRegistry {
+  constructor() {
+    super(cacheErrorFactory);
+  }
+  /**
+   * Get all registered providers.
+   * Alias for getAll() for backward compatibility.
+   *
+   * @returns Array of providers
+   */
+  getProviders() {
+    return this.getAll();
+  }
+}
+const cacheRegistry = new CacheRegistry();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CacheRegistry,
+  cacheRegistry
+});

package/dist/storage/cache/registry.d.ts

@@ -0,0 +1,42 @@
+import type { CacheProvider } from './provider.js';
+import { BaseRegistry } from '../../providers/base-registry.js';
+/**
+ * Registry for cache providers.
+ *
+ * This registry manages available cache implementations and provides
+ * runtime validation for configurations. Providers can be registered from
+ * both core (built-in) and application layers (custom).
+ *
+ * The registry follows a global singleton pattern to allow registration
+ * before configuration loading, while maintaining type safety through
+ * provider interfaces.
+ *
+ * Extends BaseRegistry for common registry functionality.
+ */
+export declare class CacheRegistry extends BaseRegistry<CacheProvider<any, any>> {
+    constructor();
+    /**
+     * Get all registered providers.
+     * Alias for getAll() for backward compatibility.
+     *
+     * @returns Array of providers
+     */
+    getProviders(): CacheProvider<any, any>[];
+}
+/**
+ * Global singleton registry for cache providers.
+ *
+ * This registry is used by the createCache factory and can be extended
+ * with custom providers before configuration loading.
+ *
+ * Example usage in CLI/server layer:
+ * ```typescript
+ * import { cacheRegistry } from '@dexto/core';
+ * import { memcachedProvider } from './storage/memcached-provider.js';
+ *
+ * // Register custom provider before loading config
+ * cacheRegistry.register(memcachedProvider);
+ * ```
+ */
+export declare const cacheRegistry: CacheRegistry;
+//# sourceMappingURL=registry.d.ts.map

package/dist/storage/cache/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../src/storage/cache/registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAEnD,OAAO,EAAE,YAAY,EAA6B,MAAM,kCAAkC,CAAC;AAY3F;;;;;;;;;;;;GAYG;AACH,qBAAa,aAAc,SAAQ,YAAY,CAAC,aAAa,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC;;IAKpE;;;;;OAKG;IACH,YAAY,IAAI,aAAa,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE;CAG5C;AAED;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,aAAa,eAAsB,CAAC"}

package/dist/storage/cache/registry.js

@@ -0,0 +1,26 @@
+import "../../chunk-PTJYTZNU.js";
+import { StorageError } from "../errors.js";
+import { BaseRegistry } from "../../providers/base-registry.js";
+const cacheErrorFactory = {
+  alreadyRegistered: (type) => StorageError.cacheProviderAlreadyRegistered(type),
+  notFound: (type, availableTypes) => StorageError.unknownCacheProvider(type, availableTypes)
+};
+class CacheRegistry extends BaseRegistry {
+  constructor() {
+    super(cacheErrorFactory);
+  }
+  /**
+   * Get all registered providers.
+   * Alias for getAll() for backward compatibility.
+   *
+   * @returns Array of providers
+   */
+  getProviders() {
+    return this.getAll();
+  }
+}
+const cacheRegistry = new CacheRegistry();
+export {
+  CacheRegistry,
+  cacheRegistry
+};

package/dist/storage/cache/schemas.cjs

@@ -19,7 +19,9 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var schemas_exports = {};
 __export(schemas_exports, {
   CACHE_TYPES: () => CACHE_TYPES,
-  CacheConfigSchema: () => CacheConfigSchema
+  CacheConfigSchema: () => CacheConfigSchema,
+  InMemoryCacheSchema: () => InMemoryCacheSchema,
+  RedisCacheSchema: () => RedisCacheSchema
 });
 module.exports = __toCommonJS(schemas_exports);
 var import_zod = require("zod");
@@ -73,5 +75,7 @@ const CacheConfigSchema = import_zod.z.discriminatedUnion("type", [InMemoryCache
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   CACHE_TYPES,
-  CacheConfigSchema
+  CacheConfigSchema,
+  InMemoryCacheSchema,
+  RedisCacheSchema
 });

package/dist/storage/cache/schemas.d.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 export declare const CACHE_TYPES: readonly ["in-memory", "redis"];
 export type CacheType = (typeof CACHE_TYPES)[number];
-declare const InMemoryCacheSchema: z.ZodObject<{
+export declare const InMemoryCacheSchema: z.ZodObject<{
     maxConnections: z.ZodOptional<z.ZodNumber>;
     idleTimeoutMillis: z.ZodOptional<z.ZodNumber>;
     connectionTimeoutMillis: z.ZodOptional<z.ZodNumber>;
@@ -22,7 +22,7 @@ declare const InMemoryCacheSchema: z.ZodObject<{
     connectionTimeoutMillis?: number | undefined;
 }>;
 export type InMemoryCacheConfig = z.output<typeof InMemoryCacheSchema>;
-declare const RedisCacheSchema: z.ZodObject<{
+export declare const RedisCacheSchema: z.ZodObject<{
     maxConnections: z.ZodOptional<z.ZodNumber>;
     idleTimeoutMillis: z.ZodOptional<z.ZodNumber>;
     connectionTimeoutMillis: z.ZodOptional<z.ZodNumber>;
@@ -147,5 +147,4 @@ export declare const CacheConfigSchema: z.ZodEffects<z.ZodDiscriminatedUnion<"ty
     database?: number | undefined;
 }>;
 export type CacheConfig = z.output<typeof CacheConfigSchema>;
-export {};
 //# sourceMappingURL=schemas.d.ts.map

package/dist/storage/cache/schemas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../src/storage/cache/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,eAAO,MAAM,WAAW,iCAAkC,CAAC;AAC3D,MAAM,MAAM,SAAS,GAAG,CAAC,OAAO,WAAW,CAAC,CAAC,MAAM,CAAC,CAAC;AAoBrD,QAAA,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;EAGd,CAAC;AAEZ,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAGvE,QAAA,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAOX,CAAC;AAEZ,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAGjE,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4BxB,CAAC;AAEP,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,iBAAiB,CAAC,CAAC"}
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../src/storage/cache/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,eAAO,MAAM,WAAW,iCAAkC,CAAC;AAC3D,MAAM,MAAM,SAAS,GAAG,CAAC,OAAO,WAAW,CAAC,CAAC,MAAM,CAAC,CAAC;AAoBrD,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;EAGrB,CAAC;AAEZ,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAGvE,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAOlB,CAAC;AAEZ,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAGjE,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4BxB,CAAC;AAEP,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,iBAAiB,CAAC,CAAC"}

package/dist/storage/cache/schemas.js

@@ -49,5 +49,7 @@ const CacheConfigSchema = z.discriminatedUnion("type", [InMemoryCacheSchema, Red
 });
 export {
   CACHE_TYPES,
-  CacheConfigSchema
+  CacheConfigSchema,
+  InMemoryCacheSchema,
+  RedisCacheSchema
 };

package/dist/storage/database/factory.cjs

@@ -1,9 +1,7 @@
 "use strict";
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -17,59 +15,22 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var factory_exports = {};
 __export(factory_exports, {
   createDatabase: () => createDatabase
 });
 module.exports = __toCommonJS(factory_exports);
-var import_memory_database_store = require("./memory-database-store.js");
-var import_errors = require("../errors.js");
-let SQLiteStore = null;
-let PostgresStore = null;
+var import_registry = require("./registry.js");
 async function createDatabase(config, logger) {
-  switch (config.type) {
-    case "postgres":
-      return createPostgresStore(config, logger);
-    case "sqlite":
-      return createSQLiteStore(config, logger);
-    case "in-memory":
-    default:
-      logger.info("Using in-memory database store");
-      return new import_memory_database_store.MemoryDatabaseStore();
+  const validatedConfig = import_registry.databaseRegistry.validateConfig(config);
+  const provider = import_registry.databaseRegistry.get(validatedConfig.type);
+  if (!provider) {
+    throw new Error(`Provider '${validatedConfig.type}' not found in registry`);
   }
-}
-async function createPostgresStore(config, logger) {
-  try {
-    if (!PostgresStore) {
-      const module2 = await import("./postgres-store.js");
-      PostgresStore = module2.PostgresStore;
-    }
-    logger.info("Connecting to PostgreSQL database");
-    return new PostgresStore(config, logger);
-  } catch (error) {
-    const err = error;
-    if (err.code === "ERR_MODULE_NOT_FOUND") {
-      throw import_errors.StorageError.dependencyNotInstalled("PostgreSQL", "pg", "npm install pg");
-    }
-    throw error;
-  }
-}
-async function createSQLiteStore(config, logger) {
-  if (!SQLiteStore) {
-    const module2 = await import("./sqlite-store.js");
-    SQLiteStore = module2.SQLiteStore;
-  }
-  logger.info(`Creating SQLite database store: ${config.path}`);
-  return new SQLiteStore(config, logger);
+  const providerName = provider.metadata?.displayName || validatedConfig.type;
+  logger.info(`Using ${providerName} database`);
+  return provider.create(validatedConfig, logger);
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/storage/database/factory.d.ts

@@ -1,13 +1,39 @@
 import type { Database } from './types.js';
-import type { DatabaseConfig } from '../schemas.js';
 import type { IDextoLogger } from '../../logger/v2/types.js';
 /**
- * Create a database store based on configuration.
- * Handles lazy loading of optional dependencies.
- * Throws StorageError.dependencyNotInstalled if required package is missing.
- * Database paths are provided via CLI enrichment layer.
- * @param config Database configuration with explicit paths
- * @param logger Logger instance for logging
+ * Create a database based on configuration using the provider registry.
+ *
+ * This factory function:
+ * 1. Validates the configuration against the registered provider's schema
+ * 2. Looks up the provider in the registry
+ * 3. Calls the provider's create method to instantiate the database
+ *
+ * The configuration type is determined at runtime by the 'type' field,
+ * which must match a registered provider. Custom providers can be registered
+ * via databaseRegistry.register() before calling this function.
+ *
+ * Database paths are provided via CLI enrichment layer (for sqlite).
+ *
+ * @param config - Database configuration with a 'type' discriminator
+ * @param logger - Logger instance for the database
+ * @returns A Database implementation
+ * @throws Error if the provider type is not registered or validation fails
+ *
+ * @example
+ * ```typescript
+ * // Using built-in provider
+ * const db = await createDatabase({ type: 'sqlite', path: '/tmp/data.db' }, logger);
+ *
+ * // Using custom provider (registered beforehand)
+ * import { databaseRegistry } from '@dexto/core';
+ * import { mongoProvider } from './storage/mongo-provider.js';
+ *
+ * databaseRegistry.register(mongoProvider);
+ * const db = await createDatabase({ type: 'mongodb', uri: '...' }, logger);
+ * ```
  */
-export declare function createDatabase(config: DatabaseConfig, logger: IDextoLogger): Promise<Database>;
+export declare function createDatabase(config: {
+    type: string;
+    [key: string]: any;
+}, logger: IDextoLogger): Promise<Database>;
 //# sourceMappingURL=factory.d.ts.map

package/dist/storage/database/factory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../../src/storage/database/factory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAC3C,OAAO,KAAK,EAAE,cAAc,EAAgD,MAAM,eAAe,CAAC;AAElG,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAgB7D;;;;;;;GAOG;AACH,wBAAsB,cAAc,CAChC,MAAM,EAAE,cAAc,EACtB,MAAM,EAAE,YAAY,GACrB,OAAO,CAAC,QAAQ,CAAC,CAanB"}
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../../src/storage/database/factory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAC3C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAG7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAsB,cAAc,CAChC,MAAM,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;CAAE,EAC5C,MAAM,EAAE,YAAY,GACrB,OAAO,CAAC,QAAQ,CAAC,CAgBnB"}

package/dist/storage/database/factory.js

@@ -1,43 +1,14 @@
 import "../../chunk-PTJYTZNU.js";
-import { MemoryDatabaseStore } from "./memory-database-store.js";
-import { StorageError } from "../errors.js";
-let SQLiteStore = null;
-let PostgresStore = null;
+import { databaseRegistry } from "./registry.js";
 async function createDatabase(config, logger) {
-  switch (config.type) {
-    case "postgres":
-      return createPostgresStore(config, logger);
-    case "sqlite":
-      return createSQLiteStore(config, logger);
-    case "in-memory":
-    default:
-      logger.info("Using in-memory database store");
-      return new MemoryDatabaseStore();
+  const validatedConfig = databaseRegistry.validateConfig(config);
+  const provider = databaseRegistry.get(validatedConfig.type);
+  if (!provider) {
+    throw new Error(`Provider '${validatedConfig.type}' not found in registry`);
   }
-}
-async function createPostgresStore(config, logger) {
-  try {
-    if (!PostgresStore) {
-      const module = await import("./postgres-store.js");
-      PostgresStore = module.PostgresStore;
-    }
-    logger.info("Connecting to PostgreSQL database");
-    return new PostgresStore(config, logger);
-  } catch (error) {
-    const err = error;
-    if (err.code === "ERR_MODULE_NOT_FOUND") {
-      throw StorageError.dependencyNotInstalled("PostgreSQL", "pg", "npm install pg");
-    }
-    throw error;
-  }
-}
-async function createSQLiteStore(config, logger) {
-  if (!SQLiteStore) {
-    const module = await import("./sqlite-store.js");
-    SQLiteStore = module.SQLiteStore;
-  }
-  logger.info(`Creating SQLite database store: ${config.path}`);
-  return new SQLiteStore(config, logger);
+  const providerName = provider.metadata?.displayName || validatedConfig.type;
+  logger.info(`Using ${providerName} database`);
+  return provider.create(validatedConfig, logger);
 }
 export {
   createDatabase

package/dist/storage/database/index.cjs

@@ -0,0 +1,58 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var database_exports = {};
+__export(database_exports, {
+  DATABASE_TYPES: () => import_schemas.DATABASE_TYPES,
+  DatabaseConfigSchema: () => import_schemas.DatabaseConfigSchema,
+  DatabaseRegistry: () => import_registry2.DatabaseRegistry,
+  InMemoryDatabaseSchema: () => import_schemas.InMemoryDatabaseSchema,
+  MemoryDatabaseStore: () => import_memory_database_store.MemoryDatabaseStore,
+  PostgresDatabaseSchema: () => import_schemas.PostgresDatabaseSchema,
+  SqliteDatabaseSchema: () => import_schemas.SqliteDatabaseSchema,
+  createDatabase: () => import_factory.createDatabase,
+  databaseRegistry: () => import_registry2.databaseRegistry
+});
+module.exports = __toCommonJS(database_exports);
+var import_registry = require("./registry.js");
+var import_providers = require("./providers/index.js");
+var import_factory = require("./factory.js");
+var import_registry2 = require("./registry.js");
+var import_schemas = require("./schemas.js");
+var import_memory_database_store = require("./memory-database-store.js");
+if (!import_registry.databaseRegistry.has("in-memory")) {
+  import_registry.databaseRegistry.register(import_providers.inMemoryDatabaseProvider);
+}
+if (!import_registry.databaseRegistry.has("sqlite")) {
+  import_registry.databaseRegistry.register(import_providers.sqliteDatabaseProvider);
+}
+if (!import_registry.databaseRegistry.has("postgres")) {
+  import_registry.databaseRegistry.register(import_providers.postgresDatabaseProvider);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DATABASE_TYPES,
+  DatabaseConfigSchema,
+  DatabaseRegistry,
+  InMemoryDatabaseSchema,
+  MemoryDatabaseStore,
+  PostgresDatabaseSchema,
+  SqliteDatabaseSchema,
+  createDatabase,
+  databaseRegistry
+});

package/dist/storage/database/index.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Database Module
+ *
+ * This module provides a flexible database system with support for
+ * multiple backends through a provider pattern.
+ *
+ * ## Built-in Providers
+ * - `in-memory`: Store data in RAM (for testing/development)
+ * - `sqlite`: Store data in a local SQLite file
+ * - `postgres`: Store data in PostgreSQL server
+ *
+ * ## Custom Providers
+ * Custom providers (e.g., MongoDB, DynamoDB) can be registered at the
+ * CLI/server layer before configuration loading.
+ *
+ * ## Usage
+ *
+ * ### Using built-in providers
+ * ```typescript
+ * import { createDatabase } from '@dexto/core';
+ *
+ * const db = await createDatabase({ type: 'sqlite', path: '/tmp/data.db' }, logger);
+ * ```
+ *
+ * ### Registering custom providers
+ * ```typescript
+ * import { databaseRegistry, type DatabaseProvider } from '@dexto/core';
+ *
+ * const mongoProvider: DatabaseProvider<'mongodb', MongoConfig> = {
+ *   type: 'mongodb',
+ *   configSchema: MongoConfigSchema,
+ *   create: (config, logger) => new MongoDatabase(config, logger),
+ * };
+ *
+ * databaseRegistry.register(mongoProvider);
+ * const db = await createDatabase({ type: 'mongodb', uri: '...' }, logger);
+ * ```
+ */
+export { createDatabase } from './factory.js';
+export { databaseRegistry, DatabaseRegistry } from './registry.js';
+export type { DatabaseProvider } from './provider.js';
+export type { Database } from './types.js';
+export { DATABASE_TYPES, DatabaseConfigSchema, InMemoryDatabaseSchema, SqliteDatabaseSchema, PostgresDatabaseSchema, type DatabaseType, type DatabaseConfig, type InMemoryDatabaseConfig, type SqliteDatabaseConfig, type PostgresDatabaseConfig, } from './schemas.js';
+export { MemoryDatabaseStore } from './memory-database-store.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/storage/database/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/storage/database/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AAwBH,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AACnE,YAAY,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAGtD,YAAY,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAG3C,OAAO,EACH,cAAc,EACd,oBAAoB,EACpB,sBAAsB,EACtB,oBAAoB,EACpB,sBAAsB,EACtB,KAAK,YAAY,EACjB,KAAK,cAAc,EACnB,KAAK,sBAAsB,EAC3B,KAAK,oBAAoB,EACzB,KAAK,sBAAsB,GAC9B,MAAM,cAAc,CAAC;AAGtB,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC"}

package/dist/storage/database/index.js

@@ -0,0 +1,37 @@
+import "../../chunk-PTJYTZNU.js";
+import { databaseRegistry } from "./registry.js";
+import {
+  inMemoryDatabaseProvider,
+  sqliteDatabaseProvider,
+  postgresDatabaseProvider
+} from "./providers/index.js";
+if (!databaseRegistry.has("in-memory")) {
+  databaseRegistry.register(inMemoryDatabaseProvider);
+}
+if (!databaseRegistry.has("sqlite")) {
+  databaseRegistry.register(sqliteDatabaseProvider);
+}
+if (!databaseRegistry.has("postgres")) {
+  databaseRegistry.register(postgresDatabaseProvider);
+}
+import { createDatabase } from "./factory.js";
+import { databaseRegistry as databaseRegistry2, DatabaseRegistry } from "./registry.js";
+import {
+  DATABASE_TYPES,
+  DatabaseConfigSchema,
+  InMemoryDatabaseSchema,
+  SqliteDatabaseSchema,
+  PostgresDatabaseSchema
+} from "./schemas.js";
+import { MemoryDatabaseStore } from "./memory-database-store.js";
+export {
+  DATABASE_TYPES,
+  DatabaseConfigSchema,
+  DatabaseRegistry,
+  InMemoryDatabaseSchema,
+  MemoryDatabaseStore,
+  PostgresDatabaseSchema,
+  SqliteDatabaseSchema,
+  createDatabase,
+  databaseRegistry2 as databaseRegistry
+};