@dexto/core 1.5.8 → 1.6.1

package/dist/storage/cache/redis-store.d.ts

@@ -1,32 +0,0 @@
-import type { Cache } from './types.js';
-import type { RedisCacheConfig } from './schemas.js';
-import type { IDextoLogger } from '../../logger/v2/types.js';
-/**
- * Redis cache store for production cache operations.
- * Implements the Cache interface with connection pooling and optimizations.
- * EXPERIMENTAL - NOT FULLY TESTED YET
- */
-export declare class RedisStore implements Cache {
-    private config;
-    private redis;
-    private connected;
-    private logger;
-    constructor(config: RedisCacheConfig, logger: IDextoLogger);
-    connect(): Promise<void>;
-    disconnect(): Promise<void>;
-    isConnected(): boolean;
-    getStoreType(): string;
-    get<T>(key: string): Promise<T | undefined>;
-    set<T>(key: string, value: T, ttlSeconds?: number): Promise<void>;
-    delete(key: string): Promise<void>;
-    mget<T>(keys: string[]): Promise<(T | undefined)[]>;
-    mset<T>(entries: [string, T][]): Promise<void>;
-    exists(key: string): Promise<boolean>;
-    expire(key: string, ttlSeconds: number): Promise<void>;
-    increment(key: string, by?: number): Promise<number>;
-    decrement(key: string, by?: number): Promise<number>;
-    private checkConnection;
-    flushdb(): Promise<void>;
-    info(): Promise<string>;
-}
-//# sourceMappingURL=redis-store.d.ts.map

package/dist/storage/cache/redis-store.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"redis-store.d.ts","sourceRoot":"","sources":["../../../src/storage/cache/redis-store.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACxC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AACrD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAI7D;;;;GAIG;AACH,qBAAa,UAAW,YAAW,KAAK;IAMhC,OAAO,CAAC,MAAM;IALlB,OAAO,CAAC,KAAK,CAAsB;IACnC,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,MAAM,CAAe;gBAGjB,MAAM,EAAE,gBAAgB,EAChC,MAAM,EAAE,YAAY;IAKlB,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAoCxB,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAQjC,WAAW,IAAI,OAAO;IAItB,YAAY,IAAI,MAAM;IAKhB,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC;IAc3C,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAmBjE,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAclC,IAAI,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,EAAE,CAAC;IAQnD,IAAI,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,MAAM,EAAE,CAAC,CAAC,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAW9C,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAMrC,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAMtD,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE,GAAE,MAAU,GAAG,OAAO,CAAC,MAAM,CAAC;IAKvD,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE,GAAE,MAAU,GAAG,OAAO,CAAC,MAAM,CAAC;IAK7D,OAAO,CAAC,eAAe;IAOjB,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAKxB,IAAI,IAAI,OAAO,CAAC,MAAM,CAAC;CAIhC"}

package/dist/storage/cache/redis-store.js

@@ -1,150 +0,0 @@
-import "../../chunk-PTJYTZNU.js";
-import { Redis } from "ioredis";
-import { DextoLogComponent } from "../../logger/v2/types.js";
-import { StorageError } from "../errors.js";
-class RedisStore {
-  constructor(config, logger) {
-    this.config = config;
-    this.logger = logger.createChild(DextoLogComponent.STORAGE);
-  }
-  redis = null;
-  connected = false;
-  logger;
-  async connect() {
-    if (this.connected) return;
-    this.redis = new Redis({
-      ...this.config.host && { host: this.config.host },
-      ...this.config.port && { port: this.config.port },
-      ...this.config.password && { password: this.config.password },
-      db: this.config.database || 0,
-      family: 4,
-      // IPv4 by default
-      ...this.config.connectionTimeoutMillis && {
-        connectTimeout: this.config.connectionTimeoutMillis
-      },
-      ...this.config.connectionTimeoutMillis && {
-        commandTimeout: this.config.connectionTimeoutMillis
-      },
-      maxRetriesPerRequest: 3,
-      lazyConnect: true,
-      ...this.config.options
-    });
-    this.redis.on("error", (error) => {
-      console.error("Redis connection error:", error);
-    });
-    this.redis.on("connect", () => {
-      this.connected = true;
-    });
-    this.redis.on("close", () => {
-      this.connected = false;
-    });
-    await this.redis.connect();
-  }
-  async disconnect() {
-    if (this.redis) {
-      await this.redis.quit();
-      this.redis = null;
-    }
-    this.connected = false;
-  }
-  isConnected() {
-    return this.connected && this.redis?.status === "ready";
-  }
-  getStoreType() {
-    return "redis";
-  }
-  // Core operations
-  async get(key) {
-    this.checkConnection();
-    try {
-      const value = await this.redis.get(key);
-      return value ? JSON.parse(value) : void 0;
-    } catch (error) {
-      throw StorageError.readFailed(
-        "get",
-        error instanceof Error ? error.message : String(error),
-        { key }
-      );
-    }
-  }
-  async set(key, value, ttlSeconds) {
-    this.checkConnection();
-    try {
-      const serialized = JSON.stringify(value);
-      if (ttlSeconds) {
-        await this.redis.setex(key, ttlSeconds, serialized);
-      } else {
-        await this.redis.set(key, serialized);
-      }
-    } catch (error) {
-      throw StorageError.writeFailed(
-        "set",
-        error instanceof Error ? error.message : String(error),
-        { key }
-      );
-    }
-  }
-  async delete(key) {
-    this.checkConnection();
-    try {
-      await this.redis.del(key);
-    } catch (error) {
-      throw StorageError.deleteFailed(
-        "delete",
-        error instanceof Error ? error.message : String(error),
-        { key }
-      );
-    }
-  }
-  // Redis-specific optimizations
-  async mget(keys) {
-    this.checkConnection();
-    if (keys.length === 0) return [];
-    const values = await this.redis.mget(...keys);
-    return values.map((value) => value ? JSON.parse(value) : void 0);
-  }
-  async mset(entries) {
-    this.checkConnection();
-    if (entries.length === 0) return;
-    const pipeline = this.redis.pipeline();
-    for (const [key, value] of entries) {
-      pipeline.set(key, JSON.stringify(value));
-    }
-    await pipeline.exec();
-  }
-  async exists(key) {
-    this.checkConnection();
-    const result = await this.redis.exists(key);
-    return result === 1;
-  }
-  async expire(key, ttlSeconds) {
-    this.checkConnection();
-    await this.redis.expire(key, ttlSeconds);
-  }
-  // Cache-specific operations
-  async increment(key, by = 1) {
-    this.checkConnection();
-    return await this.redis.incrby(key, by);
-  }
-  async decrement(key, by = 1) {
-    this.checkConnection();
-    return await this.redis.decrby(key, by);
-  }
-  checkConnection() {
-    if (!this.connected || !this.redis || this.redis.status !== "ready") {
-      throw StorageError.notConnected("RedisStore");
-    }
-  }
-  // Maintenance operations
-  async flushdb() {
-    this.checkConnection();
-    await this.redis.flushdb();
-  }
-  async info() {
-    this.checkConnection();
-    return await this.redis.info();
-  }
-}
-export {
-  RedisStore
-};

package/dist/storage/cache/registry.cjs

@@ -1,50 +0,0 @@
-"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

@@ -1,42 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,26 +0,0 @@
-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

@@ -1,81 +0,0 @@
-"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 schemas_exports = {};
-__export(schemas_exports, {
-  CACHE_TYPES: () => CACHE_TYPES,
-  CacheConfigSchema: () => CacheConfigSchema,
-  InMemoryCacheSchema: () => InMemoryCacheSchema,
-  RedisCacheSchema: () => RedisCacheSchema
-});
-module.exports = __toCommonJS(schemas_exports);
-var import_zod = require("zod");
-var import_result = require("../../utils/result.cjs");
-var import_error_codes = require("../error-codes.js");
-var import_types = require("../../errors/types.cjs");
-const CACHE_TYPES = ["in-memory", "redis"];
-const BaseCacheSchema = import_zod.z.object({
-  maxConnections: import_zod.z.number().int().positive().optional().describe("Maximum connections"),
-  idleTimeoutMillis: import_zod.z.number().int().positive().optional().describe("Idle timeout in milliseconds"),
-  connectionTimeoutMillis: import_zod.z.number().int().positive().optional().describe("Connection timeout in milliseconds"),
-  options: import_zod.z.record(import_zod.z.any()).optional().describe("Backend-specific options")
-});
-const InMemoryCacheSchema = BaseCacheSchema.extend({
-  type: import_zod.z.literal("in-memory")
-  // In-memory cache doesn't need connection options, but inherits pool options for consistency
-}).strict();
-const RedisCacheSchema = BaseCacheSchema.extend({
-  type: import_zod.z.literal("redis"),
-  url: (0, import_result.EnvExpandedString)().optional().describe("Redis connection URL (redis://...)"),
-  host: import_zod.z.string().optional().describe("Redis host"),
-  port: import_zod.z.number().int().positive().optional().describe("Redis port"),
-  password: import_zod.z.string().optional().describe("Redis password"),
-  database: import_zod.z.number().int().nonnegative().optional().describe("Redis database number")
-}).strict();
-const CacheConfigSchema = import_zod.z.discriminatedUnion("type", [InMemoryCacheSchema, RedisCacheSchema], {
-  errorMap: (issue, ctx) => {
-    if (issue.code === import_zod.z.ZodIssueCode.invalid_union_discriminator) {
-      return {
-        message: `Invalid cache type. Expected 'in-memory' or 'redis'.`
-      };
-    }
-    return { message: ctx.defaultError };
-  }
-}).describe("Cache configuration").superRefine((data, ctx) => {
-  if (data.type === "redis") {
-    if (!data.url && !data.host) {
-      ctx.addIssue({
-        code: import_zod.z.ZodIssueCode.custom,
-        message: "Redis cache requires either 'url' or 'host' to be specified",
-        path: ["url"],
-        params: {
-          code: import_error_codes.StorageErrorCode.CONNECTION_CONFIG_MISSING,
-          scope: import_types.ErrorScope.STORAGE,
-          type: import_types.ErrorType.USER
-        }
-      });
-    }
-  }
-});
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  CACHE_TYPES,
-  CacheConfigSchema,
-  InMemoryCacheSchema,
-  RedisCacheSchema
-});

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

@@ -1,150 +0,0 @@
-import { z } from 'zod';
-export declare const CACHE_TYPES: readonly ["in-memory", "redis"];
-export type CacheType = (typeof CACHE_TYPES)[number];
-export declare const InMemoryCacheSchema: z.ZodObject<{
-    maxConnections: z.ZodOptional<z.ZodNumber>;
-    idleTimeoutMillis: z.ZodOptional<z.ZodNumber>;
-    connectionTimeoutMillis: z.ZodOptional<z.ZodNumber>;
-    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
-} & {
-    type: z.ZodLiteral<"in-memory">;
-}, "strict", z.ZodTypeAny, {
-    type: "in-memory";
-    options?: Record<string, any> | undefined;
-    maxConnections?: number | undefined;
-    idleTimeoutMillis?: number | undefined;
-    connectionTimeoutMillis?: number | undefined;
-}, {
-    type: "in-memory";
-    options?: Record<string, any> | undefined;
-    maxConnections?: number | undefined;
-    idleTimeoutMillis?: number | undefined;
-    connectionTimeoutMillis?: number | undefined;
-}>;
-export type InMemoryCacheConfig = z.output<typeof InMemoryCacheSchema>;
-export declare const RedisCacheSchema: z.ZodObject<{
-    maxConnections: z.ZodOptional<z.ZodNumber>;
-    idleTimeoutMillis: z.ZodOptional<z.ZodNumber>;
-    connectionTimeoutMillis: z.ZodOptional<z.ZodNumber>;
-    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
-} & {
-    type: z.ZodLiteral<"redis">;
-    url: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
-    host: z.ZodOptional<z.ZodString>;
-    port: z.ZodOptional<z.ZodNumber>;
-    password: z.ZodOptional<z.ZodString>;
-    database: z.ZodOptional<z.ZodNumber>;
-}, "strict", z.ZodTypeAny, {
-    type: "redis";
-    password?: string | undefined;
-    options?: Record<string, any> | undefined;
-    url?: string | undefined;
-    maxConnections?: number | undefined;
-    idleTimeoutMillis?: number | undefined;
-    connectionTimeoutMillis?: number | undefined;
-    host?: string | undefined;
-    port?: number | undefined;
-    database?: number | undefined;
-}, {
-    type: "redis";
-    password?: string | undefined;
-    options?: Record<string, any> | undefined;
-    url?: string | undefined;
-    maxConnections?: number | undefined;
-    idleTimeoutMillis?: number | undefined;
-    connectionTimeoutMillis?: number | undefined;
-    host?: string | undefined;
-    port?: number | undefined;
-    database?: number | undefined;
-}>;
-export type RedisCacheConfig = z.output<typeof RedisCacheSchema>;
-export declare const CacheConfigSchema: z.ZodEffects<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
-    maxConnections: z.ZodOptional<z.ZodNumber>;
-    idleTimeoutMillis: z.ZodOptional<z.ZodNumber>;
-    connectionTimeoutMillis: z.ZodOptional<z.ZodNumber>;
-    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
-} & {
-    type: z.ZodLiteral<"in-memory">;
-}, "strict", z.ZodTypeAny, {
-    type: "in-memory";
-    options?: Record<string, any> | undefined;
-    maxConnections?: number | undefined;
-    idleTimeoutMillis?: number | undefined;
-    connectionTimeoutMillis?: number | undefined;
-}, {
-    type: "in-memory";
-    options?: Record<string, any> | undefined;
-    maxConnections?: number | undefined;
-    idleTimeoutMillis?: number | undefined;
-    connectionTimeoutMillis?: number | undefined;
-}>, z.ZodObject<{
-    maxConnections: z.ZodOptional<z.ZodNumber>;
-    idleTimeoutMillis: z.ZodOptional<z.ZodNumber>;
-    connectionTimeoutMillis: z.ZodOptional<z.ZodNumber>;
-    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
-} & {
-    type: z.ZodLiteral<"redis">;
-    url: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
-    host: z.ZodOptional<z.ZodString>;
-    port: z.ZodOptional<z.ZodNumber>;
-    password: z.ZodOptional<z.ZodString>;
-    database: z.ZodOptional<z.ZodNumber>;
-}, "strict", z.ZodTypeAny, {
-    type: "redis";
-    password?: string | undefined;
-    options?: Record<string, any> | undefined;
-    url?: string | undefined;
-    maxConnections?: number | undefined;
-    idleTimeoutMillis?: number | undefined;
-    connectionTimeoutMillis?: number | undefined;
-    host?: string | undefined;
-    port?: number | undefined;
-    database?: number | undefined;
-}, {
-    type: "redis";
-    password?: string | undefined;
-    options?: Record<string, any> | undefined;
-    url?: string | undefined;
-    maxConnections?: number | undefined;
-    idleTimeoutMillis?: number | undefined;
-    connectionTimeoutMillis?: number | undefined;
-    host?: string | undefined;
-    port?: number | undefined;
-    database?: number | undefined;
-}>]>, {
-    type: "in-memory";
-    options?: Record<string, any> | undefined;
-    maxConnections?: number | undefined;
-    idleTimeoutMillis?: number | undefined;
-    connectionTimeoutMillis?: number | undefined;
-} | {
-    type: "redis";
-    password?: string | undefined;
-    options?: Record<string, any> | undefined;
-    url?: string | undefined;
-    maxConnections?: number | undefined;
-    idleTimeoutMillis?: number | undefined;
-    connectionTimeoutMillis?: number | undefined;
-    host?: string | undefined;
-    port?: number | undefined;
-    database?: number | undefined;
-}, {
-    type: "in-memory";
-    options?: Record<string, any> | undefined;
-    maxConnections?: number | undefined;
-    idleTimeoutMillis?: number | undefined;
-    connectionTimeoutMillis?: number | undefined;
-} | {
-    type: "redis";
-    password?: string | undefined;
-    options?: Record<string, any> | undefined;
-    url?: string | undefined;
-    maxConnections?: number | undefined;
-    idleTimeoutMillis?: number | undefined;
-    connectionTimeoutMillis?: number | undefined;
-    host?: string | undefined;
-    port?: number | undefined;
-    database?: number | undefined;
-}>;
-export type CacheConfig = z.output<typeof CacheConfigSchema>;
-//# sourceMappingURL=schemas.d.ts.map

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

@@ -1 +0,0 @@
-{"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

@@ -1,55 +0,0 @@
-import "../../chunk-PTJYTZNU.js";
-import { z } from "zod";
-import { EnvExpandedString } from "../../utils/result.js";
-import { StorageErrorCode } from "../error-codes.js";
-import { ErrorScope, ErrorType } from "../../errors/types.js";
-const CACHE_TYPES = ["in-memory", "redis"];
-const BaseCacheSchema = z.object({
-  maxConnections: z.number().int().positive().optional().describe("Maximum connections"),
-  idleTimeoutMillis: z.number().int().positive().optional().describe("Idle timeout in milliseconds"),
-  connectionTimeoutMillis: z.number().int().positive().optional().describe("Connection timeout in milliseconds"),
-  options: z.record(z.any()).optional().describe("Backend-specific options")
-});
-const InMemoryCacheSchema = BaseCacheSchema.extend({
-  type: z.literal("in-memory")
-  // In-memory cache doesn't need connection options, but inherits pool options for consistency
-}).strict();
-const RedisCacheSchema = BaseCacheSchema.extend({
-  type: z.literal("redis"),
-  url: EnvExpandedString().optional().describe("Redis connection URL (redis://...)"),
-  host: z.string().optional().describe("Redis host"),
-  port: z.number().int().positive().optional().describe("Redis port"),
-  password: z.string().optional().describe("Redis password"),
-  database: z.number().int().nonnegative().optional().describe("Redis database number")
-}).strict();
-const CacheConfigSchema = z.discriminatedUnion("type", [InMemoryCacheSchema, RedisCacheSchema], {
-  errorMap: (issue, ctx) => {
-    if (issue.code === z.ZodIssueCode.invalid_union_discriminator) {
-      return {
-        message: `Invalid cache type. Expected 'in-memory' or 'redis'.`
-      };
-    }
-    return { message: ctx.defaultError };
-  }
-}).describe("Cache configuration").superRefine((data, ctx) => {
-  if (data.type === "redis") {
-    if (!data.url && !data.host) {
-      ctx.addIssue({
-        code: z.ZodIssueCode.custom,
-        message: "Redis cache requires either 'url' or 'host' to be specified",
-        path: ["url"],
-        params: {
-          code: StorageErrorCode.CONNECTION_CONFIG_MISSING,
-          scope: ErrorScope.STORAGE,
-          type: ErrorType.USER
-        }
-      });
-    }
-  }
-});
-export {
-  CACHE_TYPES,
-  CacheConfigSchema,
-  InMemoryCacheSchema,
-  RedisCacheSchema
-};

package/dist/storage/database/factory.cjs

@@ -1,38 +0,0 @@
-"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 factory_exports = {};
-__export(factory_exports, {
-  createDatabase: () => createDatabase
-});
-module.exports = __toCommonJS(factory_exports);
-var import_registry = require("./registry.js");
-async function createDatabase(config, logger) {
-  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`);
-  }
-  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 = {
-  createDatabase
-});

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

@@ -1,39 +0,0 @@
-import type { Database } from './types.js';
-import type { IDextoLogger } from '../../logger/v2/types.js';
-/**
- * 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: {
-    type: string;
-    [key: string]: any;
-}, logger: IDextoLogger): Promise<Database>;
-//# sourceMappingURL=factory.d.ts.map