@farming-labs/orm-dynamodb 0.0.37

package/dist/index.cjs

@@ -0,0 +1,1064 @@
+"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);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  createDynamodbDriver: () => createDynamodbDriver,
+  normalizeDynamoDbDocumentClient: () => normalizeDynamoDbDocumentClient
+});
+module.exports = __toCommonJS(index_exports);
+var import_node_crypto = require("crypto");
+var import_lib_dynamodb = require("@aws-sdk/lib-dynamodb");
+var import_orm = require("@farming-labs/orm");
+var ormPrimaryKey = "__orm_pk";
+var ormKindKey = "__orm_kind";
+var ormTargetKey = "__orm_target";
+var ormRecordKind = "record";
+var ormUniqueKind = "unique";
+var manifestCache = /* @__PURE__ */ new WeakMap();
+function getManifest(schema) {
+  const cached = manifestCache.get(schema);
+  if (cached) return cached;
+  const next = (0, import_orm.createManifest)(schema);
+  manifestCache.set(schema, next);
+  return next;
+}
+function isRecord(value) {
+  return !!value && typeof value === "object";
+}
+function normalizeDecimalString(value) {
+  const trimmed = value.trim();
+  const match = /^(-?\d+)(?:\.(\d+))?$/.exec(trimmed);
+  if (!match) {
+    return trimmed;
+  }
+  const [, integerPart, fractionalPart] = match;
+  if (!fractionalPart) {
+    return integerPart;
+  }
+  const normalizedFraction = fractionalPart.replace(/0+$/g, "");
+  return normalizedFraction.length ? `${integerPart}.${normalizedFraction}` : integerPart;
+}
+function isDocumentClientLike(client) {
+  const constructorName = client?.constructor?.name ?? "";
+  return constructorName.includes("DocumentClient") || isRecord(client.config) && "translateConfig" in client.config;
+}
+function createDocumentClient(client, override) {
+  if (override) return override;
+  if (isDocumentClientLike(client)) {
+    return client;
+  }
+  return import_lib_dynamodb.DynamoDBDocumentClient.from(client, {
+    marshallOptions: {
+      removeUndefinedValues: true
+    }
+  });
+}
+function applyDefault(value, field) {
+  if (value !== void 0) return value;
+  if (field.generated === "id") return (0, import_node_crypto.randomUUID)();
+  if (field.generated === "now") return /* @__PURE__ */ new Date();
+  if (typeof field.defaultValue === "function") {
+    return field.defaultValue();
+  }
+  return field.defaultValue;
+}
+function isComparable(value) {
+  return value instanceof Date || typeof value === "number" || typeof value === "string" || typeof value === "bigint";
+}
+function evaluateFilter(value, filter) {
+  if (!(0, import_orm.isOperatorFilterObject)(filter)) {
+    return (0, import_orm.equalValues)(value, filter);
+  }
+  if ("eq" in filter && !(0, import_orm.equalValues)(value, filter.eq)) return false;
+  if ("not" in filter && (0, import_orm.equalValues)(value, filter.not)) return false;
+  if ("in" in filter) {
+    const values = Array.isArray(filter.in) ? filter.in : [];
+    if (!values.some((candidate) => (0, import_orm.equalValues)(candidate, value))) return false;
+  }
+  if ("contains" in filter) {
+    if (typeof value !== "string" || typeof filter.contains !== "string") return false;
+    if (!value.includes(filter.contains)) return false;
+  }
+  if ("gt" in filter) {
+    if (!isComparable(value) || value <= filter.gt) return false;
+  }
+  if ("gte" in filter) {
+    if (!isComparable(value) || value < filter.gte) return false;
+  }
+  if ("lt" in filter) {
+    if (!isComparable(value) || value >= filter.lt) return false;
+  }
+  if ("lte" in filter) {
+    if (!isComparable(value) || value > filter.lte) return false;
+  }
+  return true;
+}
+function sortRows(rows, orderBy) {
+  if (!orderBy) return rows;
+  const entries = Object.entries(orderBy);
+  if (!entries.length) return rows;
+  return [...rows].sort((left, right) => {
+    for (const [field, direction] of entries) {
+      const a = left.data[field];
+      const b = right.data[field];
+      if ((0, import_orm.equalValues)(a, b)) continue;
+      if (a === void 0) return direction === "asc" ? -1 : 1;
+      if (b === void 0) return direction === "asc" ? 1 : -1;
+      if (a == null) return direction === "asc" ? -1 : 1;
+      if (b == null) return direction === "asc" ? 1 : -1;
+      if (a < b) return direction === "asc" ? -1 : 1;
+      if (a > b) return direction === "asc" ? 1 : -1;
+    }
+    return 0;
+  });
+}
+function pageRows(rows, skip, take) {
+  const start = skip ?? 0;
+  const end = take === void 0 ? void 0 : start + take;
+  return rows.slice(start, end);
+}
+function dynamodbConstraintError(target) {
+  const fields = Array.isArray(target) ? target.join(", ") : target ?? "unique fields";
+  const error = new Error(`DynamoDB unique constraint violation on ${fields}.`);
+  Object.assign(error, {
+    code: "ConditionalCheckFailedException",
+    target
+  });
+  return error;
+}
+function isUnsupportedTransactionWrite(error) {
+  if (!isRecord(error)) return false;
+  return error.name === "UnknownOperationException" || error.code === "UnknownOperationException" || String(error.message ?? "").includes("UnknownOperation");
+}
+function recordPk(docId) {
+  return `record#${docId}`;
+}
+function getStoredItemPk(item) {
+  const value = item[ormPrimaryKey];
+  return typeof value === "string" ? value : void 0;
+}
+function normalizeDynamoDbDocumentClient(client, documentClient) {
+  return createDocumentClient(client, documentClient);
+}
+function createDynamoDbDriverInternal(config) {
+  const documentClient = createDocumentClient(config.client, config.documentClient);
+  function getSupportedManifest(schema) {
+    const manifest = getManifest(schema);
+    for (const model of Object.values(manifest.models)) {
+      if (model.schema) {
+        throw new Error(
+          `The DynamoDB runtime does not support schema-qualified tables for model "${model.name}". Use flat table names instead.`
+        );
+      }
+      const idField = model.fields.id;
+      if (idField?.kind === "id" && idField.idType === "integer" && idField.generated === "increment") {
+        throw new Error(
+          `The DynamoDB runtime does not support generated integer ids for model "${model.name}". Use manual numeric ids or a string id instead.`
+        );
+      }
+    }
+    return manifest;
+  }
+  function getTableName(schema, modelName) {
+    const manifest = getSupportedManifest(schema);
+    return config.tables?.[modelName] ?? manifest.models[modelName].table;
+  }
+  function fieldTransform(modelName, fieldName) {
+    return config.transforms?.[modelName]?.[fieldName];
+  }
+  function encodeValue(modelName, field, value) {
+    if (value === void 0) return value;
+    if (value === null) return null;
+    const transform = fieldTransform(modelName, field.name);
+    if (transform?.encode) {
+      return transform.encode(value);
+    }
+    if (field.kind === "id" && field.idType === "integer") {
+      return Number(value);
+    }
+    if (field.kind === "enum") {
+      return String(value);
+    }
+    if (field.kind === "boolean") {
+      return Boolean(value);
+    }
+    if (field.kind === "integer") {
+      return Number(value);
+    }
+    if (field.kind === "bigint") {
+      return typeof value === "bigint" ? value.toString() : BigInt(value).toString();
+    }
+    if (field.kind === "decimal") {
+      return typeof value === "string" ? normalizeDecimalString(value) : String(value);
+    }
+    if (field.kind === "datetime") {
+      if (value instanceof Date) return value.toISOString();
+      return new Date(value).toISOString();
+    }
+    return value;
+  }
+  function decodeValue(modelName, field, value, docId) {
+    const transform = fieldTransform(modelName, field.name);
+    if (transform?.decode) {
+      return transform.decode(value);
+    }
+    if (value === void 0 && field.kind === "id" && docId !== void 0) {
+      if (field.idType === "integer") {
+        const numeric = Number(docId);
+        return Number.isFinite(numeric) ? numeric : void 0;
+      }
+      return docId;
+    }
+    if (value === void 0 || value === null) return value ?? null;
+    if (field.kind === "id" && field.idType === "integer") {
+      return Number(value);
+    }
+    if (field.kind === "enum") {
+      return String(value);
+    }
+    if (field.kind === "boolean") {
+      return Boolean(value);
+    }
+    if (field.kind === "integer") {
+      return Number(value);
+    }
+    if (field.kind === "bigint") {
+      return typeof value === "bigint" ? value : BigInt(value);
+    }
+    if (field.kind === "decimal") {
+      return normalizeDecimalString(String(value));
+    }
+    if (field.kind === "datetime") {
+      return value instanceof Date ? value : new Date(value);
+    }
+    return value;
+  }
+  function buildStoredRow(model, data) {
+    const stored = {};
+    const decoded = {};
+    for (const field of Object.values(model.fields)) {
+      const value = applyDefault(data[field.name], field);
+      if (value === void 0) continue;
+      const encoded = encodeValue(model.name, field, value);
+      stored[field.column] = encoded;
+      decoded[field.name] = decodeValue(model.name, field, encoded);
+    }
+    const idField = model.fields.id;
+    if (!idField) {
+      return {
+        docId: (0, import_node_crypto.randomUUID)(),
+        stored,
+        decoded
+      };
+    }
+    let idValue = decoded[idField.name];
+    if (idValue === void 0 || idValue === null) {
+      if (idField.idType === "integer") {
+        throw new Error(
+          `The DynamoDB runtime requires an explicit numeric id for model "${model.name}" when using manual integer ids.`
+        );
+      }
+      idValue = (0, import_node_crypto.randomUUID)();
+      const encodedId = encodeValue(model.name, idField, idValue);
+      stored[idField.column] = encodedId;
+      decoded[idField.name] = decodeValue(model.name, idField, encodedId);
+      idValue = decoded[idField.name];
+    }
+    return {
+      docId: String(idValue),
+      stored,
+      decoded
+    };
+  }
+  function buildUpdatedRow(model, current, data) {
+    const stored = {
+      ...current.stored
+    };
+    const decoded = {
+      ...current.data
+    };
+    for (const [fieldName, value] of Object.entries(data)) {
+      if (value === void 0) continue;
+      const field = model.fields[fieldName];
+      if (!field) {
+        throw new Error(`Unknown field "${fieldName}" on model "${model.name}".`);
+      }
+      if (field.name === "id" && !(0, import_orm.equalValues)(current.data.id, value)) {
+        throw new Error(
+          `The DynamoDB runtime does not support updating the id field for model "${model.name}".`
+        );
+      }
+      const encoded = encodeValue(model.name, field, value);
+      stored[field.column] = encoded;
+      decoded[field.name] = decodeValue(model.name, field, encoded);
+    }
+    return {
+      docId: current.docId,
+      stored,
+      decoded
+    };
+  }
+  async function scanAllItems(tableName) {
+    const items = [];
+    let exclusiveStartKey;
+    do {
+      const result = await documentClient.send(
+        new import_lib_dynamodb.ScanCommand({
+          TableName: tableName,
+          ExclusiveStartKey: exclusiveStartKey
+        })
+      );
+      items.push(...result.Items ?? []);
+      exclusiveStartKey = result.LastEvaluatedKey;
+    } while (exclusiveStartKey);
+    return items;
+  }
+  async function loadRowByPk(model, tableName, pk) {
+    const result = await documentClient.send(
+      new import_lib_dynamodb.GetCommand({
+        TableName: tableName,
+        Key: {
+          [ormPrimaryKey]: pk
+        }
+      })
+    );
+    const stored = result.Item;
+    if (!stored || stored[ormKindKey] !== ormRecordKind) {
+      return null;
+    }
+    const decoded = {};
+    const docId = pk.slice("record#".length);
+    for (const field of Object.values(model.fields)) {
+      decoded[field.name] = decodeValue(model.name, field, stored[field.column], docId);
+    }
+    return {
+      docId,
+      pk,
+      data: decoded,
+      stored
+    };
+  }
+  async function loadRows(schema, modelName) {
+    const model = getSupportedManifest(schema).models[modelName];
+    const tableName = getTableName(schema, modelName);
+    const items = await scanAllItems(tableName);
+    return items.filter((item) => item[ormKindKey] === ormRecordKind).map((stored) => {
+      const pk = getStoredItemPk(stored) ?? "";
+      const docId = pk.slice("record#".length);
+      const decoded = {};
+      for (const field of Object.values(model.fields)) {
+        decoded[field.name] = decodeValue(model.name, field, stored[field.column], docId);
+      }
+      return {
+        docId,
+        pk,
+        data: decoded,
+        stored
+      };
+    });
+  }
+  function normalizeFilterValue(model, fieldName, value) {
+    const field = model.fields[fieldName];
+    if (!field || value === void 0 || value === null) {
+      return value;
+    }
+    return decodeValue(model.name, field, encodeValue(model.name, field, value));
+  }
+  function evaluateModelFilter(model, fieldName, value, filter) {
+    if (!(0, import_orm.isOperatorFilterObject)(filter)) {
+      return (0, import_orm.equalValues)(value, normalizeFilterValue(model, fieldName, filter));
+    }
+    const normalized = {
+      ...filter.eq !== void 0 ? { eq: normalizeFilterValue(model, fieldName, filter.eq) } : {},
+      ...filter.not !== void 0 ? { not: normalizeFilterValue(model, fieldName, filter.not) } : {},
+      ...filter.in !== void 0 ? {
+        in: (Array.isArray(filter.in) ? filter.in : []).map(
+          (entry) => normalizeFilterValue(model, fieldName, entry)
+        )
+      } : {},
+      ...filter.contains !== void 0 ? { contains: String(filter.contains) } : {},
+      ...filter.gt !== void 0 ? { gt: normalizeFilterValue(model, fieldName, filter.gt) } : {},
+      ...filter.gte !== void 0 ? { gte: normalizeFilterValue(model, fieldName, filter.gte) } : {},
+      ...filter.lt !== void 0 ? { lt: normalizeFilterValue(model, fieldName, filter.lt) } : {},
+      ...filter.lte !== void 0 ? { lte: normalizeFilterValue(model, fieldName, filter.lte) } : {}
+    };
+    return evaluateFilter(value, normalized);
+  }
+  function matchesModelWhere(model, record, where) {
+    if (!where) return true;
+    if (where.AND && !where.AND.every((clause) => matchesModelWhere(model, record, clause))) {
+      return false;
+    }
+    if (where.OR && !where.OR.some((clause) => matchesModelWhere(model, record, clause))) {
+      return false;
+    }
+    if (where.NOT && matchesModelWhere(model, record, where.NOT)) {
+      return false;
+    }
+    for (const [key, filter] of Object.entries(where)) {
+      if (key === "AND" || key === "OR" || key === "NOT") continue;
+      if (!evaluateModelFilter(model, key, record[key], filter)) return false;
+    }
+    return true;
+  }
+  function applyModelQuery(model, rows, args = {}) {
+    const filtered = rows.filter((row) => matchesModelWhere(model, row.data, args.where));
+    const sorted = sortRows(filtered, args.orderBy);
+    return pageRows(sorted, args.skip, args.take);
+  }
+  function serializeUniqueValue(model, fieldName, value) {
+    const field = model.fields[fieldName];
+    const normalized = decodeValue(model.name, field, encodeValue(model.name, field, value));
+    if (normalized instanceof Date) {
+      return normalized.toISOString();
+    }
+    if (typeof normalized === "bigint") {
+      return normalized.toString();
+    }
+    return JSON.stringify(normalized);
+  }
+  function uniqueLockPk(model, fields, row) {
+    const values = fields.map((fieldName) => row[fieldName]);
+    if (values.some((value) => value === void 0 || value === null)) {
+      return null;
+    }
+    const encodedValues = fields.map(
+      (fieldName) => encodeURIComponent(serializeUniqueValue(model, fieldName, row[fieldName]))
+    );
+    return `unique#${model.name}#${fields.join("+")}#${encodedValues.join("#")}`;
+  }
+  function uniqueLocksForRow(model, row, docId) {
+    const target = recordPk(docId);
+    const locks = [];
+    for (const field of Object.values(model.fields)) {
+      if (!field.unique) continue;
+      const pk = uniqueLockPk(model, [field.name], row);
+      if (!pk) continue;
+      locks.push({
+        pk,
+        target,
+        fields: [field.name]
+      });
+    }
+    for (const constraint of model.constraints.unique) {
+      const pk = uniqueLockPk(model, [...constraint.fields], row);
+      if (!pk) continue;
+      locks.push({
+        pk,
+        target,
+        fields: [...constraint.fields]
+      });
+    }
+    return locks;
+  }
+  async function loadUniqueRow(schema, modelName, where) {
+    const manifest = getSupportedManifest(schema);
+    const model = manifest.models[modelName];
+    const lookup = (0, import_orm.requireUniqueLookup)(model, where, "FindUnique");
+    const tableName = getTableName(schema, modelName);
+    if (lookup.kind === "id") {
+      return loadRowByPk(model, tableName, recordPk(String(lookup.values[lookup.fields[0].name])));
+    }
+    const normalizedLookupRow = Object.fromEntries(
+      lookup.fields.map((field) => [
+        field.name,
+        decodeValue(model.name, field, encodeValue(model.name, field, lookup.values[field.name]))
+      ])
+    );
+    const lockPk = uniqueLockPk(
+      model,
+      lookup.fields.map((field) => field.name),
+      normalizedLookupRow
+    );
+    if (!lockPk) {
+      return null;
+    }
+    const lockResult = await documentClient.send(
+      new import_lib_dynamodb.GetCommand({
+        TableName: tableName,
+        Key: {
+          [ormPrimaryKey]: lockPk
+        }
+      })
+    );
+    const target = typeof lockResult.Item?.[ormTargetKey] === "string" ? lockResult.Item[ormTargetKey] : void 0;
+    if (!target) {
+      return null;
+    }
+    return loadRowByPk(model, tableName, target);
+  }
+  function findUniqueConflict(model, candidate, existingRows, ignoreDocIds = /* @__PURE__ */ new Set()) {
+    const idField = model.fields.id;
+    for (const row of existingRows) {
+      if (ignoreDocIds.has(row.docId)) continue;
+      if (idField && candidate[idField.name] !== void 0 && candidate[idField.name] !== null && row.data[idField.name] !== void 0 && row.data[idField.name] !== null && (0, import_orm.equalValues)(candidate[idField.name], row.data[idField.name])) {
+        return [idField.name];
+      }
+      for (const field of Object.values(model.fields)) {
+        if (!field.unique) continue;
+        if (candidate[field.name] === void 0 || candidate[field.name] === null) continue;
+        if (row.data[field.name] === void 0 || row.data[field.name] === null) continue;
+        if ((0, import_orm.equalValues)(candidate[field.name], row.data[field.name])) {
+          return [field.name];
+        }
+      }
+      for (const constraint of model.constraints.unique) {
+        if (!constraint.fields.every(
+          (fieldName) => candidate[fieldName] !== void 0 && candidate[fieldName] !== null && row.data[fieldName] !== void 0 && row.data[fieldName] !== null
+        )) {
+          continue;
+        }
+        if (constraint.fields.every(
+          (fieldName) => (0, import_orm.equalValues)(candidate[fieldName], row.data[fieldName])
+        )) {
+          return [...constraint.fields];
+        }
+      }
+    }
+    return null;
+  }
+  function buildRecordItem(row) {
+    return {
+      [ormPrimaryKey]: recordPk(row.docId),
+      [ormKindKey]: ormRecordKind,
+      ...row.stored
+    };
+  }
+  function putRecordCreateItem(tableName, row) {
+    return {
+      Put: {
+        TableName: tableName,
+        Item: buildRecordItem(row),
+        ConditionExpression: "attribute_not_exists(#pk)",
+        ExpressionAttributeNames: {
+          "#pk": ormPrimaryKey
+        }
+      }
+    };
+  }
+  function putRecordUpdateItem(tableName, row) {
+    return {
+      Put: {
+        TableName: tableName,
+        Item: buildRecordItem(row)
+      }
+    };
+  }
+  function putUniqueItem(tableName, lock) {
+    return {
+      Put: {
+        TableName: tableName,
+        Item: {
+          [ormPrimaryKey]: lock.pk,
+          [ormKindKey]: ormUniqueKind,
+          [ormTargetKey]: lock.target
+        },
+        ConditionExpression: "attribute_not_exists(#pk)",
+        ExpressionAttributeNames: {
+          "#pk": ormPrimaryKey
+        }
+      }
+    };
+  }
+  function deleteItem(tableName, pk) {
+    return {
+      Delete: {
+        TableName: tableName,
+        Key: {
+          [ormPrimaryKey]: pk
+        }
+      }
+    };
+  }
+  async function putRecordSequential(tableName, row, conditionallyCreate) {
+    await documentClient.send(
+      new import_lib_dynamodb.PutCommand({
+        TableName: tableName,
+        Item: buildRecordItem(row),
+        ...conditionallyCreate ? {
+          ConditionExpression: "attribute_not_exists(#pk)",
+          ExpressionAttributeNames: {
+            "#pk": ormPrimaryKey
+          }
+        } : {}
+      })
+    );
+  }
+  async function putUniqueSequential(tableName, lock) {
+    await documentClient.send(
+      new import_lib_dynamodb.PutCommand({
+        TableName: tableName,
+        Item: {
+          [ormPrimaryKey]: lock.pk,
+          [ormKindKey]: ormUniqueKind,
+          [ormTargetKey]: lock.target
+        },
+        ConditionExpression: "attribute_not_exists(#pk)",
+        ExpressionAttributeNames: {
+          "#pk": ormPrimaryKey
+        }
+      })
+    );
+  }
+  async function deleteSequential(tableName, pk) {
+    await documentClient.send(
+      new import_lib_dynamodb.DeleteCommand({
+        TableName: tableName,
+        Key: {
+          [ormPrimaryKey]: pk
+        }
+      })
+    );
+  }
+  async function acquireUniqueLocksSequential(tableName, locks) {
+    const acquired = [];
+    try {
+      for (const lock of locks) {
+        await putUniqueSequential(tableName, lock);
+        acquired.push(lock);
+      }
+    } catch (error) {
+      await releaseUniqueLocksSequential(tableName, acquired);
+      throw error;
+    }
+    return acquired;
+  }
+  async function releaseUniqueLocksSequential(tableName, locks) {
+    for (const lock of [...locks].reverse()) {
+      try {
+        await deleteSequential(tableName, lock.pk);
+      } catch {
+      }
+    }
+  }
+  async function createRecordWithLocks(tableName, row, model) {
+    const locks = uniqueLocksForRow(model, row.decoded, row.docId);
+    const transactItems = [
+      putRecordCreateItem(tableName, row),
+      ...locks.map((lock) => putUniqueItem(tableName, lock))
+    ];
+    try {
+      await documentClient.send(
+        new import_lib_dynamodb.TransactWriteCommand({
+          TransactItems: transactItems
+        })
+      );
+    } catch (error) {
+      if (!isUnsupportedTransactionWrite(error)) {
+        throw error;
+      }
+      const acquiredLocks = await acquireUniqueLocksSequential(tableName, locks);
+      try {
+        await putRecordSequential(tableName, row, true);
+      } catch (recordError) {
+        await releaseUniqueLocksSequential(tableName, acquiredLocks);
+        throw recordError;
+      }
+    }
+  }
+  async function updateRecordWithLocks(tableName, model, current, next) {
+    const currentLocks = new Map(
+      uniqueLocksForRow(model, current.data, current.docId).map((lock) => [lock.pk, lock])
+    );
+    const nextLocks = new Map(
+      uniqueLocksForRow(model, next.decoded, next.docId).map((lock) => [lock.pk, lock])
+    );
+    const deleteOps = [...currentLocks.keys()].filter((pk) => !nextLocks.has(pk)).map((pk) => deleteItem(tableName, pk));
+    const putOps = [...nextLocks.entries()].filter(([pk]) => !currentLocks.has(pk)).map(([, lock]) => putUniqueItem(tableName, lock));
+    try {
+      await documentClient.send(
+        new import_lib_dynamodb.TransactWriteCommand({
+          TransactItems: [putRecordUpdateItem(tableName, next), ...deleteOps, ...putOps]
+        })
+      );
+    } catch (error) {
+      if (!isUnsupportedTransactionWrite(error)) {
+        throw error;
+      }
+      const addedLocks = [...nextLocks.values()].filter((lock) => !currentLocks.has(lock.pk));
+      const acquiredLocks = await acquireUniqueLocksSequential(tableName, addedLocks);
+      try {
+        await putRecordSequential(tableName, next, false);
+      } catch (recordError) {
+        await releaseUniqueLocksSequential(tableName, acquiredLocks);
+        throw recordError;
+      }
+      for (const operation of deleteOps) {
+        await deleteSequential(tableName, operation.Delete.Key[ormPrimaryKey]);
+      }
+    }
+  }
+  async function deleteRecordWithLocks(tableName, model, current) {
+    const locks = uniqueLocksForRow(model, current.data, current.docId);
+    try {
+      await documentClient.send(
+        new import_lib_dynamodb.TransactWriteCommand({
+          TransactItems: [
+            deleteItem(tableName, current.pk),
+            ...locks.map((lock) => deleteItem(tableName, lock.pk))
+          ]
+        })
+      );
+    } catch (error) {
+      if (!isUnsupportedTransactionWrite(error)) {
+        throw error;
+      }
+      await deleteSequential(tableName, current.pk);
+      for (const lock of locks) {
+        await deleteSequential(tableName, lock.pk);
+      }
+    }
+  }
+  async function projectRow(schema, modelName, row, select) {
+    const modelDefinition = schema.models[modelName];
+    const output = {};
+    if (!select) {
+      for (const fieldName of Object.keys(modelDefinition.fields)) {
+        output[fieldName] = row[fieldName];
+      }
+      return output;
+    }
+    for (const [key, value] of Object.entries(select)) {
+      if (value !== true && value === void 0) continue;
+      if (key in modelDefinition.fields && value === true) {
+        output[key] = row[key];
+        continue;
+      }
+      if (key in modelDefinition.relations) {
+        output[key] = await resolveRelation(
+          schema,
+          modelName,
+          key,
+          row,
+          value
+        );
+      }
+    }
+    return output;
+  }
+  async function resolveRelation(schema, modelName, relationName, row, value) {
+    const relation = schema.models[modelName].relations[relationName];
+    const relationArgs = value === true ? {} : value;
+    if (relation.kind === "belongsTo") {
+      const foreignValue = row[relation.foreignKey];
+      const targetRows2 = (await loadRows(schema, relation.target)).filter(
+        (item) => (0, import_orm.equalValues)(item.data.id, foreignValue)
+      );
+      const target = applyModelQuery(
+        relationTargetManifest(schema, relation.target),
+        targetRows2,
+        relationArgs
+      )[0];
+      return target ? projectRow(
+        schema,
+        relation.target,
+        target.data,
+        relationArgs.select
+      ) : null;
+    }
+    if (relation.kind === "hasOne") {
+      const targetRows2 = (await loadRows(schema, relation.target)).filter(
+        (item) => (0, import_orm.equalValues)(item.data[relation.foreignKey], row.id)
+      );
+      const target = applyModelQuery(
+        relationTargetManifest(schema, relation.target),
+        targetRows2,
+        relationArgs
+      )[0];
+      return target ? projectRow(
+        schema,
+        relation.target,
+        target.data,
+        relationArgs.select
+      ) : null;
+    }
+    if (relation.kind === "hasMany") {
+      const targetRows2 = (await loadRows(schema, relation.target)).filter(
+        (item) => (0, import_orm.equalValues)(item.data[relation.foreignKey], row.id)
+      );
+      const matchedRows2 = applyModelQuery(
+        relationTargetManifest(schema, relation.target),
+        targetRows2,
+        relationArgs
+      );
+      return Promise.all(
+        matchedRows2.map(
+          (item) => projectRow(schema, relation.target, item.data, relationArgs.select)
+        )
+      );
+    }
+    const throughRows = (await loadRows(schema, relation.through)).filter(
+      (item) => (0, import_orm.equalValues)(item.data[relation.from], row.id)
+    );
+    const targetIds = throughRows.map((item) => item.data[relation.to]);
+    const targetRows = (await loadRows(schema, relation.target)).filter(
+      (item) => targetIds.some((targetId) => (0, import_orm.equalValues)(targetId, item.data.id))
+    );
+    const matchedRows = applyModelQuery(
+      relationTargetManifest(schema, relation.target),
+      targetRows,
+      relationArgs
+    );
+    return Promise.all(
+      matchedRows.map(
+        (item) => projectRow(schema, relation.target, item.data, relationArgs.select)
+      )
+    );
+  }
+  function relationTargetManifest(schema, modelName) {
+    return getSupportedManifest(schema).models[modelName];
+  }
+  let driver;
+  driver = {
+    handle: (0, import_orm.createDriverHandle)({
+      kind: "dynamodb",
+      client: {
+        client: config.client,
+        documentClient,
+        tables: config.tables
+      },
+      capabilities: {
+        supportsNumericIds: true,
+        numericIds: "manual",
+        supportsJSON: true,
+        supportsDates: true,
+        supportsBooleans: true,
+        supportsTransactions: false,
+        supportsSchemaNamespaces: false,
+        supportsTransactionalDDL: false,
+        supportsJoin: false,
+        nativeRelationLoading: "none",
+        textComparison: "case-sensitive",
+        textMatching: {
+          equality: "case-sensitive",
+          contains: "case-sensitive",
+          ordering: "case-sensitive"
+        },
+        upsert: "emulated",
+        returning: {
+          create: true,
+          update: true,
+          delete: false
+        },
+        returningMode: {
+          create: "record",
+          update: "record",
+          delete: "none"
+        },
+        nativeRelations: {
+          singularChains: false,
+          hasMany: false,
+          manyToMany: false,
+          filtered: false,
+          ordered: false,
+          paginated: false
+        }
+      }
+    }),
+    async findMany(schema, modelName, args) {
+      const model = getSupportedManifest(schema).models[modelName];
+      const rows = applyModelQuery(model, await loadRows(schema, modelName), args);
+      return Promise.all(rows.map((row) => projectRow(schema, modelName, row.data, args.select)));
+    },
+    async findFirst(schema, modelName, args) {
+      const model = getSupportedManifest(schema).models[modelName];
+      const row = applyModelQuery(model, await loadRows(schema, modelName), args)[0];
+      if (!row) return null;
+      return projectRow(schema, modelName, row.data, args.select);
+    },
+    async findUnique(schema, modelName, args) {
+      const model = getSupportedManifest(schema).models[modelName];
+      const row = await loadUniqueRow(schema, modelName, args.where);
+      if (!row || !matchesModelWhere(model, row.data, args.where)) {
+        return null;
+      }
+      return projectRow(schema, modelName, row.data, args.select);
+    },
+    async count(schema, modelName, args) {
+      const model = getSupportedManifest(schema).models[modelName];
+      return applyModelQuery(model, await loadRows(schema, modelName), args).length;
+    },
+    async create(schema, modelName, args) {
+      const model = getSupportedManifest(schema).models[modelName];
+      const existingRows = await loadRows(schema, modelName);
+      const built = buildStoredRow(model, args.data);
+      const conflict = findUniqueConflict(model, built.decoded, existingRows);
+      if (conflict) {
+        throw dynamodbConstraintError(conflict);
+      }
+      await createRecordWithLocks(getTableName(schema, modelName), built, model);
+      return projectRow(schema, modelName, built.decoded, args.select);
+    },
+    async createMany(schema, modelName, args) {
+      const model = getSupportedManifest(schema).models[modelName];
+      const existingRows = await loadRows(schema, modelName);
+      const created = [];
+      for (const entry of args.data) {
+        const built = buildStoredRow(model, entry);
+        const conflict = findUniqueConflict(model, built.decoded, [
+          ...existingRows,
+          ...created.map((row) => ({
+            docId: row.docId,
+            pk: recordPk(row.docId),
+            data: row.decoded,
+            stored: row.stored
+          }))
+        ]);
+        if (conflict) {
+          throw dynamodbConstraintError(conflict);
+        }
+        created.push(built);
+      }
+      for (const row of created) {
+        await createRecordWithLocks(getTableName(schema, modelName), row, model);
+      }
+      return Promise.all(
+        created.map((row) => projectRow(schema, modelName, row.decoded, args.select))
+      );
+    },
+    async update(schema, modelName, args) {
+      const model = getSupportedManifest(schema).models[modelName];
+      const rows = await loadRows(schema, modelName);
+      const current = applyModelQuery(model, rows, {
+        where: args.where,
+        take: 1
+      })[0];
+      if (!current) return null;
+      const next = buildUpdatedRow(model, current, args.data);
+      const conflict = findUniqueConflict(model, next.decoded, rows, /* @__PURE__ */ new Set([current.docId]));
+      if (conflict) {
+        throw dynamodbConstraintError(conflict);
+      }
+      await updateRecordWithLocks(getTableName(schema, modelName), model, current, next);
+      return projectRow(schema, modelName, next.decoded, args.select);
+    },
+    async updateMany(schema, modelName, args) {
+      const model = getSupportedManifest(schema).models[modelName];
+      const rows = await loadRows(schema, modelName);
+      const matched = applyModelQuery(model, rows, {
+        where: args.where
+      });
+      if (!matched.length) return 0;
+      const nextRows = matched.map(
+        (row) => buildUpdatedRow(model, row, args.data)
+      );
+      const keepIds = new Set(matched.map((row) => row.docId));
+      const remaining = rows.filter((row) => !keepIds.has(row.docId));
+      const pending = [];
+      for (const next of nextRows) {
+        const conflict = findUniqueConflict(model, next.decoded, [...remaining, ...pending]);
+        if (conflict) {
+          throw dynamodbConstraintError(conflict);
+        }
+        pending.push({
+          docId: next.docId,
+          pk: recordPk(next.docId),
+          data: next.decoded,
+          stored: next.stored
+        });
+      }
+      for (let index = 0; index < matched.length; index += 1) {
+        await updateRecordWithLocks(
+          getTableName(schema, modelName),
+          model,
+          matched[index],
+          nextRows[index]
+        );
+      }
+      return nextRows.length;
+    },
+    async upsert(schema, modelName, args) {
+      const model = getSupportedManifest(schema).models[modelName];
+      const lookup = (0, import_orm.requireUniqueLookup)(model, args.where, "Upsert");
+      (0, import_orm.validateUniqueLookupUpdateData)(
+        model,
+        args.update,
+        lookup,
+        "Upsert"
+      );
+      const current = await loadUniqueRow(schema, modelName, args.where);
+      if (current && matchesModelWhere(model, current.data, args.where)) {
+        const rows2 = await loadRows(schema, modelName);
+        const next = buildUpdatedRow(
+          model,
+          current,
+          args.update
+        );
+        const conflict2 = findUniqueConflict(model, next.decoded, rows2, /* @__PURE__ */ new Set([current.docId]));
+        if (conflict2) {
+          throw dynamodbConstraintError(conflict2);
+        }
+        await updateRecordWithLocks(getTableName(schema, modelName), model, current, next);
+        return projectRow(schema, modelName, next.decoded, args.select);
+      }
+      const created = buildStoredRow(
+        model,
+        (0, import_orm.mergeUniqueLookupCreateData)(
+          model,
+          args.create,
+          lookup,
+          "Upsert"
+        )
+      );
+      const rows = await loadRows(schema, modelName);
+      const conflict = findUniqueConflict(model, created.decoded, rows);
+      if (conflict) {
+        throw dynamodbConstraintError(conflict);
+      }
+      await createRecordWithLocks(getTableName(schema, modelName), created, model);
+      return projectRow(schema, modelName, created.decoded, args.select);
+    },
+    async delete(schema, modelName, args) {
+      const model = getSupportedManifest(schema).models[modelName];
+      const row = applyModelQuery(model, await loadRows(schema, modelName), {
+        where: args.where,
+        take: 1
+      })[0];
+      if (!row) return 0;
+      await deleteRecordWithLocks(getTableName(schema, modelName), model, row);
+      return 1;
+    },
+    async deleteMany(schema, modelName, args) {
+      const model = getSupportedManifest(schema).models[modelName];
+      const rows = applyModelQuery(model, await loadRows(schema, modelName), {
+        where: args.where
+      });
+      for (const row of rows) {
+        await deleteRecordWithLocks(getTableName(schema, modelName), model, row);
+      }
+      return rows.length;
+    },
+    async transaction(schema, run) {
+      getSupportedManifest(schema);
+      return run(driver);
+    }
+  };
+  return driver;
+}
+function createDynamodbDriver(config) {
+  return createDynamoDbDriverInternal(config);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createDynamodbDriver,
+  normalizeDynamoDbDocumentClient
+});
+//# sourceMappingURL=index.cjs.map