fluxor-cloud-db 1.0.0

package/dist/index.js

@@ -0,0 +1,1844 @@
+"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 __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  DynamoService: () => DynamoService,
+  MongoService: () => MongoService,
+  anyOf: () => anyOf,
+  between: () => between,
+  eq: () => eq,
+  equals: () => equals,
+  exists: () => exists,
+  gt: () => gt,
+  gte: () => gte,
+  inList: () => inList,
+  like: () => like,
+  lt: () => lt,
+  lte: () => lte,
+  neq: () => neq,
+  noneOf: () => noneOf,
+  notEquals: () => notEquals,
+  notInList: () => notInList,
+  startsWith: () => startsWith,
+  useDynamo: () => useDynamo,
+  useMongo: () => useMongo
+});
+module.exports = __toCommonJS(index_exports);
+var import_fluxor_cloud2 = require("fluxor-cloud");
+
+// src/dynamo/dynamo.ts
+var import_lib_dynamodb = require("@aws-sdk/lib-dynamodb");
+var import_fluxor_cloud = require("fluxor-cloud");
+var import_client_dynamodb = require("@aws-sdk/client-dynamodb");
+var import_lib_dynamodb2 = require("@aws-sdk/lib-dynamodb");
+
+// src/types/error.ts
+var DatabaseAdapterError = class extends Error {
+  constructor(message, code, details) {
+    super(message);
+    this.code = code;
+    this.details = details;
+    this.name = "DatabaseAdapterError";
+  }
+};
+
+// src/dynamo/dynamo.ts
+var RESERVED_KEYWORDS = /* @__PURE__ */ new Set([
+  "ABORT",
+  "ABSOLUTE",
+  "ACTION",
+  "ADD",
+  "AFTER",
+  "AGENT",
+  "ALL",
+  "ALLOCATE",
+  "ALTER",
+  "ANALYZE",
+  "AND",
+  "ANY",
+  "ARCHIVE",
+  "ARE",
+  "ARRAY",
+  "AS",
+  "ASC",
+  "ASCII",
+  "ASENSITIVE",
+  "ASSERTION",
+  "ASYMMETRIC",
+  "AT",
+  "ATOMIC",
+  "ATTACH",
+  "ATTRIBUTE",
+  "AUTH",
+  "AUTHORIZATION",
+  "AUTHORIZE",
+  "AUTO",
+  "AVG",
+  "BACK",
+  "BACKUP",
+  "BASE",
+  "BATCH",
+  "BEFORE",
+  "BEGIN",
+  "BETWEEN",
+  "BIGINT",
+  "BINARY",
+  "BIT",
+  "BLOB",
+  "BLOCK",
+  "BOOLEAN",
+  "BOTH",
+  "BREADTH",
+  "BUCKET",
+  "BULK",
+  "BY",
+  "CALL",
+  "CALLED",
+  "CALLING",
+  "CAPACITY",
+  "CASCADE",
+  "CASCADED",
+  "CASE",
+  "CAST",
+  "CATALOG",
+  "CHAR",
+  "CHARACTER",
+  "CHECK",
+  "CLASS",
+  "CLOB",
+  "CLOSE",
+  "CLUSTER",
+  "CLUSTERED",
+  "CLUSTERING",
+  "CLUSTERS",
+  "COALESCE",
+  "COLLATE",
+  "COLLATION",
+  "COLLECTION",
+  "COLUMN",
+  "COLUMNS",
+  "COMBINE",
+  "COMMENT",
+  "COMMIT",
+  "COMPACT",
+  "COMPILE",
+  "COMPRESS",
+  "CONDITION",
+  "CONFLICT",
+  "CONNECT",
+  "CONNECTION",
+  "CONSISTENCY",
+  "CONSISTENT",
+  "CONSTRAINT",
+  "CONSTRAINTS",
+  "CONSTRUCTOR",
+  "CONSUMED",
+  "CONTINUE",
+  "CONVERT",
+  "COPY",
+  "CORRESPONDING",
+  "COUNT",
+  "COUNTER",
+  "CREATE",
+  "CROSS",
+  "CUBE",
+  "CURRENT",
+  "CURSOR",
+  "CYCLE",
+  "DATA",
+  "DATABASE",
+  "DATE",
+  "DATETIME",
+  "DAY",
+  "DEALLOCATE",
+  "DEC",
+  "DECIMAL",
+  "DECLARE",
+  "DEFAULT",
+  "DEFERRABLE",
+  "DEFERRED",
+  "DEFINE",
+  "DEFINED",
+  "DEFINITION",
+  "DELETE",
+  "DELIMITED",
+  "DEPTH",
+  "DEREF",
+  "DESC",
+  "DESCRIBE",
+  "DESCRIPTOR",
+  "DETACH",
+  "DETERMINISTIC",
+  "DIAGNOSTICS",
+  "DIRECTORIES",
+  "DISABLE",
+  "DISCONNECT",
+  "DISTINCT",
+  "DISTRIBUTE",
+  "DO",
+  "DOMAIN",
+  "DOUBLE",
+  "DROP",
+  "DUMP",
+  "DURATION",
+  "DYNAMIC",
+  "EACH",
+  "ELEMENT",
+  "ELSE",
+  "ELSEIF",
+  "EMPTY",
+  "ENABLE",
+  "END",
+  "EQUAL",
+  "EQUALS",
+  "ERROR",
+  "ESCAPE",
+  "EVALUATED",
+  "EXCEPT",
+  "EXCEPTION",
+  "EXCEPTIONS",
+  "EXCLUSIVE",
+  "EXEC",
+  "EXECUTE",
+  "EXISTS",
+  "EXIT",
+  "EXPLAIN",
+  "EXPLODE",
+  "EXPORT",
+  "EXPRESSION",
+  "EXTENDED",
+  "EXTERNAL",
+  "EXTRACT",
+  "FAIL",
+  "FALSE",
+  "FAMILY",
+  "FETCH",
+  "FIELDS",
+  "FILE",
+  "FILTER",
+  "FILTERING",
+  "FINAL",
+  "FINISH",
+  "FIRST",
+  "FIXED",
+  "FLATTERN",
+  "FLOAT",
+  "FOR",
+  "FORCE",
+  "FOREIGN",
+  "FORMAT",
+  "FORWARD",
+  "FOUND",
+  "FREE",
+  "FROM",
+  "FULL",
+  "FUNCTION",
+  "FUNCTIONS",
+  "GENERAL",
+  "GENERATE",
+  "GET",
+  "GLOB",
+  "GO",
+  "GOTO",
+  "GRANT",
+  "GREATER",
+  "GROUP",
+  "GROUPING",
+  "HANDLER",
+  "HASH",
+  "HAVE",
+  "HAVING",
+  "HEAP",
+  "HIDDEN",
+  "HOLD",
+  "HOUR",
+  "IDENTIFIED",
+  "IF",
+  "IGNORE",
+  "IMMEDIATE",
+  "IMPORT",
+  "IN",
+  "INCLUDING",
+  "INCLUSIVE",
+  "INCREMENT",
+  "INDETERMINATE",
+  "INDEX",
+  "INDEXED",
+  "INDEXES",
+  "INDICATOR",
+  "INFINITE",
+  "INITIALLY",
+  "INLINE",
+  "INNER",
+  "INNTER",
+  "INOUT",
+  "INPUT",
+  "INSENSITIVE",
+  "INSERT",
+  "INSTEAD",
+  "INT",
+  "INTEGER",
+  "INTERSECT",
+  "INTERVAL",
+  "INTO",
+  "INVALIDATE",
+  "IS",
+  "ISOLATION",
+  "ITEM",
+  "ITEMS",
+  "ITERATE",
+  "JOIN",
+  "KEY",
+  "KEYS",
+  "LAG",
+  "LANGUAGE",
+  "LARGE",
+  "LAST",
+  "LATERAL",
+  "LEAD",
+  "LEADING",
+  "LEAVE",
+  "LEFT",
+  "LENGTH",
+  "LESS",
+  "LEVEL",
+  "LIKE",
+  "LIMIT",
+  "LIST",
+  "LOAD",
+  "LOCAL",
+  "LOCALTIME",
+  "LOCALTIMESTAMP",
+  "LOCATION",
+  "LOCATOR",
+  "LOCK",
+  "LOCKS",
+  "LOG",
+  "LOGED",
+  "LONG",
+  "LOOP",
+  "LOWER",
+  "MAP",
+  "MATCH",
+  "MATERIALIZED",
+  "MAX",
+  "MAXLEN",
+  "MEMBER",
+  "MERGE",
+  "METHOD",
+  "MIN",
+  "MINUS",
+  "MINUTE",
+  "MISSING",
+  "MOD",
+  "MODE",
+  "MODIFIES",
+  "MODIFY",
+  "MODULE",
+  "MONTH",
+  "MULTI",
+  "MULTISET",
+  "NAME",
+  "NAMES",
+  "NATIONAL",
+  "NATURAL",
+  "NCHAR",
+  "NCLOB",
+  "NEW",
+  "NEXT",
+  "NO",
+  "NONE",
+  "NOT",
+  "NULL",
+  "NULLIF",
+  "NUMBER",
+  "NUMERIC",
+  "OBJECT",
+  "OF",
+  "OFFLINE",
+  "OFFSET",
+  "OLD",
+  "ON",
+  "ONLINE",
+  "ONLY",
+  "OPEN",
+  "OPTION",
+  "OR",
+  "ORDER",
+  "ORDINALITY",
+  "OUT",
+  "OUTER",
+  "OUTPUT",
+  "OVER",
+  "OVERLAPS",
+  "OVERRIDE",
+  "OWNER",
+  "PAD",
+  "PARALLEL",
+  "PARAMETER",
+  "PARAMETERS",
+  "PARTIAL",
+  "PARTITION",
+  "PARTITIONED",
+  "PARTITIONS",
+  "PATH",
+  "PERCENT",
+  "PERCENTILE",
+  "PERMISSION",
+  "PERMISSIONS",
+  "PIPE",
+  "PIPELINED",
+  "PLAN",
+  "POOL",
+  "POSITION",
+  "PRECISION",
+  "PREPARE",
+  "PRESERVE",
+  "PRIMARY",
+  "PRIOR",
+  "PRIVATE",
+  "PRIVILEGES",
+  "PROCEDURE",
+  "PROCESSED",
+  "PROJECT",
+  "PROJECTION",
+  "PROPERTY",
+  "PROVISIONING",
+  "PUBLIC",
+  "PUT",
+  "QUERY",
+  "QUIT",
+  "QUORUM",
+  "RAISE",
+  "RANDOM",
+  "RANGE",
+  "RANK",
+  "RAW",
+  "READ",
+  "READS",
+  "REAL",
+  "REBUILD",
+  "RECORD",
+  "RECURSIVE",
+  "REDUCE",
+  "REF",
+  "REFERENCE",
+  "REFERENCES",
+  "REFERENCING",
+  "REGEXP",
+  "REINDEX",
+  "RELATIVE",
+  "RELEASE",
+  "REMAINDER",
+  "RENAME",
+  "REPEAT",
+  "REPLACE",
+  "REQUEST",
+  "RESET",
+  "RESIGNAL",
+  "RESTRICT",
+  "RESULT",
+  "RETURN",
+  "RETURNING",
+  "RETURNS",
+  "REVERSE",
+  "REVOKE",
+  "RIGHT",
+  "ROLE",
+  "ROLES",
+  "ROLLBACK",
+  "ROLLUP",
+  "ROUTINE",
+  "ROW",
+  "ROWS",
+  "RULE",
+  "RULES",
+  "SAMPLE",
+  "SATISFIES",
+  "SAVE",
+  "SAVEPOINT",
+  "SCAN",
+  "SCHEMA",
+  "SCOPE",
+  "SCROLL",
+  "SEARCH",
+  "SECOND",
+  "SECTION",
+  "SEGMENT",
+  "SELECT",
+  "SELF",
+  "SEMI",
+  "SENSITIVE",
+  "SEPARATE",
+  "SEQUENCE",
+  "SERIALIZABLE",
+  "SESSION",
+  "SET",
+  "SETS",
+  "SHARD",
+  "SHARE",
+  "SHARED",
+  "SHORT",
+  "SHOW",
+  "SIGNAL",
+  "SIMILAR",
+  "SIZE",
+  "SKEWED",
+  "SOME",
+  "SOURCE",
+  "SPACE",
+  "SPACES",
+  "SPARSE",
+  "SPECIFIC",
+  "SPECIFICTYPE",
+  "SQL",
+  "SQLCODE",
+  "SQLERROR",
+  "SQLEXCEPTION",
+  "SQLSTATE",
+  "SQLWARNING",
+  "START",
+  "STATE",
+  "STATIC",
+  "STATUS",
+  "STORAGE",
+  "STORE",
+  "STORED",
+  "STREAM",
+  "STRING",
+  "STRUCT",
+  "STYLE",
+  "SUB",
+  "SUBMULTISET",
+  "SUBPARTITION",
+  "SUBSTRING",
+  "SUBTYPE",
+  "SUM",
+  "SUPER",
+  "SYMMETRIC",
+  "SYNONYM",
+  "SYSTEM",
+  "TABLE",
+  "TABLESAMPLE",
+  "TEMP",
+  "TEMPORARY",
+  "TERMINATED",
+  "TEXT",
+  "THAN",
+  "THEN",
+  "THROUGHPUT",
+  "TIME",
+  "TIMESTAMP",
+  "TIMEZONE",
+  "TINYINT",
+  "TO",
+  "TOKEN",
+  "TOTAL",
+  "TOUCH",
+  "TRAILING",
+  "TRANSACTION",
+  "TRANSFORM",
+  "TRANSLATE",
+  "TRANSLATION",
+  "TREAT",
+  "TRIGGER",
+  "TRIM",
+  "TRUE",
+  "TRUNCATE",
+  "TTL",
+  "TUPLE",
+  "TYPE",
+  "UNDER",
+  "UNDO",
+  "UNION",
+  "UNIQUE",
+  "UNIT",
+  "UNKNOWN",
+  "UNLOGGED",
+  "UNNEST",
+  "UNPROCESSED",
+  "UNSIGNED",
+  "UNTIL",
+  "UPDATE",
+  "UPPER",
+  "URL",
+  "USAGE",
+  "USE",
+  "USER",
+  "USERS",
+  "USING",
+  "UUID",
+  "VACUUM",
+  "VALUE",
+  "VALUED",
+  "VALUES",
+  "VARCHAR",
+  "VARIABLE",
+  "VARIANCE",
+  "VARINT",
+  "VARYING",
+  "VIEW",
+  "VIEWS",
+  "VIRTUAL",
+  "VOID",
+  "WAIT",
+  "WHEN",
+  "WHENEVER",
+  "WHERE",
+  "WHILE",
+  "WINDOW",
+  "WITH",
+  "WITHIN",
+  "WITHOUT",
+  "WORK",
+  "WRAPPED",
+  "WRITE",
+  "YEAR",
+  "ZONE",
+  // Common attribute names that often conflict
+  "NAME",
+  "STATUS",
+  "SCORE",
+  "PRICE",
+  "CATEGORY"
+]);
+var DynamoService = class {
+  constructor() {
+    this.isConnectedFlag = false;
+  }
+  setConfig(config) {
+    this.config = config;
+  }
+  connect() {
+    if (!this.config) {
+      return Promise.reject(new DatabaseAdapterError(
+        "No configuration provided. Call setConfig() first.",
+        "INVALID_CONFIG"
+      ));
+    }
+    return Promise.resolve().then(() => {
+      try {
+        this.validateConfig(this.config);
+        this.dynamoDBClient = new import_client_dynamodb.DynamoDBClient({
+          region: this.config.region,
+          endpoint: this.config.endpoint,
+          credentials: this.config.accessKeyId ? {
+            accessKeyId: this.config.accessKeyId,
+            secretAccessKey: this.config.secretAccessKey
+          } : void 0
+        });
+        this.client = import_lib_dynamodb.DynamoDBDocumentClient.from(this.dynamoDBClient);
+        this.isConnectedFlag = true;
+      } catch (error) {
+        this.isConnectedFlag = false;
+        if (error instanceof DatabaseAdapterError) {
+          throw error;
+        }
+        if (error instanceof Error) {
+          throw new DatabaseAdapterError(
+            `Failed to connect to DynamoDB: ${error.message}`,
+            "CONNECTION_FAILED"
+          );
+        }
+        throw new DatabaseAdapterError(
+          "Failed to connect to DynamoDB: Unknown error",
+          "CONNECTION_FAILED"
+        );
+      }
+    });
+  }
+  async disconnect() {
+    try {
+      if (this.dynamoDBClient) {
+        this.dynamoDBClient.destroy();
+      }
+      this.isConnectedFlag = false;
+      this.client = void 0;
+      this.dynamoDBClient = void 0;
+    } catch (error) {
+      console.warn("Error disconnecting from DynamoDB:", error);
+      this.isConnectedFlag = false;
+      this.client = void 0;
+      this.dynamoDBClient = void 0;
+    }
+  }
+  isConnected() {
+    return this.isConnectedFlag && this.client !== void 0;
+  }
+  async healthCheck() {
+    try {
+      const client = this.getClient();
+      await client.send(new import_lib_dynamodb2.ScanCommand({ TableName: "fake_table", Limit: 1 }));
+      return true;
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("ResourceNotFoundException")) {
+        return true;
+      }
+      return false;
+    }
+  }
+  async selectOne(tableName, where, options) {
+    try {
+      const client = this.getClient();
+      const key = this.buildKey(where);
+      const params = {
+        TableName: tableName,
+        Key: key
+      };
+      if (options == null ? void 0 : options.projection) {
+        const { projection, names } = this.buildProjection(options.projection);
+        params.ProjectionExpression = projection;
+        if (Object.keys(names).length > 0) {
+          params.ExpressionAttributeNames = names;
+        }
+      }
+      const command = new import_lib_dynamodb2.GetCommand(params);
+      const result = await client.send(command);
+      return result.Item || null;
+    } catch (error) {
+      throw this.handleError(error, "selectOne");
+    }
+  }
+  async selectMany(tableName, where, options) {
+    var _a, _b, _c;
+    try {
+      const client = this.getClient();
+      let command;
+      let items = [];
+      let scannedCount = 0;
+      const isKeyQuery = where && this.isKeyQuery(where);
+      if (isKeyQuery) {
+        const { keyConditionExpression, expressionAttributeValues, names } = this.buildKeyConditionExpression(where);
+        const params = {
+          TableName: tableName,
+          KeyConditionExpression: keyConditionExpression,
+          ExpressionAttributeValues: expressionAttributeValues,
+          Limit: options == null ? void 0 : options.limit,
+          ScanIndexForward: ((_b = (_a = options == null ? void 0 : options.orderBy) == null ? void 0 : _a[0]) == null ? void 0 : _b.direction) === "DESC" ? false : true,
+          ConsistentRead: options == null ? void 0 : options.consistent
+        };
+        if (Object.keys(names).length > 0) {
+          params.ExpressionAttributeNames = names;
+        }
+        if (options == null ? void 0 : options.projection) {
+          const { projection, names: projNames } = this.buildProjection(options.projection);
+          params.ProjectionExpression = projection;
+          if (Object.keys(projNames).length > 0) {
+            params.ExpressionAttributeNames = { ...params.ExpressionAttributeNames, ...projNames };
+          }
+        }
+        command = new import_lib_dynamodb2.QueryCommand(params);
+      } else {
+        const params = {
+          TableName: tableName,
+          Limit: options == null ? void 0 : options.limit
+        };
+        if (where && Object.keys(where).length > 0) {
+          const { filterExpression, expressionAttributeValues, names } = this.buildFilterExpression(where);
+          params.FilterExpression = filterExpression;
+          params.ExpressionAttributeValues = expressionAttributeValues;
+          if (Object.keys(names).length > 0) {
+            params.ExpressionAttributeNames = names;
+          }
+        }
+        if (options == null ? void 0 : options.projection) {
+          const { projection, names: projNames } = this.buildProjection(options.projection);
+          params.ProjectionExpression = projection;
+          if (Object.keys(projNames).length > 0) {
+            params.ExpressionAttributeNames = { ...params.ExpressionAttributeNames, ...projNames };
+          }
+        }
+        command = new import_lib_dynamodb2.ScanCommand(params);
+      }
+      const result = await client.send(command);
+      items = result.Items || [];
+      scannedCount = result.ScannedCount || 0;
+      if (!isKeyQuery && ((_c = options == null ? void 0 : options.orderBy) == null ? void 0 : _c.length)) {
+        const { field, direction } = options.orderBy[0];
+        items = [...items].sort((a, b) => {
+          if (a[field] < b[field]) return direction === "DESC" ? 1 : -1;
+          if (a[field] > b[field]) return direction === "DESC" ? -1 : 1;
+          return 0;
+        });
+      }
+      return {
+        items,
+        total: items.length,
+        hasMore: result.LastEvaluatedKey !== void 0,
+        nextOffset: (options == null ? void 0 : options.offset) ? options.offset + items.length : void 0
+      };
+    } catch (error) {
+      throw this.handleError(error, "selectMany");
+    }
+  }
+  async createOne(tableName, data) {
+    try {
+      const client = this.getClient();
+      const command = new import_lib_dynamodb2.PutCommand({
+        TableName: tableName,
+        Item: data
+      });
+      await client.send(command);
+      return data;
+    } catch (error) {
+      throw this.handleError(error, "createOne");
+    }
+  }
+  async createMany(tableName, data, options) {
+    try {
+      if (!Array.isArray(data)) {
+        throw new DatabaseAdapterError(
+          "createMany requires an array of records",
+          "INVALID_INPUT"
+        );
+      }
+      const client = this.getClient();
+      const batchSize = 25;
+      let successful = 0;
+      let failed = 0;
+      const errors = [];
+      const items = [];
+      for (let i = 0; i < data.length; i += batchSize) {
+        const batch = data.slice(i, i + batchSize);
+        const requestItems = batch.map((item) => ({
+          PutRequest: { Item: item }
+        }));
+        try {
+          const command = new import_lib_dynamodb2.BatchWriteCommand({
+            RequestItems: {
+              [tableName]: requestItems
+            }
+          });
+          await client.send(command);
+          successful += batch.length;
+          items.push(...batch);
+        } catch (error) {
+          if (options == null ? void 0 : options.stopOnError) {
+            throw error;
+          }
+          failed += batch.length;
+          batch.forEach((_, index) => {
+            errors.push({
+              index: i + index,
+              error: error instanceof Error ? error.message : "Unknown error"
+            });
+          });
+        }
+      }
+      return {
+        items,
+        result: { successful, failed, errors: errors.length > 0 ? errors : void 0 }
+      };
+    } catch (error) {
+      throw this.handleError(error, "createMany");
+    }
+  }
+  async updateOne(tableName, update, where) {
+    try {
+      const client = this.getClient();
+      const key = this.buildKey(where);
+      const existing = await client.send(new import_lib_dynamodb2.GetCommand({ TableName: tableName, Key: key }));
+      if (!existing.Item) {
+        throw new DatabaseAdapterError(
+          `Record not found`,
+          "NOT_FOUND"
+        );
+      }
+      const { updateExpression, expressionAttributeValues, names } = this.buildUpdateExpression(update);
+      const params = {
+        TableName: tableName,
+        Key: key,
+        UpdateExpression: updateExpression,
+        ReturnValues: "ALL_NEW"
+      };
+      if (Object.keys(expressionAttributeValues).length > 0) {
+        params.ExpressionAttributeValues = expressionAttributeValues;
+      }
+      if (Object.keys(names).length > 0) {
+        params.ExpressionAttributeNames = names;
+      }
+      const command = new import_lib_dynamodb2.UpdateCommand(params);
+      const result = await client.send(command);
+      return result.Attributes;
+    } catch (error) {
+      throw this.handleError(error, "updateOne");
+    }
+  }
+  async updateMany(tableName, update, where, options) {
+    try {
+      const selectResult = await this.selectMany(
+        tableName,
+        where,
+        { limit: options == null ? void 0 : options.limit }
+      );
+      let successful = 0;
+      let failed = 0;
+      const errors = [];
+      const items = [];
+      for (let i = 0; i < selectResult.items.length; i++) {
+        try {
+          const item = selectResult.items[i];
+          const key = this.extractKey(item);
+          const updated = await this.updateOne(tableName, update, key);
+          successful++;
+          items.push(updated);
+        } catch (error) {
+          failed++;
+          errors.push({
+            index: i,
+            error: error instanceof Error ? error.message : "Unknown error"
+          });
+        }
+      }
+      return {
+        items,
+        result: { successful, failed, errors: errors.length > 0 ? errors : void 0 }
+      };
+    } catch (error) {
+      throw this.handleError(error, "updateMany");
+    }
+  }
+  async deleteOne(tableName, where) {
+    try {
+      const client = this.getClient();
+      const key = this.buildKey(where);
+      const getResult = await client.send(new import_lib_dynamodb2.GetCommand({
+        TableName: tableName,
+        Key: key
+      }));
+      if (!getResult.Item) {
+        return { success: false, deletedCount: 0 };
+      }
+      const command = new import_lib_dynamodb2.DeleteCommand({
+        TableName: tableName,
+        Key: key
+      });
+      await client.send(command);
+      return { success: true, deletedCount: 1 };
+    } catch (error) {
+      throw this.handleError(error, "deleteOne");
+    }
+  }
+  async deleteMany(tableName, where, options) {
+    try {
+      const selectResult = await this.selectMany(
+        tableName,
+        where,
+        { limit: options == null ? void 0 : options.limit }
+      );
+      let successful = 0;
+      let failed = 0;
+      const errors = [];
+      for (let i = 0; i < selectResult.items.length; i++) {
+        try {
+          const item = selectResult.items[i];
+          const key = this.extractKey(item);
+          await this.deleteOne(tableName, key);
+          successful++;
+        } catch (error) {
+          failed++;
+          errors.push({
+            index: i,
+            error: error instanceof Error ? error.message : "Unknown error"
+          });
+        }
+      }
+      return {
+        success: failed === 0,
+        deletedCount: successful,
+        result: { successful, failed, errors: errors.length > 0 ? errors : void 0 }
+      };
+    } catch (error) {
+      throw this.handleError(error, "deleteMany");
+    }
+  }
+  async executeRaw(query, params) {
+    throw new DatabaseAdapterError(
+      "executeRaw is not implemented for DynamoDB. Use native DynamoDB syntax instead.",
+      "NOT_IMPLEMENTED"
+    );
+  }
+  // ============ Private Helper Methods ============
+  validateConfig(config) {
+    if (!config) {
+      throw new DatabaseAdapterError(
+        "DynamoDB configuration is required",
+        "INVALID_CONFIG"
+      );
+    }
+    if (!config.region || config.region.trim() === "") {
+      throw new DatabaseAdapterError(
+        "DynamoDB region is required",
+        "MISSING_REGION"
+      );
+    }
+    if (config.accessKeyId && !config.secretAccessKey) {
+      throw new DatabaseAdapterError(
+        "secretAccessKey is required when accessKeyId is provided",
+        "INVALID_CREDENTIALS"
+      );
+    }
+    if (config.secretAccessKey && !config.accessKeyId) {
+      throw new DatabaseAdapterError(
+        "accessKeyId is required when secretAccessKey is provided",
+        "INVALID_CREDENTIALS"
+      );
+    }
+  }
+  getClient() {
+    if (!this.isConnectedFlag || !this.client) {
+      throw new DatabaseAdapterError(
+        "DynamoDB client is not connected. Call connect() first.",
+        "NOT_CONNECTED"
+      );
+    }
+    return this.client;
+  }
+  buildKey(where) {
+    const key = {};
+    for (const [field, condition] of Object.entries(where)) {
+      if (condition == null) {
+        continue;
+      }
+      if (typeof condition === "object" && "value" in condition) {
+        key[field] = condition.value;
+      } else {
+        key[field] = condition;
+      }
+    }
+    return key;
+  }
+  extractKey(item) {
+    return {
+      id: {
+        operator: "=",
+        value: item.id
+      }
+    };
+  }
+  isKeyQuery(where) {
+    return Object.keys(where).some((key) => {
+      if (key !== "id") return false;
+      const cond = where[key];
+      if (typeof cond === "object" && "operator" in cond) {
+        const unsupportedInKey = ["IN", "NOT_IN"];
+        return !unsupportedInKey.includes(cond.operator);
+      }
+      return true;
+    });
+  }
+  buildProjection(fields) {
+    const names = {};
+    const projectionParts = [];
+    for (const field of fields) {
+      if (RESERVED_KEYWORDS.has(field.toUpperCase())) {
+        const placeholder = `#${field}`;
+        names[placeholder] = field;
+        projectionParts.push(placeholder);
+      } else {
+        projectionParts.push(field);
+      }
+    }
+    return {
+      projection: projectionParts.join(", "),
+      names
+    };
+  }
+  buildKeyConditionExpression(where) {
+    const parts = [];
+    const values = {};
+    const names = {};
+    let valueIndex = 0;
+    for (const [field, condition] of Object.entries(where)) {
+      const valueKey = `:val${valueIndex}`;
+      const cond = condition;
+      const fieldPlaceholder = RESERVED_KEYWORDS.has(field.toUpperCase()) ? `#${field}` : field;
+      if (RESERVED_KEYWORDS.has(field.toUpperCase())) {
+        names[fieldPlaceholder] = field;
+      }
+      if (typeof cond === "object" && "operator" in cond) {
+        const operator = cond.operator;
+        switch (operator) {
+          case "=":
+            parts.push(`${fieldPlaceholder} = ${valueKey}`);
+            values[valueKey] = cond.value;
+            break;
+          case "!=":
+            parts.push(`${fieldPlaceholder} <> ${valueKey}`);
+            values[valueKey] = cond.value;
+            break;
+          case ">":
+            parts.push(`${fieldPlaceholder} > ${valueKey}`);
+            values[valueKey] = cond.value;
+            break;
+          case ">=":
+            parts.push(`${fieldPlaceholder} >= ${valueKey}`);
+            values[valueKey] = cond.value;
+            break;
+          case "<":
+            parts.push(`${fieldPlaceholder} < ${valueKey}`);
+            values[valueKey] = cond.value;
+            break;
+          case "<=":
+            parts.push(`${fieldPlaceholder} <= ${valueKey}`);
+            values[valueKey] = cond.value;
+            break;
+          case "BEGINS_WITH":
+            parts.push(`begins_with(${fieldPlaceholder}, ${valueKey})`);
+            values[valueKey] = cond.value;
+            break;
+          case "IN":
+            const inValues = cond.value.map((v, i) => `:inval${valueIndex}_${i}`);
+            cond.value.forEach((v, i) => {
+              values[`:inval${valueIndex}_${i}`] = v;
+            });
+            parts.push(`${fieldPlaceholder} IN (${inValues.join(", ")})`);
+            valueIndex += cond.value.length - 1;
+            break;
+          default:
+            throw new DatabaseAdapterError(
+              `Unsupported operator: ${operator}`,
+              "UNSUPPORTED_OPERATOR"
+            );
+        }
+      } else {
+        parts.push(`${fieldPlaceholder} = ${valueKey}`);
+        values[valueKey] = cond;
+      }
+      valueIndex++;
+    }
+    return {
+      keyConditionExpression: parts.join(" AND "),
+      expressionAttributeValues: Object.keys(values).length > 0 ? values : {},
+      names
+    };
+  }
+  buildFilterExpression(where) {
+    const parts = [];
+    const values = {};
+    const names = {};
+    let valueIndex = 0;
+    for (const [field, condition] of Object.entries(where)) {
+      const valueKey = `:val${valueIndex}`;
+      const cond = condition;
+      const fieldPlaceholder = RESERVED_KEYWORDS.has(field.toUpperCase()) ? `#${field}` : field;
+      if (RESERVED_KEYWORDS.has(field.toUpperCase())) {
+        names[fieldPlaceholder] = field;
+      }
+      if (typeof cond === "object" && "operator" in cond) {
+        const operator = cond.operator;
+        switch (operator) {
+          case "=":
+            parts.push(`${fieldPlaceholder} = ${valueKey}`);
+            values[valueKey] = cond.value;
+            break;
+          case "!=":
+            parts.push(`${fieldPlaceholder} <> ${valueKey}`);
+            values[valueKey] = cond.value;
+            break;
+          case ">":
+            parts.push(`${fieldPlaceholder} > ${valueKey}`);
+            values[valueKey] = cond.value;
+            break;
+          case ">=":
+            parts.push(`${fieldPlaceholder} >= ${valueKey}`);
+            values[valueKey] = cond.value;
+            break;
+          case "<":
+            parts.push(`${fieldPlaceholder} < ${valueKey}`);
+            values[valueKey] = cond.value;
+            break;
+          case "<=":
+            parts.push(`${fieldPlaceholder} <= ${valueKey}`);
+            values[valueKey] = cond.value;
+            break;
+          case "BEGINS_WITH":
+            parts.push(`begins_with(${fieldPlaceholder}, ${valueKey})`);
+            values[valueKey] = cond.value;
+            break;
+          case "IN":
+            const inValues = cond.value.map((v, i) => `:inval${valueIndex}_${i}`);
+            cond.value.forEach((v, i) => {
+              values[`:inval${valueIndex}_${i}`] = v;
+            });
+            parts.push(`${fieldPlaceholder} IN (${inValues.join(", ")})`);
+            valueIndex += cond.value.length - 1;
+            break;
+          case "NOT_IN":
+            const notInValues = cond.value.map((v, i) => `:notinval${valueIndex}_${i}`);
+            cond.value.forEach((v, i) => {
+              values[`:notinval${valueIndex}_${i}`] = v;
+            });
+            parts.push(`NOT ${fieldPlaceholder} IN (${notInValues.join(", ")})`);
+            valueIndex += cond.value.length - 1;
+            break;
+          default:
+            throw new DatabaseAdapterError(
+              `Unsupported operator: ${operator}`,
+              "UNSUPPORTED_OPERATOR"
+            );
+        }
+      } else {
+        parts.push(`${fieldPlaceholder} = ${valueKey}`);
+        values[valueKey] = cond;
+      }
+      valueIndex++;
+    }
+    return {
+      filterExpression: parts.join(" AND "),
+      expressionAttributeValues: Object.keys(values).length > 0 ? values : {},
+      names
+    };
+  }
+  buildUpdateExpression(update) {
+    const setParts = [];
+    const values = {};
+    const names = {};
+    let valueIndex = 0;
+    for (const [field, value] of Object.entries(update)) {
+      const valueKey = `:val${valueIndex}`;
+      const fieldPlaceholder = RESERVED_KEYWORDS.has(field.toUpperCase()) ? `#${field}` : field;
+      if (RESERVED_KEYWORDS.has(field.toUpperCase())) {
+        names[fieldPlaceholder] = field;
+      }
+      setParts.push(`${fieldPlaceholder} = ${valueKey}`);
+      values[valueKey] = value;
+      valueIndex++;
+    }
+    return {
+      updateExpression: `SET ${setParts.join(", ")}`,
+      expressionAttributeValues: Object.keys(values).length > 0 ? values : {},
+      names
+    };
+  }
+  handleError(error, operation) {
+    if (error instanceof DatabaseAdapterError) {
+      return error;
+    }
+    if (error instanceof Error) {
+      return new DatabaseAdapterError(
+        `${operation} failed: ${error.message}`,
+        "OPERATION_FAILED",
+        { originalError: error.message }
+      );
+    }
+    return new DatabaseAdapterError(
+      `${operation} failed: Unknown error`,
+      "OPERATION_FAILED"
+    );
+  }
+};
+DynamoService = __decorateClass([
+  (0, import_fluxor_cloud.Service)()
+], DynamoService);
+
+// src/mongo/mongo.ts
+var import_mongodb = require("mongodb");
+var MongoService = class {
+  constructor() {
+    this.isConnectedFlag = false;
+  }
+  setConfig(config) {
+    this.config = config;
+  }
+  connect() {
+    if (!this.config) {
+      return Promise.reject(new DatabaseAdapterError(
+        "No configuration provided. Call setConfig() first.",
+        "INVALID_CONFIG"
+      ));
+    }
+    return Promise.resolve().then(async () => {
+      var _a, _b;
+      try {
+        this.validateConfig(this.config);
+        this.client = new import_mongodb.MongoClient(this.config.uri, {
+          retryWrites: (_a = this.config.retryWrites) != null ? _a : true,
+          w: (_b = this.config.w) != null ? _b : "majority",
+          authSource: this.config.authSource
+        });
+        await this.client.connect();
+        this.db = this.client.db(this.config.dbName);
+        await this.db.admin().ping();
+        this.isConnectedFlag = true;
+      } catch (error) {
+        this.isConnectedFlag = false;
+        throw this.handleError(error, "connect");
+      }
+    });
+  }
+  async disconnect() {
+    try {
+      if (this.client) {
+        await this.client.close();
+      }
+      this.isConnectedFlag = false;
+      this.db = void 0;
+      this.client = void 0;
+    } catch (error) {
+      console.warn("Error disconnecting from MongoDB:", error);
+      this.isConnectedFlag = false;
+    }
+  }
+  isConnected() {
+    return this.isConnectedFlag && this.client !== void 0;
+  }
+  async healthCheck() {
+    try {
+      const db = this.getDb();
+      await db.admin().ping();
+      return true;
+    } catch (error) {
+      return false;
+    }
+  }
+  async selectOne(tableName, where, options) {
+    try {
+      const collection = this.getCollection(tableName);
+      const filter = this.buildMongoFilter(where);
+      const findOptions = {};
+      if (Array.isArray(options == null ? void 0 : options.projection)) {
+        const projection = {};
+        for (const field of options.projection) {
+          if (typeof field === "string") {
+            projection[field] = 1;
+          }
+        }
+        if (Object.keys(projection).length > 0) {
+          findOptions.projection = projection;
+        }
+      }
+      const result = await collection.findOne(filter, findOptions);
+      if (result === null || result === void 0) {
+        return null;
+      }
+      return result;
+    } catch (error) {
+      throw this.handleError(error, "selectOne");
+    }
+  }
+  async selectMany(tableName, where, options) {
+    try {
+      const collection = this.getCollection(tableName);
+      const filter = where ? this.buildMongoFilter(where) : {};
+      const findOptions = {};
+      if (typeof (options == null ? void 0 : options.limit) === "number" && options.limit > 0) {
+        findOptions.limit = options.limit;
+      }
+      if (typeof (options == null ? void 0 : options.offset) === "number" && options.offset >= 0) {
+        findOptions.skip = options.offset;
+      }
+      if (Array.isArray(options == null ? void 0 : options.orderBy) && options.orderBy.length > 0) {
+        const sort = {};
+        for (const order of options.orderBy) {
+          if (typeof order === "object" && order !== null && "field" in order && "direction" in order) {
+            const field = order.field;
+            const direction = order.direction;
+            if (typeof field === "string" && (direction === "ASC" || direction === "DESC")) {
+              sort[field] = direction === "DESC" ? -1 : 1;
+            }
+          }
+        }
+        if (Object.keys(sort).length > 0) {
+          findOptions.sort = sort;
+        }
+      }
+      if (Array.isArray(options == null ? void 0 : options.projection)) {
+        const projection = {};
+        for (const field of options.projection) {
+          if (typeof field === "string") {
+            projection[field] = 1;
+          }
+        }
+        if (Object.keys(projection).length > 0) {
+          findOptions.projection = projection;
+        }
+      }
+      const items = await collection.find(filter, findOptions).toArray();
+      const total = await collection.countDocuments(filter);
+      const offset = typeof (options == null ? void 0 : options.offset) === "number" ? options.offset : 0;
+      const hasMore = offset + items.length < total;
+      return {
+        items,
+        total,
+        hasMore
+      };
+    } catch (error) {
+      throw this.handleError(error, "selectMany");
+    }
+  }
+  async createOne(tableName, data) {
+    try {
+      if (typeof data !== "object" || data === null) {
+        throw new DatabaseAdapterError(
+          "Data must be an object",
+          "INVALID_INPUT"
+        );
+      }
+      const collection = this.getCollection(tableName);
+      const result = await collection.insertOne(data);
+      return { ...data, _id: result.insertedId };
+    } catch (error) {
+      if (error instanceof DatabaseAdapterError) {
+        throw error;
+      }
+      throw this.handleError(error, "createOne");
+    }
+  }
+  async createMany(tableName, data, options) {
+    try {
+      if (!Array.isArray(data)) {
+        throw new DatabaseAdapterError(
+          "Data must be an array",
+          "INVALID_INPUT"
+        );
+      }
+      if (data.length === 0) {
+        return {
+          items: [],
+          result: {
+            successful: 0,
+            failed: 0
+          }
+        };
+      }
+      const collection = this.getCollection(tableName);
+      const stopOnError = typeof (options == null ? void 0 : options.stopOnError) === "boolean" ? options.stopOnError : false;
+      try {
+        const result = await collection.insertMany(
+          data,
+          {
+            ordered: stopOnError
+          }
+        );
+        const items = data.map((item, index) => {
+          const insertedId = result.insertedIds[index];
+          if (insertedId === null || insertedId === void 0) {
+            return item;
+          }
+          return {
+            ...item,
+            _id: insertedId
+          };
+        });
+        return {
+          items,
+          result: {
+            successful: items.length,
+            failed: 0
+          }
+        };
+      } catch (error) {
+        if (stopOnError) {
+          throw this.handleError(error, "createMany");
+        }
+        let insertedCount = 0;
+        if (error instanceof Error) {
+          const errorMsg = error.message;
+          if (errorMsg.includes("insertedCount") || errorMsg.includes("nInserted")) {
+            const match = errorMsg.match(/\d+/);
+            if (match) {
+              insertedCount = parseInt(match[0], 10);
+            }
+          }
+        }
+        const failed = data.length - insertedCount;
+        const errorMessage = error instanceof Error ? error.message : "Unknown error during batch insert";
+        return {
+          items: insertedCount > 0 ? data.slice(0, insertedCount) : [],
+          result: {
+            successful: insertedCount,
+            failed,
+            errors: failed > 0 ? [
+              {
+                index: insertedCount,
+                error: errorMessage
+              }
+            ] : void 0
+          }
+        };
+      }
+    } catch (error) {
+      throw this.handleError(error, "createMany");
+    }
+  }
+  async updateOne(tableName, update, where) {
+    try {
+      const collection = this.getCollection(tableName);
+      const filter = this.buildMongoFilter(where);
+      const updateDoc = this.buildMongoUpdate(update);
+      const raw = await collection.findOneAndUpdate(filter, updateDoc, {
+        returnDocument: "after"
+      });
+      const doc = raw && typeof raw === "object" && "value" in raw ? raw.value : raw;
+      if (doc === null || doc === void 0) {
+        throw new DatabaseAdapterError(
+          "Document not found for update",
+          "NOT_FOUND"
+        );
+      }
+      return doc;
+    } catch (error) {
+      if (error instanceof DatabaseAdapterError) {
+        throw error;
+      }
+      throw this.handleError(error, "updateOne");
+    }
+  }
+  async updateMany(tableName, update, where, options) {
+    try {
+      const collection = this.getCollection(tableName);
+      const filter = where ? this.buildMongoFilter(where) : {};
+      const updateDoc = this.buildMongoUpdate(update);
+      const limit = typeof (options == null ? void 0 : options.limit) === "number" && options.limit > 0 ? options.limit : void 0;
+      if (limit) {
+        const matchingDocs = await collection.find(filter).limit(limit).toArray();
+        if (matchingDocs.length === 0) {
+          return {
+            items: [],
+            result: { successful: 0, failed: 0 }
+          };
+        }
+        const ids = matchingDocs.map((doc) => {
+          const docWithId = doc;
+          return docWithId._id;
+        }).filter((id) => id !== null && id !== void 0);
+        if (ids.length === 0) {
+          return {
+            items: [],
+            result: { successful: 0, failed: 0 }
+          };
+        }
+        const idFilter = { _id: { $in: ids } };
+        const updateResult = await collection.updateMany(idFilter, updateDoc);
+        return {
+          items: matchingDocs,
+          result: {
+            successful: updateResult.modifiedCount,
+            failed: 0
+          }
+        };
+      } else {
+        const updateResult = await collection.updateMany(filter, updateDoc);
+        const updatedDocs = await collection.find(filter).toArray();
+        return {
+          items: updatedDocs,
+          result: {
+            successful: updateResult.modifiedCount,
+            failed: 0
+          }
+        };
+      }
+    } catch (error) {
+      throw this.handleError(error, "updateMany");
+    }
+  }
+  async deleteOne(tableName, where) {
+    try {
+      const collection = this.getCollection(tableName);
+      const filter = this.buildMongoFilter(where);
+      const result = await collection.deleteOne(filter);
+      return {
+        success: result.deletedCount > 0,
+        deletedCount: result.deletedCount
+      };
+    } catch (error) {
+      throw this.handleError(error, "deleteOne");
+    }
+  }
+  async deleteMany(tableName, where, options) {
+    try {
+      const collection = this.getCollection(tableName);
+      const filter = where ? this.buildMongoFilter(where) : {};
+      let deletedCount = 0;
+      if (typeof (options == null ? void 0 : options.limit) === "number" && options.limit > 0) {
+        const docsToDelete = await collection.find(filter).limit(options.limit).toArray();
+        if (docsToDelete.length === 0) {
+          return {
+            success: true,
+            deletedCount: 0,
+            result: {
+              successful: 0,
+              failed: 0
+            }
+          };
+        }
+        const ids = docsToDelete.map((doc) => {
+          const docWithId = doc;
+          return docWithId._id;
+        }).filter((id) => id !== null && id !== void 0);
+        if (ids.length === 0) {
+          return {
+            success: true,
+            deletedCount: 0,
+            result: {
+              successful: 0,
+              failed: 0
+            }
+          };
+        }
+        const idFilter = { _id: { $in: ids } };
+        const result = await collection.deleteMany(idFilter);
+        deletedCount = result.deletedCount;
+      } else {
+        const result = await collection.deleteMany(filter);
+        deletedCount = result.deletedCount;
+      }
+      return {
+        success: true,
+        deletedCount,
+        result: {
+          successful: deletedCount,
+          failed: 0
+        }
+      };
+    } catch (error) {
+      throw this.handleError(error, "deleteMany");
+    }
+  }
+  async executeRaw(query, params) {
+    throw new DatabaseAdapterError(
+      "executeRaw not fully implemented for this example",
+      "NOT_IMPLEMENTED"
+    );
+  }
+  // ============ Private Helpers ============
+  validateConfig(config) {
+    if (!config || !config.uri || !config.dbName) {
+      throw new DatabaseAdapterError(
+        "MongoDB configuration requires uri and dbName",
+        "INVALID_CONFIG"
+      );
+    }
+  }
+  getDb() {
+    if (!this.isConnectedFlag || !this.db) {
+      throw new DatabaseAdapterError(
+        "MongoDB client is not connected. Call connect() first.",
+        "NOT_CONNECTED"
+      );
+    }
+    return this.db;
+  }
+  getCollection(tableName) {
+    if (typeof tableName !== "string" || !tableName) {
+      throw new DatabaseAdapterError(
+        "Table name must be a non-empty string",
+        "INVALID_TABLE_NAME"
+      );
+    }
+    return this.getDb().collection(tableName);
+  }
+  buildMongoFilter(where) {
+    const filter = {};
+    if (typeof where !== "object" || where === null) {
+      return filter;
+    }
+    for (const [field, condition] of Object.entries(where)) {
+      if (!field || typeof field !== "string") {
+        continue;
+      }
+      if (condition === null || condition === void 0) {
+        continue;
+      }
+      if (typeof condition === "object" && "operator" in condition) {
+        const condObj = condition;
+        const operator = condObj["operator"];
+        const value = condObj["value"];
+        if (typeof operator !== "string" || !this.isValidOperator(operator)) {
+          continue;
+        }
+        if (value === null || value === void 0) {
+          continue;
+        }
+        const op = operator;
+        switch (op) {
+          case "=":
+            filter[field] = value;
+            break;
+          case "!=":
+            filter[field] = { $ne: value };
+            break;
+          case ">":
+            filter[field] = { $gt: value };
+            break;
+          case ">=":
+            filter[field] = { $gte: value };
+            break;
+          case "<":
+            filter[field] = { $lt: value };
+            break;
+          case "<=":
+            filter[field] = { $lte: value };
+            break;
+          case "IN":
+            if (Array.isArray(value)) {
+              filter[field] = { $in: value };
+            } else {
+              filter[field] = { $in: [value] };
+            }
+            break;
+          case "NOT_IN":
+            if (Array.isArray(value)) {
+              filter[field] = { $nin: value };
+            } else {
+              filter[field] = { $nin: [value] };
+            }
+            break;
+          case "BETWEEN":
+            if (Array.isArray(value) && value.length === 2) {
+              const [min, max] = value;
+              if (min !== null && min !== void 0 && max !== null && max !== void 0) {
+                filter[field] = { $gte: min, $lte: max };
+              }
+            }
+            break;
+          case "LIKE":
+            if (typeof value === "string") {
+              filter[field] = { $regex: value, $options: "i" };
+            }
+            break;
+          case "BEGINS_WITH":
+            if (typeof value === "string") {
+              filter[field] = { $regex: `^${value}`, $options: "i" };
+            }
+            break;
+          case "EXISTS":
+            if (typeof value === "boolean") {
+              filter[field] = { $exists: value };
+            }
+            break;
+        }
+      } else {
+        filter[field] = condition;
+      }
+    }
+    return filter;
+  }
+  isValidOperator(op) {
+    const validOperators = ["=", "!=", ">", ">=", "<", "<=", "IN", "NOT_IN", "BETWEEN", "LIKE", "BEGINS_WITH", "EXISTS"];
+    return validOperators.includes(op);
+  }
+  buildMongoUpdate(update) {
+    const mongoUpdate = {};
+    const setFields = {};
+    const incrementFields = {};
+    if (typeof update !== "object" || update === null) {
+      return mongoUpdate;
+    }
+    for (const [field, value] of Object.entries(update)) {
+      if (!field || typeof field !== "string") {
+        continue;
+      }
+      if (value === null || value === void 0) {
+        continue;
+      }
+      if (typeof value === "object" && "$increment" in value) {
+        const val = value;
+        if (typeof val["$increment"] === "number") {
+          incrementFields[field] = val["$increment"];
+        }
+      } else {
+        setFields[field] = value;
+      }
+    }
+    if (Object.keys(setFields).length > 0) {
+      mongoUpdate.$set = setFields;
+    }
+    if (Object.keys(incrementFields).length > 0) {
+      mongoUpdate.$inc = incrementFields;
+    }
+    return mongoUpdate;
+  }
+  handleError(error, operation) {
+    if (error instanceof DatabaseAdapterError) {
+      return error;
+    }
+    if (error instanceof Error) {
+      return new DatabaseAdapterError(
+        `${operation} failed: ${error.message}`,
+        "OPERATION_FAILED",
+        { originalError: error.message }
+      );
+    }
+    return new DatabaseAdapterError(
+      `${operation} failed: Unknown error`,
+      "OPERATION_FAILED"
+    );
+  }
+};
+
+// src/fluentapi.ts
+var eq = (value) => ({ operator: "=", value });
+var neq = (value) => ({ operator: "!=", value });
+var gt = (value) => ({ operator: ">", value });
+var gte = (value) => ({ operator: ">=", value });
+var lt = (value) => ({ operator: "<", value });
+var lte = (value) => ({ operator: "<=", value });
+var between = (min, max) => ({ operator: "BETWEEN", value: [min, max] });
+var anyOf = (values) => ({ operator: "IN", value: values });
+var noneOf = (values) => ({ operator: "NOT_IN", value: values });
+var startsWith = (value) => ({ operator: "BEGINS_WITH", value });
+var like = (value) => ({ operator: "LIKE", value });
+var exists = (value = true) => ({ operator: "EXISTS", value });
+var equals = eq;
+var notEquals = neq;
+var inList = anyOf;
+var notInList = noneOf;
+
+// src/index.ts
+var useDynamo = () => {
+  return (0, import_fluxor_cloud2.resolveService)(DynamoService);
+};
+var useMongo = () => {
+  return (0, import_fluxor_cloud2.resolveService)(MongoService);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DynamoService,
+  MongoService,
+  anyOf,
+  between,
+  eq,
+  equals,
+  exists,
+  gt,
+  gte,
+  inList,
+  like,
+  lt,
+  lte,
+  neq,
+  noneOf,
+  notEquals,
+  notInList,
+  startsWith,
+  useDynamo,
+  useMongo
+});