@dexto/core 1.1.4 → 1.1.6

package/dist/storage/schemas.cjs

@@ -0,0 +1,113 @@
+"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, {
+  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
+        }
+      });
+    }
+  }
+});
+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();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  StorageSchema
+});