@dexto/storage 1.6.0

package/dist/index.cjs

@@ -0,0 +1,82 @@
+"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 index_exports = {};
+__export(index_exports, {
+  BLOB_STORE_TYPES: () => import_schemas.BLOB_STORE_TYPES,
+  BlobStoreConfigSchema: () => import_schemas.BlobStoreConfigSchema,
+  CACHE_TYPES: () => import_schemas.CACHE_TYPES,
+  CacheConfigSchema: () => import_schemas.CacheConfigSchema,
+  DATABASE_TYPES: () => import_schemas.DATABASE_TYPES,
+  DatabaseConfigSchema: () => import_schemas.DatabaseConfigSchema,
+  InMemoryBlobStoreSchema: () => import_schemas.InMemoryBlobStoreSchema,
+  LocalBlobStore: () => import_local_blob_store.LocalBlobStore,
+  LocalBlobStoreSchema: () => import_schemas.LocalBlobStoreSchema,
+  MemoryBlobStore: () => import_memory_blob_store.MemoryBlobStore,
+  MemoryCacheStore: () => import_memory_cache_store.MemoryCacheStore,
+  MemoryDatabaseStore: () => import_memory_database_store.MemoryDatabaseStore,
+  PostgresStore: () => import_postgres_store.PostgresStore,
+  RedisStore: () => import_redis_store.RedisStore,
+  SQLiteStore: () => import_sqlite_store.SQLiteStore,
+  StorageSchema: () => import_schemas.StorageSchema,
+  inMemoryBlobStoreFactory: () => import_factories3.inMemoryBlobStoreFactory,
+  inMemoryCacheFactory: () => import_factories.inMemoryCacheFactory,
+  inMemoryDatabaseFactory: () => import_factories2.inMemoryDatabaseFactory,
+  localBlobStoreFactory: () => import_factories3.localBlobStoreFactory,
+  postgresDatabaseFactory: () => import_factories2.postgresDatabaseFactory,
+  redisCacheFactory: () => import_factories.redisCacheFactory,
+  sqliteDatabaseFactory: () => import_factories2.sqliteDatabaseFactory
+});
+module.exports = __toCommonJS(index_exports);
+var import_schemas = require("./schemas.js");
+var import_factories = require("./cache/factories/index.js");
+var import_memory_cache_store = require("./cache/memory-cache-store.js");
+var import_redis_store = require("./cache/redis-store.js");
+var import_factories2 = require("./database/factories/index.js");
+var import_memory_database_store = require("./database/memory-database-store.js");
+var import_sqlite_store = require("./database/sqlite-store.js");
+var import_postgres_store = require("./database/postgres-store.js");
+var import_factories3 = require("./blob/factories/index.js");
+var import_local_blob_store = require("./blob/local-blob-store.js");
+var import_memory_blob_store = require("./blob/memory-blob-store.js");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BLOB_STORE_TYPES,
+  BlobStoreConfigSchema,
+  CACHE_TYPES,
+  CacheConfigSchema,
+  DATABASE_TYPES,
+  DatabaseConfigSchema,
+  InMemoryBlobStoreSchema,
+  LocalBlobStore,
+  LocalBlobStoreSchema,
+  MemoryBlobStore,
+  MemoryCacheStore,
+  MemoryDatabaseStore,
+  PostgresStore,
+  RedisStore,
+  SQLiteStore,
+  StorageSchema,
+  inMemoryBlobStoreFactory,
+  inMemoryCacheFactory,
+  inMemoryDatabaseFactory,
+  localBlobStoreFactory,
+  postgresDatabaseFactory,
+  redisCacheFactory,
+  sqliteDatabaseFactory
+});

package/dist/index.d.cts

@@ -0,0 +1,24 @@
+export { StorageConfig, StorageSchema, ValidatedStorageConfig } from './schemas.cjs';
+export { CacheFactory } from './cache/factory.cjs';
+export { inMemoryCacheFactory } from './cache/factories/memory.cjs';
+export { redisCacheFactory } from './cache/factories/redis.cjs';
+export { CACHE_TYPES, CacheConfig, CacheConfigSchema, CacheType, InMemoryCacheConfig, RedisCacheConfig } from './cache/schemas.cjs';
+export { MemoryCacheStore } from './cache/memory-cache-store.cjs';
+export { RedisStore } from './cache/redis-store.cjs';
+export { DatabaseFactory } from './database/factory.cjs';
+export { inMemoryDatabaseFactory } from './database/factories/memory.cjs';
+export { sqliteDatabaseFactory } from './database/factories/sqlite.cjs';
+export { postgresDatabaseFactory } from './database/factories/postgres.cjs';
+export { DATABASE_TYPES, DatabaseConfig, DatabaseConfigSchema, DatabaseType, InMemoryDatabaseConfig, PostgresDatabaseConfig, SqliteDatabaseConfig } from './database/schemas.cjs';
+export { MemoryDatabaseStore } from './database/memory-database-store.cjs';
+export { SQLiteStore } from './database/sqlite-store.cjs';
+export { PostgresStore } from './database/postgres-store.cjs';
+export { BlobStoreFactory } from './blob/factory.cjs';
+export { localBlobStoreFactory } from './blob/factories/local.cjs';
+export { inMemoryBlobStoreFactory } from './blob/factories/memory.cjs';
+export { BLOB_STORE_TYPES, BlobStoreConfig, BlobStoreConfigSchema, BlobStoreType, InMemoryBlobStoreConfig, InMemoryBlobStoreConfigInput, InMemoryBlobStoreSchema, LocalBlobStoreConfig, LocalBlobStoreConfigInput, LocalBlobStoreSchema } from './blob/schemas.cjs';
+export { LocalBlobStore } from './blob/local-blob-store.cjs';
+export { MemoryBlobStore } from './blob/memory-blob-store.cjs';
+import 'zod';
+import '@dexto/core';
+import 'pg';

package/dist/index.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @dexto/storage
+ *
+ * Concrete storage backends + config schemas + factory objects.
+ *
+ * Core keeps only the storage *interfaces* (`BlobStore`, `Database`, `Cache`) and `StorageManager`.
+ * Product layers (CLI/server/platform) choose which factories to include via images.
+ */
+export type { StorageConfig, ValidatedStorageConfig } from './schemas.js';
+export { StorageSchema, CACHE_TYPES, DATABASE_TYPES, BLOB_STORE_TYPES, CacheConfigSchema, DatabaseConfigSchema, BlobStoreConfigSchema, InMemoryBlobStoreSchema, LocalBlobStoreSchema, } from './schemas.js';
+export type { CacheType, DatabaseType, BlobStoreType, CacheConfig, InMemoryCacheConfig, RedisCacheConfig, DatabaseConfig, InMemoryDatabaseConfig, SqliteDatabaseConfig, PostgresDatabaseConfig, BlobStoreConfig, InMemoryBlobStoreConfigInput, InMemoryBlobStoreConfig, LocalBlobStoreConfigInput, LocalBlobStoreConfig, } from './schemas.js';
+export type { CacheFactory } from './cache/index.js';
+export { inMemoryCacheFactory, redisCacheFactory } from './cache/factories/index.js';
+export { MemoryCacheStore } from './cache/memory-cache-store.js';
+export { RedisStore } from './cache/redis-store.js';
+export type { DatabaseFactory } from './database/index.js';
+export { inMemoryDatabaseFactory, sqliteDatabaseFactory, postgresDatabaseFactory, } from './database/factories/index.js';
+export { MemoryDatabaseStore } from './database/memory-database-store.js';
+export { SQLiteStore } from './database/sqlite-store.js';
+export { PostgresStore } from './database/postgres-store.js';
+export type { BlobStoreFactory } from './blob/index.js';
+export { localBlobStoreFactory, inMemoryBlobStoreFactory } from './blob/factories/index.js';
+export { LocalBlobStore } from './blob/local-blob-store.js';
+export { MemoryBlobStore } from './blob/memory-blob-store.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,YAAY,EAAE,aAAa,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAC;AAC1E,OAAO,EACH,aAAa,EACb,WAAW,EACX,cAAc,EACd,gBAAgB,EAChB,iBAAiB,EACjB,oBAAoB,EACpB,qBAAqB,EACrB,uBAAuB,EACvB,oBAAoB,GACvB,MAAM,cAAc,CAAC;AACtB,YAAY,EACR,SAAS,EACT,YAAY,EACZ,aAAa,EACb,WAAW,EACX,mBAAmB,EACnB,gBAAgB,EAChB,cAAc,EACd,sBAAsB,EACtB,oBAAoB,EACpB,sBAAsB,EACtB,eAAe,EACf,4BAA4B,EAC5B,uBAAuB,EACvB,yBAAyB,EACzB,oBAAoB,GACvB,MAAM,cAAc,CAAC;AAEtB,YAAY,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AACrD,OAAO,EAAE,oBAAoB,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AACrF,OAAO,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AACjE,OAAO,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AAEpD,YAAY,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAC3D,OAAO,EACH,uBAAuB,EACvB,qBAAqB,EACrB,uBAAuB,GAC1B,MAAM,+BAA+B,CAAC;AACvC,OAAO,EAAE,mBAAmB,EAAE,MAAM,qCAAqC,CAAC;AAC1E,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AACzD,OAAO,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAE7D,YAAY,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AACxD,OAAO,EAAE,qBAAqB,EAAE,wBAAwB,EAAE,MAAM,2BAA2B,CAAC;AAC5F,OAAO,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAC5D,OAAO,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC"}

package/dist/index.js

@@ -0,0 +1,50 @@
+import {
+  StorageSchema,
+  CACHE_TYPES,
+  DATABASE_TYPES,
+  BLOB_STORE_TYPES,
+  CacheConfigSchema,
+  DatabaseConfigSchema,
+  BlobStoreConfigSchema,
+  InMemoryBlobStoreSchema,
+  LocalBlobStoreSchema
+} from "./schemas.js";
+import { inMemoryCacheFactory, redisCacheFactory } from "./cache/factories/index.js";
+import { MemoryCacheStore } from "./cache/memory-cache-store.js";
+import { RedisStore } from "./cache/redis-store.js";
+import {
+  inMemoryDatabaseFactory,
+  sqliteDatabaseFactory,
+  postgresDatabaseFactory
+} from "./database/factories/index.js";
+import { MemoryDatabaseStore } from "./database/memory-database-store.js";
+import { SQLiteStore } from "./database/sqlite-store.js";
+import { PostgresStore } from "./database/postgres-store.js";
+import { localBlobStoreFactory, inMemoryBlobStoreFactory } from "./blob/factories/index.js";
+import { LocalBlobStore } from "./blob/local-blob-store.js";
+import { MemoryBlobStore } from "./blob/memory-blob-store.js";
+export {
+  BLOB_STORE_TYPES,
+  BlobStoreConfigSchema,
+  CACHE_TYPES,
+  CacheConfigSchema,
+  DATABASE_TYPES,
+  DatabaseConfigSchema,
+  InMemoryBlobStoreSchema,
+  LocalBlobStore,
+  LocalBlobStoreSchema,
+  MemoryBlobStore,
+  MemoryCacheStore,
+  MemoryDatabaseStore,
+  PostgresStore,
+  RedisStore,
+  SQLiteStore,
+  StorageSchema,
+  inMemoryBlobStoreFactory,
+  inMemoryCacheFactory,
+  inMemoryDatabaseFactory,
+  localBlobStoreFactory,
+  postgresDatabaseFactory,
+  redisCacheFactory,
+  sqliteDatabaseFactory
+};

package/dist/schemas.cjs

@@ -0,0 +1,67 @@
+"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, {
+  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,
+  InMemoryBlobStoreSchema: () => import_schemas3.InMemoryBlobStoreSchema,
+  InMemoryCacheSchema: () => import_schemas.InMemoryCacheSchema,
+  InMemoryDatabaseSchema: () => import_schemas2.InMemoryDatabaseSchema,
+  LocalBlobStoreSchema: () => import_schemas3.LocalBlobStoreSchema,
+  PostgresDatabaseSchema: () => import_schemas2.PostgresDatabaseSchema,
+  RedisCacheSchema: () => import_schemas.RedisCacheSchema,
+  SqliteDatabaseSchema: () => import_schemas2.SqliteDatabaseSchema,
+  StorageSchema: () => StorageSchema
+});
+module.exports = __toCommonJS(schemas_exports);
+var import_zod = require("zod");
+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: import_schemas4.CacheConfigSchema.describe("Cache configuration (fast, ephemeral)"),
+  database: import_schemas5.DatabaseConfigSchema.describe("Database configuration (persistent, reliable)"),
+  blob: import_schemas6.BlobStoreConfigSchema.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,
+  InMemoryBlobStoreSchema,
+  InMemoryCacheSchema,
+  InMemoryDatabaseSchema,
+  LocalBlobStoreSchema,
+  PostgresDatabaseSchema,
+  RedisCacheSchema,
+  SqliteDatabaseSchema,
+  StorageSchema
+});

package/dist/schemas.d.cts

@@ -0,0 +1,72 @@
+import { z } from 'zod';
+export { CACHE_TYPES, CacheConfig, CacheConfigSchema, CacheType, InMemoryCacheConfig, InMemoryCacheSchema, RedisCacheConfig, RedisCacheSchema } from './cache/schemas.cjs';
+export { DATABASE_TYPES, DatabaseConfig, DatabaseConfigSchema, DatabaseType, InMemoryDatabaseConfig, InMemoryDatabaseSchema, PostgresDatabaseConfig, PostgresDatabaseSchema, SqliteDatabaseConfig, SqliteDatabaseSchema } from './database/schemas.cjs';
+export { BLOB_STORE_TYPES, BlobStoreConfig, BlobStoreConfigSchema, BlobStoreType, InMemoryBlobStoreConfig, InMemoryBlobStoreConfigInput, InMemoryBlobStoreSchema, LocalBlobStoreConfig, LocalBlobStoreConfigInput, LocalBlobStoreSchema } from './blob/schemas.cjs';
+
+/**
+ * Top-level storage configuration schema
+ * Composes cache, database, and blob store configurations
+ *
+ * Note: detailed backend validation happens in the resolver (`@dexto/agent-config`)
+ * via each image factory's `configSchema`. This schema validates only the structural
+ * shape required for config parsing and defaults.
+ */
+declare const StorageSchema: z.ZodBranded<z.ZodObject<{
+    cache: z.ZodObject<{
+        type: z.ZodString;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        type: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        type: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">>;
+    database: z.ZodObject<{
+        type: z.ZodString;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        type: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        type: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">>;
+    blob: z.ZodObject<{
+        type: z.ZodString;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        type: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        type: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">>;
+}, "strict", z.ZodTypeAny, {
+    database: {
+        type: string;
+    } & {
+        [k: string]: unknown;
+    };
+    cache: {
+        type: string;
+    } & {
+        [k: string]: unknown;
+    };
+    blob: {
+        type: string;
+    } & {
+        [k: string]: unknown;
+    };
+}, {
+    database: {
+        type: string;
+    } & {
+        [k: string]: unknown;
+    };
+    cache: {
+        type: string;
+    } & {
+        [k: string]: unknown;
+    };
+    blob: {
+        type: string;
+    } & {
+        [k: string]: unknown;
+    };
+}>, "ValidatedStorageConfig">;
+type StorageConfig = z.input<typeof StorageSchema>;
+type ValidatedStorageConfig = z.output<typeof StorageSchema>;
+
+export { type StorageConfig, StorageSchema, type ValidatedStorageConfig };

package/dist/schemas.d.ts

@@ -0,0 +1,70 @@
+import { z } from 'zod';
+export { CACHE_TYPES, CacheConfigSchema, type CacheType, type CacheConfig, InMemoryCacheSchema, type InMemoryCacheConfig, RedisCacheSchema, type RedisCacheConfig, } from './cache/schemas.js';
+export { DATABASE_TYPES, DatabaseConfigSchema, type DatabaseType, type DatabaseConfig, InMemoryDatabaseSchema, type InMemoryDatabaseConfig, SqliteDatabaseSchema, type SqliteDatabaseConfig, PostgresDatabaseSchema, type PostgresDatabaseConfig, } from './database/schemas.js';
+export { BLOB_STORE_TYPES, BlobStoreConfigSchema, InMemoryBlobStoreSchema, LocalBlobStoreSchema, type BlobStoreType, type BlobStoreConfig, type InMemoryBlobStoreConfigInput, type InMemoryBlobStoreConfig, type LocalBlobStoreConfigInput, type LocalBlobStoreConfig, } from './blob/schemas.js';
+/**
+ * Top-level storage configuration schema
+ * Composes cache, database, and blob store configurations
+ *
+ * Note: detailed backend validation happens in the resolver (`@dexto/agent-config`)
+ * via each image factory's `configSchema`. This schema validates only the structural
+ * shape required for config parsing and defaults.
+ */
+export declare const StorageSchema: z.ZodBranded<z.ZodObject<{
+    cache: z.ZodObject<{
+        type: z.ZodString;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        type: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        type: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">>;
+    database: z.ZodObject<{
+        type: z.ZodString;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        type: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        type: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">>;
+    blob: z.ZodObject<{
+        type: z.ZodString;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        type: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        type: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">>;
+}, "strict", z.ZodTypeAny, {
+    database: {
+        type: string;
+    } & {
+        [k: string]: unknown;
+    };
+    cache: {
+        type: string;
+    } & {
+        [k: string]: unknown;
+    };
+    blob: {
+        type: string;
+    } & {
+        [k: string]: unknown;
+    };
+}, {
+    database: {
+        type: string;
+    } & {
+        [k: string]: unknown;
+    };
+    cache: {
+        type: string;
+    } & {
+        [k: string]: unknown;
+    };
+    blob: {
+        type: string;
+    } & {
+        [k: string]: unknown;
+    };
+}>, "ValidatedStorageConfig">;
+export type StorageConfig = z.input<typeof StorageSchema>;
+export type ValidatedStorageConfig = z.output<typeof StorageSchema>;
+//# sourceMappingURL=schemas.d.ts.map

package/dist/schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../src/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,EACH,WAAW,EACX,iBAAiB,EACjB,KAAK,SAAS,EACd,KAAK,WAAW,EAChB,mBAAmB,EACnB,KAAK,mBAAmB,EACxB,gBAAgB,EAChB,KAAK,gBAAgB,GACxB,MAAM,oBAAoB,CAAC;AAG5B,OAAO,EACH,cAAc,EACd,oBAAoB,EACpB,KAAK,YAAY,EACjB,KAAK,cAAc,EACnB,sBAAsB,EACtB,KAAK,sBAAsB,EAC3B,oBAAoB,EACpB,KAAK,oBAAoB,EACzB,sBAAsB,EACtB,KAAK,sBAAsB,GAC9B,MAAM,uBAAuB,CAAC;AAG/B,OAAO,EACH,gBAAgB,EAChB,qBAAqB,EACrB,uBAAuB,EACvB,oBAAoB,EACpB,KAAK,aAAa,EAClB,KAAK,eAAe,EACpB,KAAK,4BAA4B,EACjC,KAAK,uBAAuB,EAC5B,KAAK,yBAAyB,EAC9B,KAAK,oBAAoB,GAC5B,MAAM,mBAAmB,CAAC;AAO3B;;;;;;;GAOG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BAUY,CAAC;AAEvC,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAC1D,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,aAAa,CAAC,CAAC"}

package/dist/schemas.js

@@ -0,0 +1,46 @@
+import { z } from "zod";
+import {
+  CACHE_TYPES,
+  CacheConfigSchema,
+  InMemoryCacheSchema,
+  RedisCacheSchema
+} from "./cache/schemas.js";
+import {
+  DATABASE_TYPES,
+  DatabaseConfigSchema,
+  InMemoryDatabaseSchema,
+  SqliteDatabaseSchema,
+  PostgresDatabaseSchema
+} from "./database/schemas.js";
+import {
+  BLOB_STORE_TYPES,
+  BlobStoreConfigSchema,
+  InMemoryBlobStoreSchema,
+  LocalBlobStoreSchema
+} from "./blob/schemas.js";
+import { CacheConfigSchema as CacheConfigSchema2 } from "./cache/schemas.js";
+import { DatabaseConfigSchema as DatabaseConfigSchema2 } from "./database/schemas.js";
+import { BlobStoreConfigSchema as BlobStoreConfigSchema2 } from "./blob/schemas.js";
+const StorageSchema = z.object({
+  cache: CacheConfigSchema2.describe("Cache configuration (fast, ephemeral)"),
+  database: DatabaseConfigSchema2.describe("Database configuration (persistent, reliable)"),
+  blob: BlobStoreConfigSchema2.describe(
+    "Blob store configuration (for large, unstructured data)"
+  )
+}).strict().describe("Storage configuration with cache, database, and blob store").brand();
+export {
+  BLOB_STORE_TYPES,
+  BlobStoreConfigSchema,
+  CACHE_TYPES,
+  CacheConfigSchema,
+  DATABASE_TYPES,
+  DatabaseConfigSchema,
+  InMemoryBlobStoreSchema,
+  InMemoryCacheSchema,
+  InMemoryDatabaseSchema,
+  LocalBlobStoreSchema,
+  PostgresDatabaseSchema,
+  RedisCacheSchema,
+  SqliteDatabaseSchema,
+  StorageSchema
+};

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@dexto/storage",
+  "version": "1.6.0",
+  "description": "Storage backends and factories for Dexto agents",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./schemas": {
+      "types": "./dist/schemas.d.ts",
+      "import": "./dist/schemas.js"
+    }
+  },
+  "keywords": [
+    "dexto",
+    "storage"
+  ],
+  "dependencies": {
+    "zod": "^3.25.0",
+    "@dexto/core": "1.6.0"
+  },
+  "peerDependencies": {
+    "better-sqlite3": "^11.10.0",
+    "ioredis": "^5.7.0",
+    "pg": "^8.15.4"
+  },
+  "peerDependenciesMeta": {
+    "better-sqlite3": {
+      "optional": true
+    },
+    "ioredis": {
+      "optional": true
+    },
+    "pg": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "tsup": "^8.0.0",
+    "typescript": "^5.3.3"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf dist"
+  }
+}