@exabugs/dynamodb-client 1.4.8 → 1.4.10

package/dist/server/handler.cjs

@@ -1,5 +1,5 @@
-// @exabugs/dynamodb-client v1.4.8
-// Built: 2026-04-05T11:02:55.391Z
+// @exabugs/dynamodb-client v1.4.10
+// Built: 2026-04-05T13:26:07.424Z
 "use strict";
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -30324,6 +30324,25 @@ function encodeNextToken(pk, sk) {
   const base64url = base64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
   return base64url;
 }
+function encodeOffsetToken(offset) {
+  const payload2 = { offset };
+  const json = JSON.stringify(payload2);
+  const base64 = Buffer.from(json, "utf-8").toString("base64");
+  return base64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+}
+function decodeOffsetToken(token) {
+  try {
+    let base64 = token.replace(/-/g, "+").replace(/_/g, "/");
+    while (base64.length % 4 !== 0) base64 += "=";
+    const payload2 = JSON.parse(Buffer.from(base64, "base64").toString("utf-8"));
+    if (typeof payload2.offset === "number" && !payload2.PK) {
+      return payload2.offset;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
 function decodeNextToken(token) {
   try {
     let base64 = token.replace(/-/g, "+").replace(/_/g, "/");
@@ -30349,6 +30368,8 @@ var init_pagination = __esm({
     init_index2();
     init_validation3();
     __name(encodeNextToken, "encodeNextToken");
+    __name(encodeOffsetToken, "encodeOffsetToken");
+    __name(decodeOffsetToken, "decodeOffsetToken");
     __name(decodeNextToken, "decodeNextToken");
   }
 });
@@ -30819,20 +30840,26 @@ async function executeShadowQuery(resource, normalizedParams, requestId) {
   const costTracker = new CostTracker();
   const filterFirstCandidate = selectFilterFirstCandidate(parsedFilters, sort.field, normalizedParams.schema, perPage);
   const isFilterFirst = filterFirstCandidate !== void 0;
-  const querySort = isFilterFirst ? { field: filterFirstCandidate.parsed.field, order: "ASC" } : sort;
-  const optimizableFilter = isFilterFirst ? filterFirstCandidate : findOptimizableFilter(sort.field, parsedFilters);
-  const remainingFilters = isFilterFirst ? parsedFilters.filter((f4) => f4 !== filterFirstCandidate) : parsedFilters;
+  if (isFilterFirst) {
+    return executeFilterFirstQuery(
+      resource,
+      normalizedParams,
+      filterFirstCandidate,
+      costTracker,
+      requestId
+    );
+  }
+  const optimizableFilter = findOptimizableFilter(sort.field, parsedFilters);
   logger8.debug("Executing shadow query", {
     requestId,
     resource,
     sortField: sort.field,
-    isFilterFirst,
-    queryField: querySort.field,
+    isFilterFirst: false,
     hasFilters: parsedFilters.length > 0
   });
   const shadowRecords = await executeShadowRecordQuery(
     resource,
-    querySort,
+    sort,
     perPage,
     nextToken,
     optimizableFilter,
@@ -30863,11 +30890,8 @@ async function executeShadowQuery(resource, normalizedParams, requestId) {
     seenIds.add(id);
     return true;
   }).map((id) => recordMap.get(id)).filter((record) => record !== void 0);
-  if (remainingFilters.length > 0) {
-    items = items.filter((record) => matchesAllFilters(record, remainingFilters));
-  }
-  if (isFilterFirst) {
-    items = sortInMemory(items, sort);
+  if (parsedFilters.length > 0) {
+    items = items.filter((record) => matchesAllFilters(record, parsedFilters));
   }
   const hasNextPage = (shadowRecords.Items?.length || 0) < perPage ? false : shadowRecords.LastEvaluatedKey !== void 0;
   const nextTokenValue = hasNextPage && shadowRecords.LastEvaluatedKey ? encodeNextToken(
@@ -30878,7 +30902,7 @@ async function executeShadowQuery(resource, normalizedParams, requestId) {
     requestId,
     resource,
     sortField: sort.field,
-    isFilterFirst,
+    isFilterFirst: false,
     shadowCount: shadowRecords.Items?.length || 0,
     mainCount: items.length,
     hasNextPage
@@ -30893,6 +30917,75 @@ async function executeShadowQuery(resource, normalizedParams, requestId) {
     consumedCapacity: costTracker.getAggregated()
   };
 }
+async function executeFilterFirstQuery(resource, normalizedParams, filterCandidate, costTracker, requestId) {
+  const { sort, pagination, parsedFilters } = normalizedParams;
+  const { perPage, nextToken } = pagination;
+  const offset = nextToken ? decodeOffsetToken(nextToken) ?? 0 : 0;
+  const filterSort = { field: filterCandidate.parsed.field, order: "ASC" };
+  const remainingFilters = parsedFilters.filter((f4) => f4 !== filterCandidate);
+  logger8.debug("Executing filter-first query", {
+    requestId,
+    resource,
+    filterField: filterCandidate.parsed.field,
+    sortField: sort.field,
+    offset
+  });
+  const allShadowItems = [];
+  let lastKey;
+  do {
+    const result = await executeShadowRecordQuery(
+      resource,
+      filterSort,
+      1e3,
+      // 大きめの Limit でループ回数を最小化
+      lastKey ? encodeNextToken(lastKey.PK, lastKey.SK) : void 0,
+      filterCandidate,
+      costTracker,
+      requestId
+    );
+    allShadowItems.push(...result.Items || []);
+    lastKey = result.LastEvaluatedKey;
+  } while (lastKey);
+  const allIds = Array.from(new Set(extractRecordIds(allShadowItems)));
+  if (allIds.length === 0) {
+    return {
+      items: [],
+      pageInfo: { hasNextPage: false, hasPreviousPage: offset > 0 },
+      consumedCapacity: costTracker.getAggregated()
+    };
+  }
+  const mainRecords = await fetchMainRecords(resource, allIds, costTracker, requestId);
+  const recordMap = new Map(
+    mainRecords.map((item) => {
+      const data2 = item.data;
+      return [data2.id, extractCleanRecord(item)];
+    })
+  );
+  let items = allIds.map((id) => recordMap.get(id)).filter((r4) => r4 !== void 0);
+  if (remainingFilters.length > 0) {
+    items = items.filter((r4) => matchesAllFilters(r4, remainingFilters));
+  }
+  items = sortInMemory(items, sort);
+  const page = items.slice(offset, offset + perPage);
+  const hasNextPage = offset + perPage < items.length;
+  const nextTokenValue = hasNextPage ? encodeOffsetToken(offset + perPage) : void 0;
+  logger8.info("Filter-first query succeeded", {
+    requestId,
+    resource,
+    filterField: filterCandidate.parsed.field,
+    sortField: sort.field,
+    totalMatched: items.length,
+    offset,
+    returned: page.length,
+    hasNextPage
+  });
+  return {
+    items: page,
+    pageInfo: { hasNextPage, hasPreviousPage: offset > 0 },
+    ...nextTokenValue && { nextToken: nextTokenValue },
+    consumedCapacity: costTracker.getAggregated()
+  };
+}
 function selectFilterFirstCandidate(parsedFilters, sortField, schema, perPage) {
   const eqFilters = parsedFilters.filter(
     (f4) => f4.parsed.operator === "$eq" && f4.parsed.field !== sortField
@@ -30900,7 +30993,7 @@ function selectFilterFirstCandidate(parsedFilters, sortField, schema, perPage) {
   if (eqFilters.length === 0) return void 0;
   const cardinality = schema?.cardinality;
   if (!cardinality) {
-    return eqFilters[0];
+    return void 0;
   }
   const threshold = perPage / 2;
   const scored = eqFilters.map((f4) => ({ f: f4, score: cardinality[f4.parsed.field] ?? 0 })).filter(({ score }) => score > threshold).sort((a4, b4) => b4.score - a4.score);
@@ -31053,36 +31146,41 @@ async function fetchMainRecords(resource, recordIds, costTracker, requestId) {
   const dbClient2 = getDBClient();
   const tableName = getTableName();
   const uniqueRecordIds = Array.from(new Set(recordIds));
-  const batchGetResult = await executeDynamoDBOperation(
-    () => dbClient2.send(
-      new import_lib_dynamodb4.BatchGetCommand({
-        RequestItems: {
-          [tableName]: {
-            Keys: uniqueRecordIds.map((id) => ({
-              PK: resource,
-              SK: `id#${id}`
-            })),
-            ConsistentRead: true
-          }
-        },
-        ReturnConsumedCapacity: "TOTAL"
-      })
-    ),
-    "BatchGetItem"
-  );
-  if (batchGetResult.ConsumedCapacity) {
-    for (const capacity of batchGetResult.ConsumedCapacity) {
-      costTracker.add(capacity);
+  const BATCH_SIZE = 100;
+  const allRecords = [];
+  for (let i4 = 0; i4 < uniqueRecordIds.length; i4 += BATCH_SIZE) {
+    const chunk = uniqueRecordIds.slice(i4, i4 + BATCH_SIZE);
+    const batchGetResult = await executeDynamoDBOperation(
+      () => dbClient2.send(
+        new import_lib_dynamodb4.BatchGetCommand({
+          RequestItems: {
+            [tableName]: {
+              Keys: chunk.map((id) => ({
+                PK: resource,
+                SK: `id#${id}`
+              })),
+              ConsistentRead: true
+            }
+          },
+          ReturnConsumedCapacity: "TOTAL"
+        })
+      ),
+      "BatchGetItem"
+    );
+    if (batchGetResult.ConsumedCapacity) {
+      for (const capacity of batchGetResult.ConsumedCapacity) {
+        costTracker.add(capacity);
+      }
     }
+    allRecords.push(...batchGetResult.Responses?.[tableName] || []);
   }
-  const mainRecords = batchGetResult.Responses?.[tableName] || [];
   logger8.debug("Main records fetched", {
     requestId,
     resource,
     requestedCount: uniqueRecordIds.length,
-    fetchedCount: mainRecords.length
+    fetchedCount: allRecords.length
   });
-  return mainRecords;
+  return allRecords;
 }
 var import_lib_dynamodb4, logger8;
 var init_shadowQuery = __esm({
@@ -31100,6 +31198,7 @@ var init_shadowQuery = __esm({
       level: process.env.LOG_LEVEL || "info"
     });
     __name(executeShadowQuery, "executeShadowQuery");
+    __name(executeFilterFirstQuery, "executeFilterFirstQuery");
     __name(selectFilterFirstCandidate, "selectFilterFirstCandidate");
     __name(sortInMemory, "sortInMemory");
     __name(executeShadowRecordQuery, "executeShadowRecordQuery");
@@ -34401,7 +34500,7 @@ async function handler(event) {
       return createCorsResponse(HTTP_STATUS.OK);
     }
     if (event.requestContext.http.method === "GET" && event.requestContext.http.path === "/version") {
-      const version = "1.4.8";
+      const version = "1.4.10";
       return createSuccessResponse({ version, timestamp: (/* @__PURE__ */ new Date()).toISOString() }, requestId);
     }
     if (event.requestContext.http.method !== "POST") {