@dexto/core 1.1.10 → 1.2.0

package/dist/storage/index.d.ts

@@ -1,7 +1,48 @@
-export { StorageManager, createStorageBackends } from './storage-manager.js';
-export { StorageBackends } from './backend/types.js';
-export { MemoryBackend } from './backend/memory-backend.js';
-export { CacheBackend } from './backend/cache-backend.js';
-export { DatabaseBackend } from './backend/database-backend.js';
-export { BackendConfig, StorageConfig, ValidatedStorageConfig } from './schemas.js';
-import 'zod';
+/**
+ * Dexto Storage Layer
+ *
+ * A storage system with two storage types:
+ * - Cache: Fast, ephemeral storage (Redis, Memory) with TTL support
+ * - Database: Persistent, reliable storage (PostgreSQL, SQLite, Memory) with list operations
+ *
+ * Usage:
+ *
+ * ```typescript
+ * // Create and initialize a storage manager
+ * const manager = await createStorageManager({
+ *   cache: { type: 'in-memory' },
+ *   database: { type: 'in-memory' }
+ * });
+ *
+ * // Access cache and database via getters
+ * const cache = manager.getCache();
+ * const database = manager.getDatabase();
+ *
+ * // Use cache for temporary data
+ * await cache.set('session:123', sessionData, 3600); // 1 hour TTL
+ * const sessionData = await cache.get('session:123');
+ *
+ * // Use database for persistent data
+ * await database.set('user:456', userData);
+ * await database.append('messages:789', message);
+ * const messages = await database.getRange('messages:789', 0, 50);
+ *
+ * // Cleanup when done
+ * await manager.disconnect();
+ * ```
+ */
+export { StorageManager, createStorageManager } from './storage-manager.js';
+export type { Cache } from './cache/types.js';
+export type { Database } from './database/types.js';
+export type { StorageConfig, ValidatedStorageConfig } from './schemas.js';
+export { MemoryCacheStore } from './cache/memory-cache-store.js';
+export { MemoryDatabaseStore } from './database/memory-database-store.js';
+export { CACHE_TYPES, DATABASE_TYPES, BLOB_STORE_TYPES } from './schemas.js';
+export type { CacheType, DatabaseType, BlobStoreType } from './schemas.js';
+export { CacheConfigSchema, DatabaseConfigSchema, BlobStoreConfigSchema, StorageSchema, } from './schemas.js';
+export type { BlobStore } from './blob/types.js';
+export type { BlobInput, BlobMetadata, StoredBlobMetadata, BlobReference, BlobData, BlobStats, } from './blob/types.js';
+export type { BlobStoreConfig, InMemoryBlobStoreConfig, LocalBlobStoreConfig } from './schemas.js';
+export type { CacheConfig, InMemoryCacheConfig, RedisCacheConfig } from './schemas.js';
+export type { DatabaseConfig, InMemoryDatabaseConfig, SqliteDatabaseConfig, PostgresDatabaseConfig, } from './schemas.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/storage/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAGH,OAAO,EAAE,cAAc,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAG5E,YAAY,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAC9C,YAAY,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAGpD,YAAY,EAAE,aAAa,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAC;AAG1E,OAAO,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AACjE,OAAO,EAAE,mBAAmB,EAAE,MAAM,qCAAqC,CAAC;AAG1E,OAAO,EAAE,WAAW,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAC7E,YAAY,EAAE,SAAS,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAC3E,OAAO,EACH,iBAAiB,EACjB,oBAAoB,EACpB,qBAAqB,EACrB,aAAa,GAChB,MAAM,cAAc,CAAC;AAGtB,YAAY,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AACjD,YAAY,EACR,SAAS,EACT,YAAY,EACZ,kBAAkB,EAClB,aAAa,EACb,QAAQ,EACR,SAAS,GACZ,MAAM,iBAAiB,CAAC;AAGzB,YAAY,EAAE,eAAe,EAAE,uBAAuB,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC;AAGnG,YAAY,EAAE,WAAW,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAGvF,YAAY,EACR,cAAc,EACd,sBAAsB,EACtB,oBAAoB,EACpB,sBAAsB,GACzB,MAAM,cAAc,CAAC"}

package/dist/storage/index.js

@@ -1,7 +1,24 @@
-import { StorageManager, createStorageBackends } from "./storage-manager.js";
-import { MemoryBackend } from "./backend/memory-backend.js";
+import "../chunk-C6A6W6XS.js";
+import { StorageManager, createStorageManager } from "./storage-manager.js";
+import { MemoryCacheStore } from "./cache/memory-cache-store.js";
+import { MemoryDatabaseStore } from "./database/memory-database-store.js";
+import { CACHE_TYPES, DATABASE_TYPES, BLOB_STORE_TYPES } from "./schemas.js";
+import {
+  CacheConfigSchema,
+  DatabaseConfigSchema,
+  BlobStoreConfigSchema,
+  StorageSchema
+} from "./schemas.js";
 export {
-  MemoryBackend,
+  BLOB_STORE_TYPES,
+  BlobStoreConfigSchema,
+  CACHE_TYPES,
+  CacheConfigSchema,
+  DATABASE_TYPES,
+  DatabaseConfigSchema,
+  MemoryCacheStore,
+  MemoryDatabaseStore,
   StorageManager,
-  createStorageBackends
+  StorageSchema,
+  createStorageManager
 };

package/dist/storage/schemas.cjs

@@ -18,96 +18,34 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var schemas_exports = {};
 __export(schemas_exports, {
+  BLOB_STORE_TYPES: () => import_schemas3.BLOB_STORE_TYPES,
+  BlobStoreConfigSchema: () => import_schemas3.BlobStoreConfigSchema,
+  CACHE_TYPES: () => import_schemas.CACHE_TYPES,
+  CacheConfigSchema: () => import_schemas.CacheConfigSchema,
+  DATABASE_TYPES: () => import_schemas2.DATABASE_TYPES,
+  DatabaseConfigSchema: () => import_schemas2.DatabaseConfigSchema,
   StorageSchema: () => StorageSchema
 });
 module.exports = __toCommonJS(schemas_exports);
 var import_zod = require("zod");
-var import_error_codes = require("./error-codes.js");
-var import_types = require("../errors/types.cjs");
-const BaseBackendSchema = 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 InMemoryBackendSchema = BaseBackendSchema.extend({
-  type: import_zod.z.literal("in-memory")
-  // In-memory backend doesn't need connection options, but inherits pool options for consistency
-}).strict();
-const RedisBackendSchema = BaseBackendSchema.extend({
-  type: import_zod.z.literal("redis"),
-  url: import_zod.z.string().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 SqliteBackendSchema = BaseBackendSchema.extend({
-  type: import_zod.z.literal("sqlite"),
-  path: import_zod.z.string().optional().describe(
-    "SQLite database file path (optional, will auto-detect using path resolver if not provided)"
-  ),
-  database: import_zod.z.string().optional().describe("Database filename (default: dexto.db)")
-}).strict();
-const PostgresBackendSchema = BaseBackendSchema.extend({
-  type: import_zod.z.literal("postgres"),
-  url: import_zod.z.string().optional().describe("PostgreSQL connection URL (postgresql://...)"),
-  connectionString: import_zod.z.string().optional().describe("PostgreSQL connection string"),
-  host: import_zod.z.string().optional().describe("PostgreSQL host"),
-  port: import_zod.z.number().int().positive().optional().describe("PostgreSQL port"),
-  database: import_zod.z.string().optional().describe("PostgreSQL database name"),
-  password: import_zod.z.string().optional().describe("PostgreSQL password")
-}).strict();
-const BackendConfigSchema = import_zod.z.discriminatedUnion(
-  "type",
-  [InMemoryBackendSchema, RedisBackendSchema, SqliteBackendSchema, PostgresBackendSchema],
-  {
-    errorMap: (issue, ctx) => {
-      if (issue.code === import_zod.z.ZodIssueCode.invalid_union_discriminator) {
-        return {
-          message: `Invalid backend type. Expected 'in-memory', 'redis', 'sqlite', or 'postgres'.`
-        };
-      }
-      return { message: ctx.defaultError };
-    }
-  }
-).describe("Backend configuration for storage system").superRefine((data, ctx) => {
-  if (data.type === "redis") {
-    if (!data.url && !data.host) {
-      ctx.addIssue({
-        code: import_zod.z.ZodIssueCode.custom,
-        message: "Redis backend 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
-        }
-      });
-    }
-  }
-  if (data.type === "postgres") {
-    if (!data.url && !data.connectionString && !data.host) {
-      ctx.addIssue({
-        code: import_zod.z.ZodIssueCode.custom,
-        message: "PostgreSQL backend requires one of 'url', 'connectionString', 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
-        }
-      });
-    }
-  }
-});
+var import_schemas = require("./cache/schemas.js");
+var import_schemas2 = require("./database/schemas.js");
+var import_schemas3 = require("./blob/schemas.js");
+var import_schemas4 = require("./cache/schemas.js");
+var import_schemas5 = require("./database/schemas.js");
+var import_schemas6 = require("./blob/schemas.js");
 const StorageSchema = import_zod.z.object({
-  cache: BackendConfigSchema.describe("Cache backend configuration (fast, ephemeral)"),
-  database: BackendConfigSchema.describe(
-    "Database backend configuration (persistent, reliable)"
-  )
-}).strict().describe("Storage configuration with cache and database backends").brand();
+  cache: import_schemas4.CacheConfigSchema.describe("Cache configuration (fast, ephemeral)"),
+  database: import_schemas5.DatabaseConfigSchema.describe("Database configuration (persistent, reliable)"),
+  blob: import_schemas6.BlobStoreConfigSchema.optional().default({ type: "local" }).describe("Blob store configuration (for large, unstructured data)")
+}).strict().describe("Storage configuration with cache, database, and blob store").brand();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  BLOB_STORE_TYPES,
+  BlobStoreConfigSchema,
+  CACHE_TYPES,
+  CacheConfigSchema,
+  DATABASE_TYPES,
+  DatabaseConfigSchema,
   StorageSchema
 });