@exabugs/dynamodb-client 1.24.1 → 1.25.1

package/dist/server/handler.cjs

@@ -1,5 +1,5 @@
-// @exabugs/dynamodb-client v1.24.1
-// Built: 2026-11-01T08:26:06.123Z
+// @exabugs/dynamodb-client v1.25.1
+// Built: 2026-11-13T23:34:00.545Z
 "use strict";
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -3429,13 +3429,13 @@ var init_parse_utils = __esm({
       if (value === null || value === void 0) {
         return void 0;
       }
-      const asObject = expectObject(value);
+      const asObject2 = expectObject(value);
       const setKeys = [];
-      for (const k5 in asObject) {
-        if (!hasOwn(asObject, k5)) {
+      for (const k5 in asObject2) {
+        if (!hasOwn(asObject2, k5)) {
           continue;
         }
-        if (asObject[k5] != null) {
+        if (asObject2[k5] != null) {
           setKeys.push(k5);
         }
       }
@@ -3445,7 +3445,7 @@ var init_parse_utils = __esm({
       if (setKeys.length > 1) {
         throw new TypeError(`Unions must have exactly one non-null member. Keys ${setKeys} were not null.`);
       }
-      return asObject;
+      return asObject2;
     }, "expectUnion");
     strictParseDouble = /* @__PURE__ */ __name((value) => {
       if (typeof value == "string") {
@@ -38724,22 +38724,24 @@ var require_main = __commonJS({
     var decode_bbox_int = /* @__PURE__ */ __name(function(hashInt, bitDepth) {
       bitDepth = bitDepth || 52;
       var maxLat = MAX_LAT, minLat = MIN_LAT, maxLon = MAX_LON, minLon = MIN_LON;
-      var latBit = 0, lonBit = 0;
-      var step = bitDepth / 2;
-      for (var i6 = 0; i6 < step; i6++) {
-        lonBit = get_bit(hashInt, (step - i6) * 2 - 1);
-        latBit = get_bit(hashInt, (step - i6) * 2 - 2);
-        if (latBit === 0) {
-          maxLat = (maxLat + minLat) / 2;
-        } else {
-          minLat = (maxLat + minLat) / 2;
-        }
+      var lonBits = Math.ceil(bitDepth / 2);
+      var latBits = Math.floor(bitDepth / 2);
+      for (var i6 = 0; i6 < lonBits; i6++) {
+        var lonBit = get_bit(hashInt, bitDepth - 1 - i6 * 2);
         if (lonBit === 0) {
           maxLon = (maxLon + minLon) / 2;
         } else {
           minLon = (maxLon + minLon) / 2;
         }
       }
+      for (var j5 = 0; j5 < latBits; j5++) {
+        var latBit = get_bit(hashInt, bitDepth - 2 - j5 * 2);
+        if (latBit === 0) {
+          maxLat = (maxLat + minLat) / 2;
+        } else {
+          minLat = (maxLat + minLat) / 2;
+        }
+      }
       return [minLat, minLon, maxLat, maxLon];
     }, "decode_bbox_int");
     function get_bit(bits, position) {
@@ -38844,6 +38846,9 @@ var require_main = __commonJS({
       return neighborHashIntList;
     }, "neighbors_int");
     var bboxes = /* @__PURE__ */ __name(function(minLat, minLon, maxLat, maxLon, numberOfChars) {
+      if (numberOfChars <= 0) {
+        throw new Error("numberOfChars must be strictly positive");
+      }
       numberOfChars = numberOfChars || 9;
       var hashSouthWest = encode(minLat, minLon, numberOfChars);
       var hashNorthEast = encode(maxLat, maxLon, numberOfChars);
@@ -39030,16 +39035,9 @@ var init_shared = __esm({
 });
 
 // src/shared/constants/formatting.ts
-var NUMBER_FORMAT;
 var init_formatting = __esm({
   "src/shared/constants/formatting.ts"() {
     "use strict";
-    NUMBER_FORMAT = {
-      /** シャドウSKで使用する数値の桁数（20桁ゼロ埋め） */
-      SHADOW_SK_DIGITS: 20,
-      /** ゼロ埋め文字 */
-      ZERO_PAD_CHAR: "0"
-    };
   }
 });
 
@@ -39752,6 +39750,71 @@ var init_cost_tracker = __esm({
   }
 });
 
+// src/server/utils/revision.ts
+function revisionOf(item) {
+  const rev = item[REVISION_ATTRIBUTE];
+  return typeof rev === "number" ? rev : void 0;
+}
+function nextRevision(current) {
+  return (current ?? 0) + 1;
+}
+function notExistsCondition() {
+  return { ConditionExpression: "attribute_not_exists(PK)" };
+}
+function unchangedCondition(revision) {
+  const names = { "#rev": REVISION_ATTRIBUTE };
+  if (revision === void 0) {
+    return {
+      ConditionExpression: "attribute_exists(PK) AND attribute_not_exists(#rev)",
+      ExpressionAttributeNames: names
+    };
+  }
+  return {
+    ConditionExpression: "#rev = :rev",
+    ExpressionAttributeNames: names,
+    ExpressionAttributeValues: { ":rev": revision }
+  };
+}
+function isWriteConflict(error2) {
+  if (!error2 || typeof error2 !== "object") return false;
+  const { name, CancellationReasons } = error2;
+  if (name === "TransactionConflictException") return true;
+  if (name !== "TransactionCanceledException" || !Array.isArray(CancellationReasons)) return false;
+  const codes = CancellationReasons.map((r5) => r5?.Code).filter((c5) => c5 && c5 !== "None");
+  return codes.length > 0 && codes.every((c5) => c5 === "ConditionalCheckFailed" || c5 === "TransactionConflict");
+}
+function sleep3(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function writeWithConflictRetry(initial, write, refresh, baseDelayMs = 20) {
+  let records = initial;
+  for (let attempt = 0; ; attempt++) {
+    try {
+      if (records.length > 0) await write(records);
+      return records;
+    } catch (error2) {
+      if (!isWriteConflict(error2) || attempt >= MAX_CONFLICT_RETRIES) throw error2;
+      await sleep3(baseDelayMs * 2 ** attempt * (0.5 + Math.random() / 2));
+      records = await refresh(records);
+    }
+  }
+}
+var REVISION_ATTRIBUTE, MAX_CONFLICT_RETRIES;
+var init_revision = __esm({
+  "src/server/utils/revision.ts"() {
+    "use strict";
+    REVISION_ATTRIBUTE = "__rev";
+    MAX_CONFLICT_RETRIES = 5;
+    __name(revisionOf, "revisionOf");
+    __name(nextRevision, "nextRevision");
+    __name(notExistsCondition, "notExistsCondition");
+    __name(unchangedCondition, "unchangedCondition");
+    __name(isWriteConflict, "isWriteConflict");
+    __name(sleep3, "sleep");
+    __name(writeWithConflictRetry, "writeWithConflictRetry");
+  }
+});
+
 // src/server/utils/validation.ts
 function validateSortField(_config, _resource, _sort) {
   return;
@@ -40194,6 +40257,12 @@ function normalizeFindParams(config, resource, params) {
     schema: params.schema
   };
 }
+function withInferredType(parsed, fieldKey, value) {
+  if (fieldKey.split(":").length >= 3) return parsed;
+  if (typeof value === "number") return { ...parsed, type: "number" };
+  if (typeof value === "boolean") return { ...parsed, type: "boolean" };
+  return parsed;
+}
 function parseFilters(filter) {
   const parsedFilters = [];
   if (!filter || Object.keys(filter).length === 0) {
@@ -40204,11 +40273,14 @@ function parseFilters(filter) {
       if (value && typeof value === "object" && !Array.isArray(value)) {
         for (const [operator, operatorValue] of Object.entries(value)) {
           const parsed = parseFilterField(`${fieldKey}:${operator}`);
-          parsedFilters.push({ parsed, value: operatorValue });
+          parsedFilters.push({
+            parsed: withInferredType(parsed, fieldKey, operatorValue),
+            value: operatorValue
+          });
         }
       } else {
         const parsed = parseFilterField(fieldKey);
-        parsedFilters.push({ parsed, value });
+        parsedFilters.push({ parsed: withInferredType(parsed, fieldKey, value), value });
       }
     } catch (error2) {
       logger7.error("Invalid filter field syntax", {
@@ -40295,6 +40367,7 @@ var init_utils6 = __esm({
     });
     __name(initializeFindConfig, "initializeFindConfig");
     __name(normalizeFindParams, "normalizeFindParams");
+    __name(withInferredType, "withInferredType");
     __name(parseFilters, "parseFilters");
     __name(findOptimizableFilter, "findOptimizableFilter");
     __name(matchesAllFilters, "matchesAllFilters");
@@ -41092,51 +41165,39 @@ function buildKeyCondition(resource, sortField, optimizableFilter) {
   }
   const { operator, type } = optimizableFilter.parsed;
   const value = optimizableFilter.value;
-  const encodedValue = encodeValueForShadowSK(value, type);
-  const skValue = `${sortField}#${encodedValue}`;
+  const { encoded, exact } = encodeValueForShadowSK(value, type, operator);
+  const skValue = `${sortField}#${encoded}`;
+  const afterValue = `${skValue}#id#~`;
+  const beforeValue = `${skValue}#id#`;
   switch (operator) {
     case "$eq":
       return {
         keyConditionExpression: "PK = :pk AND begins_with(SK, :skValue)",
         expressionAttributeValues: {
           ...expressionAttributeValues,
-          ":skValue": `${skValue}#id#`
+          ":skValue": beforeValue
         }
       };
+    // 範囲検索は SK BETWEEN の 1 条件にする。
+    // - DynamoDB はソートキーに 1 つの条件しか許さない（begins_with と比較を並べると ValidationException）
+    // - 上限・下限を sortField の範囲に閉じないと、他の項目のシャドー（や本体 id#…）まで読む
+    // BETWEEN は両端を含むが、端の値（`…#id#`、`…#id#~`、`{sortField}$`）と一致する SK は実在しない
     case "$gt":
-      return {
-        keyConditionExpression: "PK = :pk AND SK > :skValue",
-        expressionAttributeValues: {
-          ...expressionAttributeValues,
-          ":skValue": `${skValue}#id#~`
-        }
-      };
+      return rangeCondition(
+        expressionAttributeValues,
+        exact ? afterValue : beforeValue,
+        fieldUpperBound(sortField)
+      );
     case "$gte":
-      return {
-        keyConditionExpression: "PK = :pk AND SK >= :skValue",
-        expressionAttributeValues: {
-          ...expressionAttributeValues,
-          ":skValue": `${skValue}#id#`
-        }
-      };
+      return rangeCondition(expressionAttributeValues, beforeValue, fieldUpperBound(sortField));
     case "$lt":
-      return {
-        keyConditionExpression: "PK = :pk AND begins_with(SK, :skPrefix) AND SK < :skValue",
-        expressionAttributeValues: {
-          ...expressionAttributeValues,
-          ":skPrefix": `${sortField}#`,
-          ":skValue": `${skValue}#id#`
-        }
-      };
+      return rangeCondition(
+        expressionAttributeValues,
+        `${sortField}#`,
+        exact ? beforeValue : afterValue
+      );
     case "$lte":
-      return {
-        keyConditionExpression: "PK = :pk AND begins_with(SK, :skPrefix) AND SK <= :skValue",
-        expressionAttributeValues: {
-          ...expressionAttributeValues,
-          ":skPrefix": `${sortField}#`,
-          ":skValue": `${skValue}#id#~`
-        }
-      };
+      return rangeCondition(expressionAttributeValues, `${sortField}#`, afterValue);
     case "$starts":
       return {
         keyConditionExpression: "PK = :pk AND begins_with(SK, :skValue)",
@@ -41155,16 +41216,35 @@ function buildKeyCondition(resource, sortField, optimizableFilter) {
       };
   }
 }
-function encodeValueForShadowSK(value, type) {
-  if (type === "number") {
-    return String(value).padStart(NUMBER_FORMAT.SHADOW_SK_DIGITS, NUMBER_FORMAT.ZERO_PAD_CHAR);
-  } else if (type === "date") {
-    return new Date(String(value)).toISOString();
-  } else if (type === "boolean") {
-    return String(value);
-  } else {
-    return String(value).replace(/#/g, "##").replace(/ /g, "#");
+function fieldUpperBound(sortField) {
+  return `${sortField}$`;
+}
+function rangeCondition(base, low, high) {
+  return {
+    keyConditionExpression: "PK = :pk AND SK BETWEEN :skLow AND :skHigh",
+    expressionAttributeValues: { ...base, ":skLow": low, ":skHigh": high }
+  };
+}
+function encodeValueForShadowSK(value, type, operator) {
+  const config = getShadowConfig();
+  if (type === "number" || typeof value === "number") {
+    const num = Number(value);
+    return { encoded: formatFieldValue2("number", num, config), exact: false };
   }
+  if (type === "boolean" || typeof value === "boolean") {
+    const bool = typeof value === "boolean" ? value : String(value).toLowerCase() === "true";
+    return { encoded: formatFieldValue2("boolean", bool, config), exact: true };
+  }
+  const str = String(value);
+  if (operator !== "$starts" && (type === "date" || inferFieldType(str) === "datetime")) {
+    return { encoded: formatFieldValue2("datetime", str, config), exact: true };
+  }
+  const encoded = formatFieldValue2("string", str, config);
+  const bytes = new TextEncoder().encode(str).length;
+  return {
+    encoded,
+    exact: encoded === escapeString2(str) && bytes < config.stringMaxBytes - 3
+  };
 }
 function extractRecordIds(shadowRecords) {
   return shadowRecords.map((record) => {
@@ -41191,8 +41271,8 @@ var init_shadowQuery = __esm({
   "src/server/operations/find/shadowQuery.ts"() {
     "use strict";
     import_lib_dynamodb5 = __toESM(require_dist_cjs22(), 1);
-    init_formatting();
     init_shared();
+    init_shadow();
     init_batchGet();
     init_cost_tracker();
     init_dynamodb3();
@@ -41212,6 +41292,8 @@ var init_shadowQuery = __esm({
     __name(sortInMemory, "sortInMemory");
     __name(executeShadowRecordQuery, "executeShadowRecordQuery");
     __name(buildKeyCondition, "buildKeyCondition");
+    __name(fieldUpperBound, "fieldUpperBound");
+    __name(rangeCondition, "rangeCondition");
     __name(encodeValueForShadowSK, "encodeValueForShadowSK");
     __name(extractRecordIds, "extractRecordIds");
     __name(fetchMainRecords, "fetchMainRecords");
@@ -41406,7 +41488,8 @@ async function handleDeleteMany(resource, params, requestId) {
     preparedRecords.push({
       id,
       mainSK: generateMainRecordSK2(id),
-      shadowKeys
+      shadowKeys,
+      revision: revisionOf(item)
     });
   }
   const notFoundIds = ids.filter((id) => !existingIds.has(id));
@@ -41454,16 +41537,20 @@ async function handleDeleteMany(resource, params, requestId) {
     chunks.length,
     preparationRiskInfo
   );
-  const executeChunk = /* @__PURE__ */ __name(async (chunk) => {
+  const writeChunk = /* @__PURE__ */ __name(async (chunk) => {
     const transactItems = [];
     for (const record of chunk) {
+      if (record.gone) continue;
       transactItems.push({
         Delete: {
           TableName: tableName,
           Key: {
             PK: resource,
             SK: record.mainSK
-          }
+          },
+          // 読んでから消すまでの間に、ほかの書き込みが入っていないこと（楽観ロック）。
+          // 古い一覧のままシャドーを消すと、新しく増えたシャドーが残る
+          ...unchangedCondition(record.revision)
         }
       });
       for (const shadowSK of record.shadowKeys) {
@@ -41478,6 +41565,7 @@ async function handleDeleteMany(resource, params, requestId) {
         });
       }
     }
+    if (transactItems.length === 0) return;
     const result = await executeDynamoDBOperation(
       () => dbClient2.send(
         new import_lib_dynamodb6.TransactWriteCommand({
@@ -41494,8 +41582,24 @@ async function handleDeleteMany(resource, params, requestId) {
     } else {
       costTracker.add(result.ConsumedCapacity);
     }
-    return chunk;
-  }, "executeChunk");
+  }, "writeChunk");
+  const executeChunk = /* @__PURE__ */ __name((chunk) => writeWithConflictRetry(chunk, writeChunk, async (stale) => {
+    const items = await batchGetAll(
+      stale.map((record) => ({ PK: resource, SK: record.mainSK })),
+      { consistentRead: true, costTracker, requestId }
+    );
+    const fresh = new Map(items.map((item) => [item.SK, item]));
+    return stale.map((record) => {
+      const item = fresh.get(record.mainSK);
+      if (!item) return { ...record, gone: true };
+      const data = item.data;
+      return {
+        ...record,
+        shadowKeys: item.__shadowKeys ?? data.__shadowKeys ?? [],
+        revision: revisionOf(item)
+      };
+    });
+  }), "executeChunk");
   const {
     successRecords,
     failedIds: chunkFailedIds,
@@ -41587,6 +41691,7 @@ var init_deleteMany = __esm({
     init_chunking();
     init_cost_tracker();
     init_dynamodb3();
+    init_revision();
     init_findAll();
     logger12 = createLogger({ service: "records-lambda" });
     __name(handleDeleteMany, "handleDeleteMany");
@@ -41881,7 +41986,7 @@ async function handleInsertMany(resource, params, requestId) {
     chunks.length,
     preparationRiskInfo
   );
-  const executeChunk = /* @__PURE__ */ __name(async (chunk) => {
+  const writeChunk = /* @__PURE__ */ __name(async (chunk) => {
     const transactItems = [];
     for (const record of chunk) {
       transactItems.push({
@@ -41891,12 +41996,23 @@ async function handleInsertMany(resource, params, requestId) {
             PK: resource,
             SK: record.mainSK,
             __shadowKeys: record.shadowKeys,
+            [REVISION_ATTRIBUTE]: nextRevision(record.existing?.revision),
             data: {
               ...record.fullRecordData
             }
-          }
+          },
+          // 既存の id への挿入は上書きになる。既存を知らずに上書きすると、古いシャドーが残るので、
+          // まず「無い」ことを条件に書き、外れたら既存を読んで、古いシャドーも一緒に消す
+          ...record.existing ? unchangedCondition(record.existing.revision) : notExistsCondition()
         }
       });
+      const newShadowKeys = new Set(record.shadowKeys);
+      for (const shadowSK of record.existing?.shadowKeys ?? []) {
+        if (newShadowKeys.has(shadowSK)) continue;
+        transactItems.push({
+          Delete: { TableName: tableName, Key: { PK: resource, SK: shadowSK } }
+        });
+      }
       for (const shadowSK of record.shadowKeys) {
         transactItems.push({
           Put: {
@@ -41926,8 +42042,26 @@ async function handleInsertMany(resource, params, requestId) {
     } else {
       costTracker.add(result.ConsumedCapacity);
     }
-    return chunk;
-  }, "executeChunk");
+  }, "writeChunk");
+  const executeChunk = /* @__PURE__ */ __name((chunk) => writeWithConflictRetry(chunk, writeChunk, async (stale) => {
+    const items = await batchGetAll(
+      stale.map((record) => ({ PK: resource, SK: record.mainSK })),
+      { consistentRead: true, costTracker, requestId }
+    );
+    const fresh = new Map(items.map((item) => [item.SK, item]));
+    return stale.map((record) => {
+      const item = fresh.get(record.mainSK);
+      if (!item) return { ...record, existing: void 0 };
+      const data = item.data;
+      return {
+        ...record,
+        existing: {
+          revision: revisionOf(item),
+          shadowKeys: item.__shadowKeys ?? data?.__shadowKeys ?? []
+        }
+      };
+    });
+  }), "executeChunk");
   const {
     successRecords,
     failedIds: chunkFailedIds,
@@ -42027,10 +42161,12 @@ var init_insertMany = __esm({
     init_shared();
     init_shadow();
     init_shadow();
+    init_batchGet();
     init_bulkOperations();
     init_chunking();
     init_cost_tracker();
     init_dynamodb3();
+    init_revision();
     init_timestamps();
     init_ttl();
     logger18 = createLogger({ service: "records-lambda" });
@@ -42146,6 +42282,71 @@ var init_mergePatch = __esm({
   }
 });
 
+// src/server/utils/updateOperators.ts
+function invalid(message) {
+  return new AppError("VALIDATION_ERROR" /* VALIDATION_ERROR */, message, 400);
+}
+function asObject(value, operator) {
+  if (value === void 0) return {};
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw invalid(`${operator} must be an object`);
+  }
+  return value;
+}
+function unsetFields(value) {
+  if (value === void 0) return [];
+  if (Array.isArray(value)) {
+    if (!value.every((f5) => typeof f5 === "string")) {
+      throw invalid("$unset must be an array of field names or an object");
+    }
+    return value;
+  }
+  return Object.keys(asObject(value, "$unset"));
+}
+function resolveUpdateOperators(data) {
+  const operators = Object.keys(data).filter((key) => key.startsWith("$"));
+  if (operators.length === 0) {
+    return { patch: data, setOnInsert: {}, returned: data };
+  }
+  const unsupported = operators.filter((op2) => !SUPPORTED_OPERATORS.includes(op2));
+  if (unsupported.length > 0) {
+    throw invalid(
+      `Unsupported update operator: ${unsupported.join(", ")} (supported: ${SUPPORTED_OPERATORS.join(", ")})`
+    );
+  }
+  const set = asObject(data.$set, "$set");
+  const patch = { ...set };
+  for (const field of unsetFields(data.$unset)) {
+    if (field in set) {
+      throw invalid(`Field "${field}" is in both $set and $unset`);
+    }
+    patch[field] = null;
+  }
+  return { patch, setOnInsert: asObject(data.$setOnInsert, "$setOnInsert"), returned: set };
+}
+function equalityFieldsOf(filter) {
+  const fields = {};
+  for (const [key, value] of Object.entries(filter)) {
+    if (key.includes(":") || key.startsWith("$")) continue;
+    if (typeof value === "object" && value !== null) continue;
+    fields[key] = value;
+  }
+  return fields;
+}
+var SUPPORTED_OPERATORS;
+var init_updateOperators = __esm({
+  "src/server/utils/updateOperators.ts"() {
+    "use strict";
+    init_shared();
+    SUPPORTED_OPERATORS = ["$set", "$setOnInsert", "$unset"];
+    __name(invalid, "invalid");
+    __name(asObject, "asObject");
+    __name(unsetFields, "unsetFields");
+    __name(resolveUpdateOperators, "resolveUpdateOperators");
+    __name(equalityFieldsOf, "equalityFieldsOf");
+  }
+});
+
 // src/server/operations/updateMany.ts
 var updateMany_exports = {};
 __export(updateMany_exports, {
@@ -42156,6 +42357,7 @@ async function handleUpdateMany(resource, params, requestId) {
   const upsert = options?.upsert ?? false;
   const startTime = Date.now();
   const costTracker = new CostTracker();
+  const update = resolveUpdateOperators(patchData);
   logger20.debug("Executing updateMany", {
     requestId,
     resource,
@@ -42203,16 +42405,10 @@ async function handleUpdateMany(resource, params, requestId) {
           newId,
           filter: params.filter
         });
-        if (patchData.$setOnInsert) {
-          patchData.$setOnInsert = {
-            ...params.filter,
-            ...patchData.$setOnInsert
-          };
-        } else if (patchData.$set) {
-          patchData.$setOnInsert = params.filter;
-        } else {
-          patchData.$setOnInsert = params.filter;
-        }
+        update.setOnInsert = {
+          ...equalityFieldsOf(params.filter),
+          ...update.setOnInsert
+        };
       } else {
         return {
           count: 0,
@@ -42227,118 +42423,121 @@ async function handleUpdateMany(resource, params, requestId) {
   logLargeBatchWarning("updateMany", ids.length, requestId, resource);
   const dbClient2 = getDBClient();
   const tableName = getTableName();
-  const existingItems = await batchGetAll(
-    ids.map((id) => ({ PK: resource, SK: generateMainRecordSK2(id) })),
-    { consistentRead: true, costTracker, requestId }
-  );
-  const existingIds = new Set(
-    existingItems.map((item) => {
-      const data = item.data;
-      return data.id;
-    })
-  );
-  const notFoundIds = ids.filter((id) => !existingIds.has(id));
-  if (!upsert && notFoundIds.length > 0) {
-    logger20.warn("Records not found (upsert: false)", {
-      requestId,
-      resource,
-      notFoundCount: notFoundIds.length,
-      notFoundIds: notFoundIds.slice(0, 10)
-      // 最初の10件のみログ
-    });
-  }
-  if (upsert && notFoundIds.length > 0) {
-    logger20.info("Creating new records (upsert: true)", {
-      requestId,
-      resource,
-      notFoundCount: notFoundIds.length,
-      notFoundIds: notFoundIds.slice(0, 10)
-      // 最初の10件のみログ
-    });
-  }
-  const shadowConfig = getShadowConfig();
-  const preparedRecords = [];
-  const preparationFailedIds = [];
-  const preparationErrors = [];
-  for (const item of existingItems) {
-    try {
-      const existingData = item.data;
-      const id = existingData.id;
-      const oldShadowKeys = item.__shadowKeys ?? existingData.__shadowKeys ?? [];
-      const actualPatchData2 = patchData.$set ? patchData.$set : patchData;
-      const timestampedPatch = addUpdateTimestamp(actualPatchData2);
-      const mergedData = applyJsonMergePatch(removeShadowKeys(existingData), timestampedPatch);
-      const updatedData = { ...mergedData, id };
-      const newShadowRecords = generateShadowRecords(updatedData, resource, shadowConfig);
-      const newShadowKeys = newShadowRecords.map((shadow) => shadow.SK);
-      const mainSK = generateMainRecordSK2(id);
-      preparedRecords.push({
-        id,
-        updatedData,
-        oldShadowKeys,
-        newShadowKeys,
-        mainSK
-      });
-    } catch (error2) {
-      const existingData = item.data;
-      const failedId = existingData.id || "unknown-id";
-      const errorMessage = error2 instanceof Error ? error2.message : "Unknown preparation error";
-      const errorCode = getPreparationErrorCode2(error2);
-      logger20.error("Failed to prepare record for update", {
+  const prepare = /* @__PURE__ */ __name(async (targetIds) => {
+    const existingItems = await batchGetAll(
+      targetIds.map((id) => ({ PK: resource, SK: generateMainRecordSK2(id) })),
+      { consistentRead: true, costTracker, requestId }
+    );
+    const existingIds = new Set(
+      existingItems.map((item) => {
+        const data = item.data;
+        return data.id;
+      })
+    );
+    const notFoundIds2 = targetIds.filter((id) => !existingIds.has(id));
+    if (!upsert && notFoundIds2.length > 0) {
+      logger20.warn("Records not found (upsert: false)", {
         requestId,
-        recordId: failedId,
-        error: errorMessage,
-        errorCode
+        resource,
+        notFoundCount: notFoundIds2.length,
+        notFoundIds: notFoundIds2.slice(0, 10)
+        // 最初の10件のみログ
       });
-      preparationFailedIds.push(failedId);
-      preparationErrors.push({
-        id: failedId,
-        code: errorCode,
-        message: errorMessage
+    }
+    if (upsert && notFoundIds2.length > 0) {
+      logger20.info("Creating new records (upsert: true)", {
+        requestId,
+        resource,
+        notFoundCount: notFoundIds2.length,
+        notFoundIds: notFoundIds2.slice(0, 10)
+        // 最初の10件のみログ
       });
     }
-  }
-  if (upsert && notFoundIds.length > 0) {
-    const { addCreateTimestamps: addCreateTimestamps2 } = await Promise.resolve().then(() => (init_timestamps(), timestamps_exports));
-    for (const id of notFoundIds) {
+    const shadowConfig = getShadowConfig();
+    const preparedRecords2 = [];
+    const preparationFailedIds2 = [];
+    const preparationErrors2 = [];
+    for (const item of existingItems) {
       try {
-        const setData = patchData.$set ? patchData.$set : patchData;
-        const setOnInsertData2 = patchData.$setOnInsert ? patchData.$setOnInsert : {};
-        const mergedData = {
-          ...setOnInsertData2,
-          ...setData,
-          id
-        };
-        const newData = addCreateTimestamps2(mergedData);
-        const newShadowRecords = generateShadowRecords(newData, resource, shadowConfig);
+        const existingData = item.data;
+        const id = existingData.id;
+        const oldShadowKeys = item.__shadowKeys ?? existingData.__shadowKeys ?? [];
+        const timestampedPatch = addUpdateTimestamp(update.patch);
+        const mergedData = applyJsonMergePatch(removeShadowKeys(existingData), timestampedPatch);
+        const updatedData = { ...mergedData, id };
+        const newShadowRecords = generateShadowRecords(updatedData, resource, shadowConfig);
         const newShadowKeys = newShadowRecords.map((shadow) => shadow.SK);
         const mainSK = generateMainRecordSK2(id);
-        preparedRecords.push({
+        preparedRecords2.push({
           id,
-          updatedData: newData,
-          oldShadowKeys: [],
-          // 新規作成なので空
+          updatedData,
+          oldShadowKeys,
           newShadowKeys,
-          mainSK
+          mainSK,
+          isNew: false,
+          revision: revisionOf(item)
         });
       } catch (error2) {
+        const existingData = item.data;
+        const failedId = existingData.id || "unknown-id";
         const errorMessage = error2 instanceof Error ? error2.message : "Unknown preparation error";
         const errorCode = getPreparationErrorCode2(error2);
-        logger20.error("Failed to prepare new record for upsert", {
+        logger20.error("Failed to prepare record for update", {
           requestId,
-          recordId: id,
+          recordId: failedId,
           error: errorMessage,
           errorCode
         });
-        preparationFailedIds.push(id);
-        preparationErrors.push({
-          id,
+        preparationFailedIds2.push(failedId);
+        preparationErrors2.push({
+          id: failedId,
           code: errorCode,
           message: errorMessage
         });
       }
     }
-  }
+    if (upsert && notFoundIds2.length > 0) {
+      const { addCreateTimestamps: addCreateTimestamps2 } = await Promise.resolve().then(() => (init_timestamps(), timestamps_exports));
+      for (const id of notFoundIds2) {
+        try {
+          const mergedData = {
+            ...applyJsonMergePatch({}, { ...update.setOnInsert, ...update.patch }),
+            id
+          };
+          const newData = addCreateTimestamps2(mergedData);
+          const newShadowRecords = generateShadowRecords(newData, resource, shadowConfig);
+          const newShadowKeys = newShadowRecords.map((shadow) => shadow.SK);
+          const mainSK = generateMainRecordSK2(id);
+          preparedRecords2.push({
+            id,
+            updatedData: newData,
+            oldShadowKeys: [],
+            // 新規作成なので空
+            newShadowKeys,
+            mainSK,
+            isNew: true
+          });
+        } catch (error2) {
+          const errorMessage = error2 instanceof Error ? error2.message : "Unknown preparation error";
+          const errorCode = getPreparationErrorCode2(error2);
+          logger20.error("Failed to prepare new record for upsert", {
+            requestId,
+            recordId: id,
+            error: errorMessage,
+            errorCode
+          });
+          preparationFailedIds2.push(id);
+          preparationErrors2.push({
+            id,
+            code: errorCode,
+            message: errorMessage
+          });
+        }
+      }
+    }
+    return { preparedRecords: preparedRecords2, notFoundIds: notFoundIds2, preparationFailedIds: preparationFailedIds2, preparationErrors: preparationErrors2 };
+  }, "prepare");
+  const { preparedRecords, notFoundIds, preparationFailedIds, preparationErrors } = await prepare(ids);
   const getItemCount = /* @__PURE__ */ __name((record) => {
     const shadowDiff = calculateShadowDiff(record.oldShadowKeys, record.newShadowKeys);
     return 1 + shadowDiff.toDelete.length + shadowDiff.toAdd.length;
@@ -42352,7 +42551,7 @@ async function handleUpdateMany(resource, params, requestId) {
     chunks.length,
     preparationRiskInfo
   );
-  const executeChunk = /* @__PURE__ */ __name(async (chunk) => {
+  const writeChunk = /* @__PURE__ */ __name(async (chunk) => {
     const transactItems = [];
     for (const record of chunk) {
       const shadowDiff = calculateShadowDiff(record.oldShadowKeys, record.newShadowKeys);
@@ -42363,10 +42562,13 @@ async function handleUpdateMany(resource, params, requestId) {
             PK: resource,
             SK: record.mainSK,
             __shadowKeys: record.newShadowKeys,
+            [REVISION_ATTRIBUTE]: nextRevision(record.revision),
             data: {
               ...record.updatedData
             }
-          }
+          },
+          // 読んでから書くまでの間に、ほかの書き込みが入っていないこと（楽観ロック）
+          ...record.isNew ? notExistsCondition() : unchangedCondition(record.revision)
         }
       });
       for (const shadowSK of shadowDiff.toDelete) {
@@ -42409,8 +42611,18 @@ async function handleUpdateMany(resource, params, requestId) {
     } else {
       costTracker.add(result.ConsumedCapacity);
     }
-    return chunk;
-  }, "executeChunk");
+  }, "writeChunk");
+  const executeChunk = /* @__PURE__ */ __name((chunk) => writeWithConflictRetry(chunk, writeChunk, async (stale) => {
+    const fresh = await prepare(stale.map((record) => record.id));
+    if (fresh.preparedRecords.length !== stale.length) {
+      throw new AppError(
+        "INTERNAL_ERROR" /* INTERNAL_ERROR */,
+        "Records changed concurrently and could not be re-read for update",
+        409
+      );
+    }
+    return fresh.preparedRecords;
+  }), "executeChunk");
   const {
     successRecords,
     failedIds: chunkFailedIds,
@@ -42420,8 +42632,6 @@ async function handleUpdateMany(resource, params, requestId) {
   const items = [];
   const failedIdsMap = {};
   const errorsMap = {};
-  const actualPatchData = patchData.$set ? patchData.$set : patchData;
-  const setOnInsertData = patchData.$setOnInsert ? patchData.$setOnInsert : {};
   const successIdSet = new Set(successRecords.map((r5) => r5.id));
   for (let i5 = 0; i5 < ids.length; i5++) {
     const id = ids[i5];
@@ -42430,13 +42640,13 @@ async function handleUpdateMany(resource, params, requestId) {
       if (upsert && notFoundIds.includes(id)) {
         items.push({
           id,
-          ...setOnInsertData,
-          ...actualPatchData
+          ...update.setOnInsert,
+          ...update.returned
         });
       } else {
         items.push({
           id,
-          ...actualPatchData
+          ...update.returned
         });
       }
     }
@@ -42551,7 +42761,9 @@ var init_updateMany = __esm({
     init_cost_tracker();
     init_dynamodb3();
     init_mergePatch();
+    init_revision();
     init_timestamps();
+    init_updateOperators();
     init_findAll();
     logger20 = createLogger({ service: "records-lambda" });
     __name(handleUpdateMany, "handleUpdateMany");
@@ -44605,7 +44817,7 @@ async function handler(event) {
       return createCorsResponse(HTTP_STATUS.OK);
     }
     if (event.requestContext.http.method === "GET" && event.requestContext.http.path === "/version") {
-      const version = "1.24.1";
+      const version = "1.25.1";
       return createSuccessResponse({ version, timestamp: (/* @__PURE__ */ new Date()).toISOString() }, requestId);
     }
     if (event.requestContext.http.method !== "POST") {