@dexto/storage 1.6.0

package/dist/cache/schemas.d.ts

@@ -0,0 +1,91 @@
+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.ZodUnknown>>;
+} & {
+    type: z.ZodLiteral<"in-memory">;
+}, "strict", z.ZodTypeAny, {
+    type: "in-memory";
+    maxConnections?: number | undefined;
+    idleTimeoutMillis?: number | undefined;
+    connectionTimeoutMillis?: number | undefined;
+    options?: Record<string, unknown> | undefined;
+}, {
+    type: "in-memory";
+    maxConnections?: number | undefined;
+    idleTimeoutMillis?: number | undefined;
+    connectionTimeoutMillis?: number | undefined;
+    options?: Record<string, unknown> | undefined;
+}>;
+export type InMemoryCacheConfig = z.output<typeof InMemoryCacheSchema>;
+export declare const RedisCacheSchema: z.ZodEffects<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.ZodUnknown>>;
+} & {
+    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";
+    maxConnections?: number | undefined;
+    idleTimeoutMillis?: number | undefined;
+    connectionTimeoutMillis?: number | undefined;
+    options?: Record<string, unknown> | undefined;
+    url?: string | undefined;
+    host?: string | undefined;
+    port?: number | undefined;
+    password?: string | undefined;
+    database?: number | undefined;
+}, {
+    type: "redis";
+    maxConnections?: number | undefined;
+    idleTimeoutMillis?: number | undefined;
+    connectionTimeoutMillis?: number | undefined;
+    options?: Record<string, unknown> | undefined;
+    url?: string | undefined;
+    host?: string | undefined;
+    port?: number | undefined;
+    password?: string | undefined;
+    database?: number | undefined;
+}>, {
+    type: "redis";
+    maxConnections?: number | undefined;
+    idleTimeoutMillis?: number | undefined;
+    connectionTimeoutMillis?: number | undefined;
+    options?: Record<string, unknown> | undefined;
+    url?: string | undefined;
+    host?: string | undefined;
+    port?: number | undefined;
+    password?: string | undefined;
+    database?: number | undefined;
+}, {
+    type: "redis";
+    maxConnections?: number | undefined;
+    idleTimeoutMillis?: number | undefined;
+    connectionTimeoutMillis?: number | undefined;
+    options?: Record<string, unknown> | undefined;
+    url?: string | undefined;
+    host?: string | undefined;
+    port?: number | undefined;
+    password?: string | undefined;
+    database?: number | undefined;
+}>;
+export type RedisCacheConfig = z.output<typeof RedisCacheSchema>;
+export declare const CacheConfigSchema: z.ZodObject<{
+    type: z.ZodString;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    type: z.ZodString;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    type: z.ZodString;
+}, z.ZodTypeAny, "passthrough">>;
+export type CacheConfig = z.output<typeof CacheConfigSchema>;
+//# sourceMappingURL=schemas.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/cache/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsBvB,CAAC;AAEP,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAGjE,eAAO,MAAM,iBAAiB;;;;;;gCAKmC,CAAC;AAElE,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,iBAAiB,CAAC,CAAC"}

package/dist/cache/schemas.js

@@ -0,0 +1,43 @@
+import { z } from "zod";
+import { EnvExpandedString, ErrorScope, ErrorType, StorageErrorCode } from "@dexto/core";
+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.unknown()).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().superRefine((data, ctx) => {
+  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
+      }
+    });
+  }
+});
+const CacheConfigSchema = z.object({
+  type: z.string().describe("Cache backend type identifier")
+}).passthrough().describe("Cache configuration (validated by image factory)");
+export {
+  CACHE_TYPES,
+  CacheConfigSchema,
+  InMemoryCacheSchema,
+  RedisCacheSchema
+};

package/dist/cache/types.cjs

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/dist/cache/types.d.cts

@@ -0,0 +1 @@
+export { Cache } from '@dexto/core';

package/dist/cache/types.d.ts

@@ -0,0 +1,2 @@
+export type { Cache } from '@dexto/core';
+//# sourceMappingURL=types.d.ts.map

package/dist/cache/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/cache/types.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC"}

package/dist/database/factories/index.cjs

@@ -0,0 +1,34 @@
+"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 factories_exports = {};
+__export(factories_exports, {
+  inMemoryDatabaseFactory: () => import_memory.inMemoryDatabaseFactory,
+  postgresDatabaseFactory: () => import_postgres.postgresDatabaseFactory,
+  sqliteDatabaseFactory: () => import_sqlite.sqliteDatabaseFactory
+});
+module.exports = __toCommonJS(factories_exports);
+var import_memory = require("./memory.js");
+var import_sqlite = require("./sqlite.js");
+var import_postgres = require("./postgres.js");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  inMemoryDatabaseFactory,
+  postgresDatabaseFactory,
+  sqliteDatabaseFactory
+});

package/dist/database/factories/index.d.cts

@@ -0,0 +1,7 @@
+export { inMemoryDatabaseFactory } from './memory.cjs';
+export { sqliteDatabaseFactory } from './sqlite.cjs';
+export { postgresDatabaseFactory } from './postgres.cjs';
+import '../schemas.cjs';
+import 'zod';
+import '../factory.cjs';
+import '@dexto/core';

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

@@ -0,0 +1,7 @@
+/**
+ * Built-in database factories.
+ */
+export { inMemoryDatabaseFactory } from './memory.js';
+export { sqliteDatabaseFactory } from './sqlite.js';
+export { postgresDatabaseFactory } from './postgres.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/database/factories/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,uBAAuB,EAAE,MAAM,aAAa,CAAC;AACtD,OAAO,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AACpD,OAAO,EAAE,uBAAuB,EAAE,MAAM,eAAe,CAAC"}

package/dist/database/factories/index.js

@@ -0,0 +1,8 @@
+import { inMemoryDatabaseFactory } from "./memory.js";
+import { sqliteDatabaseFactory } from "./sqlite.js";
+import { postgresDatabaseFactory } from "./postgres.js";
+export {
+  inMemoryDatabaseFactory,
+  postgresDatabaseFactory,
+  sqliteDatabaseFactory
+};

package/dist/database/factories/memory.cjs

@@ -0,0 +1,39 @@
+"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 memory_exports = {};
+__export(memory_exports, {
+  inMemoryDatabaseFactory: () => inMemoryDatabaseFactory
+});
+module.exports = __toCommonJS(memory_exports);
+var import_schemas = require("../schemas.js");
+var import_memory_database_store = require("../memory-database-store.js");
+const inMemoryDatabaseFactory = {
+  configSchema: import_schemas.InMemoryDatabaseSchema,
+  create: (_config, _logger) => new import_memory_database_store.MemoryDatabaseStore(),
+  metadata: {
+    displayName: "In-Memory",
+    description: "Store data in RAM (ephemeral, for testing and development)",
+    requiresNetwork: false,
+    supportsListOperations: true
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  inMemoryDatabaseFactory
+});

package/dist/database/factories/memory.d.cts

@@ -0,0 +1,20 @@
+import { InMemoryDatabaseConfig } from '../schemas.cjs';
+import { DatabaseFactory } from '../factory.cjs';
+import 'zod';
+import '@dexto/core';
+
+/**
+ * Factory for in-memory database storage.
+ *
+ * This factory stores data in RAM and is ideal for development,
+ * testing, and ephemeral use cases where persistence is not required.
+ *
+ * Features:
+ * - Zero external dependencies
+ * - Fast in-memory operations
+ * - No network required
+ * - Data is lost on restart
+ */
+declare const inMemoryDatabaseFactory: DatabaseFactory<InMemoryDatabaseConfig>;
+
+export { inMemoryDatabaseFactory };

package/dist/database/factories/memory.d.ts

@@ -0,0 +1,16 @@
+import type { InMemoryDatabaseConfig } from '../schemas.js';
+import type { DatabaseFactory } from '../factory.js';
+/**
+ * Factory for in-memory database storage.
+ *
+ * This factory stores data in RAM and is ideal for development,
+ * testing, and ephemeral use cases where persistence is not required.
+ *
+ * Features:
+ * - Zero external dependencies
+ * - Fast in-memory operations
+ * - No network required
+ * - Data is lost on restart
+ */
+export declare const inMemoryDatabaseFactory: DatabaseFactory<InMemoryDatabaseConfig>;
+//# sourceMappingURL=memory.d.ts.map

package/dist/database/factories/memory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory.d.ts","sourceRoot":"","sources":["../../../src/database/factories/memory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,eAAe,CAAC;AAG5D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAErD;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,uBAAuB,EAAE,eAAe,CAAC,sBAAsB,CAS3E,CAAC"}

package/dist/database/factories/memory.js

@@ -0,0 +1,15 @@
+import { InMemoryDatabaseSchema } from "../schemas.js";
+import { MemoryDatabaseStore } from "../memory-database-store.js";
+const inMemoryDatabaseFactory = {
+  configSchema: InMemoryDatabaseSchema,
+  create: (_config, _logger) => new MemoryDatabaseStore(),
+  metadata: {
+    displayName: "In-Memory",
+    description: "Store data in RAM (ephemeral, for testing and development)",
+    requiresNetwork: false,
+    supportsListOperations: true
+  }
+};
+export {
+  inMemoryDatabaseFactory
+};

package/dist/database/factories/postgres.cjs

@@ -0,0 +1,61 @@
+"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)
+    __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 __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 postgres_exports = {};
+__export(postgres_exports, {
+  postgresDatabaseFactory: () => postgresDatabaseFactory
+});
+module.exports = __toCommonJS(postgres_exports);
+var import_schemas = require("../schemas.js");
+var import_core = require("@dexto/core");
+const postgresDatabaseFactory = {
+  configSchema: import_schemas.PostgresDatabaseSchema,
+  create: async (config, logger) => {
+    try {
+      const module2 = await import("../postgres-store.js");
+      logger.info("Connecting to PostgreSQL database");
+      return new module2.PostgresStore(config, logger);
+    } catch (error) {
+      const err = error;
+      if (err.code === "ERR_MODULE_NOT_FOUND") {
+        throw import_core.StorageError.dependencyNotInstalled("PostgreSQL", "pg", "npm install pg");
+      }
+      throw error;
+    }
+  },
+  metadata: {
+    displayName: "PostgreSQL",
+    description: "Production PostgreSQL database with connection pooling",
+    requiresNetwork: true,
+    supportsListOperations: true
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  postgresDatabaseFactory
+});

package/dist/database/factories/postgres.d.cts

@@ -0,0 +1,23 @@
+import { PostgresDatabaseConfig } from '../schemas.cjs';
+import { DatabaseFactory } from '../factory.cjs';
+import 'zod';
+import '@dexto/core';
+
+/**
+ * Factory for PostgreSQL database storage.
+ *
+ * This factory stores data in a PostgreSQL database server using the pg package.
+ * It's ideal for production deployments requiring scalability and multi-machine access.
+ *
+ * Features:
+ * - Connection pooling for efficient resource usage
+ * - JSONB storage for flexible data types
+ * - Transaction support
+ * - Suitable for distributed deployments
+ *
+ * Note: pg is an optional dependency. Install it with:
+ * npm install pg
+ */
+declare const postgresDatabaseFactory: DatabaseFactory<PostgresDatabaseConfig>;
+
+export { postgresDatabaseFactory };

package/dist/database/factories/postgres.d.ts

@@ -0,0 +1,19 @@
+import type { PostgresDatabaseConfig } from '../schemas.js';
+import type { DatabaseFactory } from '../factory.js';
+/**
+ * Factory for PostgreSQL database storage.
+ *
+ * This factory stores data in a PostgreSQL database server using the pg package.
+ * It's ideal for production deployments requiring scalability and multi-machine access.
+ *
+ * Features:
+ * - Connection pooling for efficient resource usage
+ * - JSONB storage for flexible data types
+ * - Transaction support
+ * - Suitable for distributed deployments
+ *
+ * Note: pg is an optional dependency. Install it with:
+ * npm install pg
+ */
+export declare const postgresDatabaseFactory: DatabaseFactory<PostgresDatabaseConfig>;
+//# sourceMappingURL=postgres.d.ts.map

package/dist/database/factories/postgres.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgres.d.ts","sourceRoot":"","sources":["../../../src/database/factories/postgres.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,eAAe,CAAC;AAG5D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAErD;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,uBAAuB,EAAE,eAAe,CAAC,sBAAsB,CAqB3E,CAAC"}

package/dist/database/factories/postgres.js

@@ -0,0 +1,27 @@
+import { PostgresDatabaseSchema } from "../schemas.js";
+import { StorageError } from "@dexto/core";
+const postgresDatabaseFactory = {
+  configSchema: PostgresDatabaseSchema,
+  create: async (config, logger) => {
+    try {
+      const module = await import("../postgres-store.js");
+      logger.info("Connecting to PostgreSQL database");
+      return new module.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;
+    }
+  },
+  metadata: {
+    displayName: "PostgreSQL",
+    description: "Production PostgreSQL database with connection pooling",
+    requiresNetwork: true,
+    supportsListOperations: true
+  }
+};
+export {
+  postgresDatabaseFactory
+};

package/dist/database/factories/sqlite.cjs

@@ -0,0 +1,65 @@
+"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)
+    __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 __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 sqlite_exports = {};
+__export(sqlite_exports, {
+  sqliteDatabaseFactory: () => sqliteDatabaseFactory
+});
+module.exports = __toCommonJS(sqlite_exports);
+var import_schemas = require("../schemas.js");
+var import_core = require("@dexto/core");
+const sqliteDatabaseFactory = {
+  configSchema: import_schemas.SqliteDatabaseSchema,
+  create: async (config, logger) => {
+    try {
+      const module2 = await import("../sqlite-store.js");
+      logger.info(`Creating SQLite database store: ${config.path}`);
+      return new module2.SQLiteStore(config, logger);
+    } catch (error) {
+      const err = error;
+      if (err.code === "ERR_MODULE_NOT_FOUND" && typeof err.message === "string" && err.message.includes("better-sqlite3")) {
+        throw import_core.StorageError.dependencyNotInstalled(
+          "SQLite",
+          "better-sqlite3",
+          "npm install better-sqlite3"
+        );
+      }
+      throw error;
+    }
+  },
+  metadata: {
+    displayName: "SQLite",
+    description: "Local SQLite database for persistent storage",
+    requiresNetwork: false,
+    supportsListOperations: true
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  sqliteDatabaseFactory
+});

package/dist/database/factories/sqlite.d.cts

@@ -0,0 +1,24 @@
+import { SqliteDatabaseConfig } from '../schemas.cjs';
+import { DatabaseFactory } from '../factory.cjs';
+import 'zod';
+import '@dexto/core';
+
+/**
+ * Factory for SQLite database storage.
+ *
+ * This factory stores data in a local SQLite database file using better-sqlite3.
+ * It's ideal for single-machine deployments and development scenarios where
+ * persistence is required without the overhead of a database server.
+ *
+ * Features:
+ * - Uses better-sqlite3 for synchronous, fast operations
+ * - WAL mode enabled for better concurrency
+ * - No external server required
+ * - Persistent storage survives restarts
+ *
+ * Note: better-sqlite3 is an optional dependency. Install it with:
+ * npm install better-sqlite3
+ */
+declare const sqliteDatabaseFactory: DatabaseFactory<SqliteDatabaseConfig>;
+
+export { sqliteDatabaseFactory };

package/dist/database/factories/sqlite.d.ts

@@ -0,0 +1,20 @@
+import type { SqliteDatabaseConfig } from '../schemas.js';
+import type { DatabaseFactory } from '../factory.js';
+/**
+ * Factory for SQLite database storage.
+ *
+ * This factory stores data in a local SQLite database file using better-sqlite3.
+ * It's ideal for single-machine deployments and development scenarios where
+ * persistence is required without the overhead of a database server.
+ *
+ * Features:
+ * - Uses better-sqlite3 for synchronous, fast operations
+ * - WAL mode enabled for better concurrency
+ * - No external server required
+ * - Persistent storage survives restarts
+ *
+ * Note: better-sqlite3 is an optional dependency. Install it with:
+ * npm install better-sqlite3
+ */
+export declare const sqliteDatabaseFactory: DatabaseFactory<SqliteDatabaseConfig>;
+//# sourceMappingURL=sqlite.d.ts.map

package/dist/database/factories/sqlite.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite.d.ts","sourceRoot":"","sources":["../../../src/database/factories/sqlite.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAC;AAG1D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAErD;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,qBAAqB,EAAE,eAAe,CAAC,oBAAoB,CA6BvE,CAAC"}

package/dist/database/factories/sqlite.js

@@ -0,0 +1,31 @@
+import { SqliteDatabaseSchema } from "../schemas.js";
+import { StorageError } from "@dexto/core";
+const sqliteDatabaseFactory = {
+  configSchema: SqliteDatabaseSchema,
+  create: async (config, logger) => {
+    try {
+      const module = await import("../sqlite-store.js");
+      logger.info(`Creating SQLite database store: ${config.path}`);
+      return new module.SQLiteStore(config, logger);
+    } catch (error) {
+      const err = error;
+      if (err.code === "ERR_MODULE_NOT_FOUND" && typeof err.message === "string" && err.message.includes("better-sqlite3")) {
+        throw StorageError.dependencyNotInstalled(
+          "SQLite",
+          "better-sqlite3",
+          "npm install better-sqlite3"
+        );
+      }
+      throw error;
+    }
+  },
+  metadata: {
+    displayName: "SQLite",
+    description: "Local SQLite database for persistent storage",
+    requiresNetwork: false,
+    supportsListOperations: true
+  }
+};
+export {
+  sqliteDatabaseFactory
+};

package/dist/database/factory.cjs

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 = {};
+module.exports = __toCommonJS(factory_exports);