@exabugs/dynamodb-client 1.3.34 → 1.3.36

package/dist/server/handler.cjs

@@ -1,5 +1,5 @@
-// @exabugs/dynamodb-client v1.3.34
-// Built: 2026-01-08T13:09:01.510Z
+// @exabugs/dynamodb-client v1.3.36
+// Built: 2026-01-09T00:36:32.014Z
 "use strict";
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -37,11 +37,10 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/shared/constants/http.ts
-var DEFAULT_HTTP_TIMEOUT_MS, HTTP_STATUS, HTTP_METHOD;
+var HTTP_STATUS;
 var init_http = __esm({
   "src/shared/constants/http.ts"() {
     "use strict";
-    DEFAULT_HTTP_TIMEOUT_MS = 3e4;
     HTTP_STATUS = {
       OK: 200,
       BAD_REQUEST: 400,
@@ -52,13 +51,6 @@ var init_http = __esm({
       INTERNAL_SERVER_ERROR: 500,
       NOT_IMPLEMENTED: 501
     };
-    HTTP_METHOD = {
-      GET: "GET",
-      POST: "POST",
-      PUT: "PUT",
-      DELETE: "DELETE",
-      OPTIONS: "OPTIONS"
-    };
   }
 });
 
@@ -73,43 +65,10 @@ var init_types = __esm({
 function isAppError(error2) {
   return error2 instanceof AppError;
 }
-function getErrorClass(code) {
-  switch (code) {
-    case "AUTH_ERROR" /* AUTH_ERROR */:
-      return AuthError;
-    case "CONFIG_ERROR" /* CONFIG_ERROR */:
-      return ConfigError;
-    case "INVALID_FILTER" /* INVALID_FILTER */:
-      return InvalidFilterError;
-    case "INVALID_TOKEN" /* INVALID_TOKEN */:
-      return InvalidTokenError;
-    case "ITEM_NOT_FOUND" /* ITEM_NOT_FOUND */:
-      return ItemNotFoundError;
-    case "VERSION_CONFLICT" /* VERSION_CONFLICT */:
-      return VersionConflictError;
-    default:
-      return AppError;
-  }
-}
-var ErrorCode, AppError, AuthError, ConfigError, InvalidFilterError, InvalidTokenError, ItemNotFoundError, PartialFailureError, VersionConflictError;
+var AppError, AuthError, ConfigError, InvalidTokenError, ItemNotFoundError;
 var init_errors = __esm({
   "src/shared/errors/index.ts"() {
     "use strict";
-    ErrorCode = /* @__PURE__ */ ((ErrorCode2) => {
-      ErrorCode2["AUTH_ERROR"] = "AUTH_ERROR";
-      ErrorCode2["CONFIG_ERROR"] = "CONFIG_ERROR";
-      ErrorCode2["INVALID_FILTER"] = "INVALID_FILTER";
-      ErrorCode2["INVALID_TOKEN"] = "INVALID_TOKEN";
-      ErrorCode2["ITEM_NOT_FOUND"] = "ITEM_NOT_FOUND";
-      ErrorCode2["PARTIAL_FAILURE"] = "PARTIAL_FAILURE";
-      ErrorCode2["VERSION_CONFLICT"] = "VERSION_CONFLICT";
-      ErrorCode2["VALIDATION_ERROR"] = "VALIDATION_ERROR";
-      ErrorCode2["INTERNAL_ERROR"] = "INTERNAL_ERROR";
-      ErrorCode2["NOT_IMPLEMENTED"] = "NOT_IMPLEMENTED";
-      ErrorCode2["INVALID_OPERATION"] = "INVALID_OPERATION";
-      ErrorCode2["UNKNOWN_ERROR"] = "UNKNOWN_ERROR";
-      return ErrorCode2;
-    })(ErrorCode || {});
     AppError = class extends Error {
       constructor(code, message, statusCode = 500, details) {
         super(message);
@@ -150,14 +109,6 @@ var init_errors = __esm({
         super("CONFIG_ERROR" /* CONFIG_ERROR */, message, 500, details);
       }
     };
-    InvalidFilterError = class extends AppError {
-      static {
-        __name(this, "InvalidFilterError");
-      }
-      constructor(message, details) {
-        super("INVALID_FILTER" /* INVALID_FILTER */, message, 400, details);
-      }
-    };
     InvalidTokenError = class extends AppError {
       static {
         __name(this, "InvalidTokenError");
@@ -174,30 +125,7 @@ var init_errors = __esm({
         super("ITEM_NOT_FOUND" /* ITEM_NOT_FOUND */, message, 404, details);
       }
     };
-    PartialFailureError = class extends AppError {
-      constructor(message, failedIds, errors, details) {
-        super("PARTIAL_FAILURE" /* PARTIAL_FAILURE */, message, 207, {
-          ...details,
-          failedIds,
-          errors
-        });
-        this.failedIds = failedIds;
-        this.errors = errors;
-      }
-      static {
-        __name(this, "PartialFailureError");
-      }
-    };
-    VersionConflictError = class extends AppError {
-      static {
-        __name(this, "VersionConflictError");
-      }
-      constructor(message, details) {
-        super("VERSION_CONFLICT" /* VERSION_CONFLICT */, message, 409, details);
-      }
-    };
     __name(isAppError, "isAppError");
-    __name(getErrorClass, "getErrorClass");
   }
 });
 
@@ -377,102 +305,19 @@ var init_node = __esm({
 function ulid2() {
   return ulid();
 }
-function ulidWithTime(seedTime) {
-  return ulid(seedTime);
-}
-function decodeTime(id) {
-  const timeChars = id.substring(0, 10);
-  const ENCODING2 = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
-  let time2 = 0;
-  for (let i4 = 0; i4 < timeChars.length; i4++) {
-    const char = timeChars[i4];
-    const value = ENCODING2.indexOf(char);
-    if (value === -1) {
-      throw new Error(`Invalid ULID character: ${char}`);
-    }
-    time2 = time2 * 32 + value;
-  }
-  return time2;
-}
 var init_ulid = __esm({
   "src/shared/utils/ulid.ts"() {
     "use strict";
     init_node();
     __name(ulid2, "ulid");
-    __name(ulidWithTime, "ulidWithTime");
-    __name(decodeTime, "decodeTime");
   }
 });
 
 // src/shared/utils/validation.ts
-function validateRequiredFields(obj, fields) {
-  const missingFields = fields.filter((field) => obj[field] === void 0 || obj[field] === null);
-  if (missingFields.length > 0) {
-    throw new Error(`Missing required fields: ${missingFields.join(", ")}`);
-  }
-}
-function validateNonEmptyString(value, fieldName) {
-  if (typeof value !== "string" || value.trim() === "") {
-    throw new Error(`${fieldName} must be a non-empty string`);
-  }
-}
-function validateNumberRange(value, fieldName, min, max) {
-  if (typeof value !== "number" || isNaN(value)) {
-    throw new Error(`${fieldName} must be a valid number`);
-  }
-  if (min !== void 0 && value < min) {
-    throw new Error(`${fieldName} must be at least ${min}`);
-  }
-  if (max !== void 0 && value > max) {
-    throw new Error(`${fieldName} must be at most ${max}`);
-  }
-}
-function validateNonEmptyArray(value, fieldName) {
-  if (!Array.isArray(value) || value.length === 0) {
-    throw new Error(`${fieldName} must be a non-empty array`);
-  }
-}
-function validateSortField(sortField, validFields) {
-  if (!validFields.includes(sortField)) {
-    throw new InvalidFilterError(
-      `Invalid sort field: ${sortField}. Valid fields are: ${validFields.join(", ")}`,
-      { sortField, validFields }
-    );
-  }
-}
-function validateULID(value, fieldName) {
-  if (typeof value !== "string") {
-    throw new Error(`${fieldName} must be a string`);
-  }
-  const ulidPattern = /^[0123456789ABCDEFGHJKMNPQRSTVWXYZ]{26}$/;
-  if (!ulidPattern.test(value)) {
-    throw new Error(`${fieldName} must be a valid ULID format (26 characters, Crockford's Base32)`);
-  }
-}
-function validateISO8601DateTime(value, fieldName) {
-  if (typeof value !== "string") {
-    throw new Error(`${fieldName} must be a string`);
-  }
-  const date2 = new Date(value);
-  if (isNaN(date2.getTime())) {
-    throw new Error(`${fieldName} must be a valid ISO 8601 datetime string`);
-  }
-  const iso8601Pattern = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{3})?Z?$/;
-  if (!iso8601Pattern.test(value)) {
-    throw new Error(`${fieldName} must be in ISO 8601 format (YYYY-MM-DDTHH:mm:ss.sssZ)`);
-  }
-}
 var init_validation = __esm({
   "src/shared/utils/validation.ts"() {
     "use strict";
     init_errors();
-    __name(validateRequiredFields, "validateRequiredFields");
-    __name(validateNonEmptyString, "validateNonEmptyString");
-    __name(validateNumberRange, "validateNumberRange");
-    __name(validateNonEmptyArray, "validateNonEmptyArray");
-    __name(validateSortField, "validateSortField");
-    __name(validateULID, "validateULID");
-    __name(validateISO8601DateTime, "validateISO8601DateTime");
   }
 });
 
@@ -28542,7 +28387,7 @@ var require_dist_cjs66 = __commonJS({
         return async () => handler2(this.clientCommand);
       }
     };
-    var GetCommand4 = class extends DynamoDBDocumentClientCommand {
+    var GetCommand = class extends DynamoDBDocumentClientCommand {
       static {
         __name(this, "GetCommand");
       }
@@ -28568,7 +28413,7 @@ var require_dist_cjs66 = __commonJS({
         return async () => handler2(this.clientCommand);
       }
     };
-    var PutCommand2 = class extends DynamoDBDocumentClientCommand {
+    var PutCommand = class extends DynamoDBDocumentClientCommand {
       static {
         __name(this, "PutCommand");
       }
@@ -28715,7 +28560,7 @@ var require_dist_cjs66 = __commonJS({
         return async () => handler2(this.clientCommand);
       }
     };
-    var TransactWriteCommand6 = class extends DynamoDBDocumentClientCommand {
+    var TransactWriteCommand4 = class extends DynamoDBDocumentClientCommand {
       static {
         __name(this, "TransactWriteCommand");
       }
@@ -28913,7 +28758,7 @@ var require_dist_cjs66 = __commonJS({
         }
       }
       get(args, optionsOrCb, cb) {
-        const command = new GetCommand4(args);
+        const command = new GetCommand(args);
         if (typeof optionsOrCb === "function") {
           this.send(command, optionsOrCb);
         } else if (typeof cb === "function") {
@@ -28926,7 +28771,7 @@ var require_dist_cjs66 = __commonJS({
         }
       }
       put(args, optionsOrCb, cb) {
-        const command = new PutCommand2(args);
+        const command = new PutCommand(args);
         if (typeof optionsOrCb === "function") {
           this.send(command, optionsOrCb);
         } else if (typeof cb === "function") {
@@ -28978,7 +28823,7 @@ var require_dist_cjs66 = __commonJS({
         }
       }
       transactWrite(args, optionsOrCb, cb) {
-        const command = new TransactWriteCommand6(args);
+        const command = new TransactWriteCommand4(args);
         if (typeof optionsOrCb === "function") {
           this.send(command, optionsOrCb);
         } else if (typeof cb === "function") {
@@ -29033,12 +28878,12 @@ var require_dist_cjs66 = __commonJS({
     exports2.DynamoDBDocumentClientCommand = DynamoDBDocumentClientCommand;
     exports2.ExecuteStatementCommand = ExecuteStatementCommand;
     exports2.ExecuteTransactionCommand = ExecuteTransactionCommand;
-    exports2.GetCommand = GetCommand4;
-    exports2.PutCommand = PutCommand2;
+    exports2.GetCommand = GetCommand;
+    exports2.PutCommand = PutCommand;
     exports2.QueryCommand = QueryCommand5;
     exports2.ScanCommand = ScanCommand;
     exports2.TransactGetCommand = TransactGetCommand;
-    exports2.TransactWriteCommand = TransactWriteCommand6;
+    exports2.TransactWriteCommand = TransactWriteCommand4;
     exports2.UpdateCommand = UpdateCommand;
     exports2.paginateQuery = paginateQuery;
     exports2.paginateScan = paginateScan;
@@ -29085,591 +28930,13 @@ var init_utils2 = __esm({
 });
 
 // src/shared/constants/dynamodb.ts
-var DYNAMODB_TRANSACT_WRITE_MAX_ITEMS, DYNAMODB_BATCH_GET_MAX_ITEMS, DYNAMODB_BATCH_WRITE_MAX_ITEMS, DYNAMODB_QUERY_MAX_SIZE_BYTES, DYNAMODB_SCAN_MAX_SIZE_BYTES, DYNAMODB_RESERVED_WORDS;
+var DYNAMODB_TRANSACT_WRITE_MAX_ITEMS, DYNAMODB_QUERY_MAX_SIZE_BYTES, DYNAMODB_SCAN_MAX_SIZE_BYTES;
 var init_dynamodb2 = __esm({
   "src/shared/constants/dynamodb.ts"() {
     "use strict";
     DYNAMODB_TRANSACT_WRITE_MAX_ITEMS = 100;
-    DYNAMODB_BATCH_GET_MAX_ITEMS = 100;
-    DYNAMODB_BATCH_WRITE_MAX_ITEMS = 25;
     DYNAMODB_QUERY_MAX_SIZE_BYTES = 1024 * 1024;
     DYNAMODB_SCAN_MAX_SIZE_BYTES = 1024 * 1024;
-    DYNAMODB_RESERVED_WORDS = [
-      "ABORT",
-      "ABSOLUTE",
-      "ACTION",
-      "ADD",
-      "AFTER",
-      "AGENT",
-      "AGGREGATE",
-      "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",
-      "BYTE",
-      "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",
-      "CONTAINS",
-      "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",
-      "ESCAPED",
-      "EVAL",
-      "EVALUATE",
-      "EXCEEDED",
-      "EXCEPT",
-      "EXCEPTION",
-      "EXCEPTIONS",
-      "EXCLUSIVE",
-      "EXEC",
-      "EXECUTE",
-      "EXISTS",
-      "EXIT",
-      "EXPLAIN",
-      "EXPLODE",
-      "EXPORT",
-      "EXPRESSION",
-      "EXPRESSIONS",
-      "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",
-      "GLOBAL",
-      "GO",
-      "GOTO",
-      "GRANT",
-      "GREATER",
-      "GROUP",
-      "GROUPING",
-      "HANDLER",
-      "HASH",
-      "HAVE",
-      "HAVING",
-      "HEAP",
-      "HIDDEN",
-      "HOLD",
-      "HOUR",
-      "IDENTIFIED",
-      "IDENTITY",
-      "IF",
-      "IGNORE",
-      "IMMEDIATE",
-      "IMPORT",
-      "IN",
-      "INCLUDING",
-      "INCLUSIVE",
-      "INCREMENT",
-      "INCREMENTAL",
-      "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",
-      "LIMITED",
-      "LINES",
-      "LIST",
-      "LOAD",
-      "LOCAL",
-      "LOCALTIME",
-      "LOCALTIMESTAMP",
-      "LOCATION",
-      "LOCATOR",
-      "LOCK",
-      "LOCKS",
-      "LOG",
-      "LOGED",
-      "LONG",
-      "LOOP",
-      "LOWER",
-      "MAP",
-      "MATCH",
-      "MATERIALIZED",
-      "MAX",
-      "MAXLEN",
-      "MEMBER",
-      "MERGE",
-      "METHOD",
-      "METRICS",
-      "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",
-      "OPAQUE",
-      "OPEN",
-      "OPERATOR",
-      "OPTION",
-      "OR",
-      "ORDER",
-      "ORDINALITY",
-      "OTHER",
-      "OTHERS",
-      "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",
-      "REGION",
-      "REINDEX",
-      "RELATIVE",
-      "RELEASE",
-      "REMAINDER",
-      "RENAME",
-      "REPEAT",
-      "REPLACE",
-      "REQUEST",
-      "RESET",
-      "RESIGNAL",
-      "RESOURCE",
-      "RESPONSE",
-      "RESTORE",
-      "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",
-      "SEGMENTS",
-      "SELECT",
-      "SELF",
-      "SEMI",
-      "SENSITIVE",
-      "SEPARATE",
-      "SEQUENCE",
-      "SERIALIZABLE",
-      "SESSION",
-      "SET",
-      "SETS",
-      "SHARD",
-      "SHARE",
-      "SHARED",
-      "SHORT",
-      "SHOW",
-      "SIGNAL",
-      "SIMILAR",
-      "SIZE",
-      "SKEWED",
-      "SMALLINT",
-      "SNAPSHOT",
-      "SOME",
-      "SOURCE",
-      "SPACE",
-      "SPACES",
-      "SPARSE",
-      "SPECIFIC",
-      "SPECIFICTYPE",
-      "SPLIT",
-      "SQL",
-      "SQLCODE",
-      "SQLERROR",
-      "SQLEXCEPTION",
-      "SQLSTATE",
-      "SQLWARNING",
-      "START",
-      "STATE",
-      "STATIC",
-      "STATUS",
-      "STORAGE",
-      "STORE",
-      "STORED",
-      "STREAM",
-      "STRING",
-      "STRUCTURE",
-      "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"
-    ];
   }
 });
 
@@ -29699,18 +28966,10 @@ var init_constants = __esm({
 });
 
 // src/shared/geohash/types.ts
-var GEOHASH_PRECISION_TABLE, DEFAULT_GEOHASH_CONFIG;
+var DEFAULT_GEOHASH_CONFIG;
 var init_types2 = __esm({
   "src/shared/geohash/types.ts"() {
     "use strict";
-    GEOHASH_PRECISION_TABLE = {
-      1: { error: 25e5, description: "\u5927\u9678\u30EC\u30D9\u30EB" },
-      4: { error: 2e4, description: "\u5927\u90FD\u5E02\u30EC\u30D9\u30EB" },
-      6: { error: 610, description: "\u8FD1\u96A3\u30EC\u30D9\u30EB" },
-      7: { error: 76, description: "\u8857\u533A\u30EC\u30D9\u30EB" },
-      8: { error: 19, description: "\u5EFA\u7269\u30EC\u30D9\u30EB" },
-      10: { error: 0.6, description: "\u9AD8\u7CBE\u5EA6" }
-    };
     DEFAULT_GEOHASH_CONFIG = {
       shadowPrecision: 8,
       // ±19m（建物レベル）
@@ -30045,9 +29304,6 @@ function isGeoCoordinates(value) {
 function encodeGeoHash(latitude, longitude, precision = 6) {
   return import_ngeohash.default.encode(latitude, longitude, precision);
 }
-function decodeGeoHash(geohash) {
-  return import_ngeohash.default.decode(geohash);
-}
 function getNeighborGeoHashes(geohash) {
   const neighbors = [
     geohash,
@@ -30111,14 +29367,6 @@ function extractMinDistanceFromNearQuery(query) {
     return query.minDistance;
   }
 }
-function validateLocation(latitude, longitude) {
-  if (latitude < -90 || latitude > 90) {
-    throw new Error("Latitude must be between -90 and 90");
-  }
-  if (longitude < -180 || longitude > 180) {
-    throw new Error("Longitude must be between -180 and 180");
-  }
-}
 var import_ngeohash;
 var init_utils3 = __esm({
   "src/shared/geohash/utils.ts"() {
@@ -30126,14 +29374,12 @@ var init_utils3 = __esm({
     import_ngeohash = __toESM(require_main(), 1);
     __name(isGeoCoordinates, "isGeoCoordinates");
     __name(encodeGeoHash, "encodeGeoHash");
-    __name(decodeGeoHash, "decodeGeoHash");
     __name(getNeighborGeoHashes, "getNeighborGeoHashes");
     __name(calculateDistance, "calculateDistance");
     __name(isNearQueryGeoJSON, "isNearQueryGeoJSON");
     __name(extractCoordinatesFromNearQuery, "extractCoordinatesFromNearQuery");
     __name(extractMaxDistanceFromNearQuery, "extractMaxDistanceFromNearQuery");
     __name(extractMinDistanceFromNearQuery, "extractMinDistanceFromNearQuery");
-    __name(validateLocation, "validateLocation");
   }
 });
 
@@ -30147,60 +29393,6 @@ var init_geohash = __esm({
 });
 
 // src/shared/index.ts
-var shared_exports = {};
-__export(shared_exports, {
-  AppError: () => AppError,
-  AuthError: () => AuthError,
-  ConfigError: () => ConfigError,
-  DEFAULT_GEOHASH_CONFIG: () => DEFAULT_GEOHASH_CONFIG,
-  DEFAULT_HTTP_TIMEOUT_MS: () => DEFAULT_HTTP_TIMEOUT_MS,
-  DYNAMODB_BATCH_GET_MAX_ITEMS: () => DYNAMODB_BATCH_GET_MAX_ITEMS,
-  DYNAMODB_BATCH_WRITE_MAX_ITEMS: () => DYNAMODB_BATCH_WRITE_MAX_ITEMS,
-  DYNAMODB_QUERY_MAX_SIZE_BYTES: () => DYNAMODB_QUERY_MAX_SIZE_BYTES,
-  DYNAMODB_RESERVED_WORDS: () => DYNAMODB_RESERVED_WORDS,
-  DYNAMODB_SCAN_MAX_SIZE_BYTES: () => DYNAMODB_SCAN_MAX_SIZE_BYTES,
-  DYNAMODB_TRANSACT_WRITE_MAX_ITEMS: () => DYNAMODB_TRANSACT_WRITE_MAX_ITEMS,
-  ErrorCode: () => ErrorCode,
-  GEOHASH_PRECISION_TABLE: () => GEOHASH_PRECISION_TABLE,
-  HTTP_METHOD: () => HTTP_METHOD,
-  HTTP_STATUS: () => HTTP_STATUS,
-  InvalidFilterError: () => InvalidFilterError,
-  InvalidTokenError: () => InvalidTokenError,
-  ItemNotFoundError: () => ItemNotFoundError,
-  LAMBDA_MAX_ENV_VARS_SIZE: () => LAMBDA_MAX_ENV_VARS_SIZE,
-  LAMBDA_MAX_PAYLOAD_SIZE_ASYNC: () => LAMBDA_MAX_PAYLOAD_SIZE_ASYNC,
-  LAMBDA_MAX_PAYLOAD_SIZE_SYNC: () => LAMBDA_MAX_PAYLOAD_SIZE_SYNC,
-  LAMBDA_MAX_RESPONSE_SIZE: () => LAMBDA_MAX_RESPONSE_SIZE,
-  LAMBDA_TIMEOUT_MS: () => LAMBDA_TIMEOUT_MS,
-  LARGE_BATCH_WARNING_THRESHOLD: () => LARGE_BATCH_WARNING_THRESHOLD,
-  PartialFailureError: () => PartialFailureError,
-  TIMEOUT_RISK_THRESHOLD: () => TIMEOUT_RISK_THRESHOLD,
-  VersionConflictError: () => VersionConflictError,
-  calculateDistance: () => calculateDistance,
-  createDynamoDBClient: () => createDynamoDBClient,
-  createLogger: () => createLogger,
-  decodeGeoHash: () => decodeGeoHash,
-  decodeTime: () => decodeTime,
-  encodeGeoHash: () => encodeGeoHash,
-  extractCoordinatesFromNearQuery: () => extractCoordinatesFromNearQuery,
-  extractMaxDistanceFromNearQuery: () => extractMaxDistanceFromNearQuery,
-  extractMinDistanceFromNearQuery: () => extractMinDistanceFromNearQuery,
-  getErrorClass: () => getErrorClass,
-  getNeighborGeoHashes: () => getNeighborGeoHashes,
-  isAppError: () => isAppError,
-  isGeoCoordinates: () => isGeoCoordinates,
-  isNearQueryGeoJSON: () => isNearQueryGeoJSON,
-  ulid: () => ulid2,
-  ulidWithTime: () => ulidWithTime,
-  validateISO8601DateTime: () => validateISO8601DateTime,
-  validateLocation: () => validateLocation,
-  validateNonEmptyArray: () => validateNonEmptyArray,
-  validateNonEmptyString: () => validateNonEmptyString,
-  validateNumberRange: () => validateNumberRange,
-  validateRequiredFields: () => validateRequiredFields,
-  validateSortField: () => validateSortField,
-  validateULID: () => validateULID
-});
 var init_shared = __esm({
   "src/shared/index.ts"() {
     "use strict";
@@ -30271,14 +29463,10 @@ function calculateShadowDiff(oldShadowKeys, newShadowKeys) {
     toAdd
   };
 }
-function isDiffEmpty(diff) {
-  return diff.toDelete.length === 0 && diff.toAdd.length === 0;
-}
 var init_differ = __esm({
   "src/shadows/differ.ts"() {
     "use strict";
     __name(calculateShadowDiff, "calculateShadowDiff");
-    __name(isDiffEmpty, "isDiffEmpty");
   }
 });
 
@@ -30507,6 +29695,238 @@ var init_shadow = __esm({
   }
 });
 
+// src/server/utils/bulkOperations.ts
+function logLargeBatchWarning(operation2, recordCount, requestId, resource) {
+  if (recordCount > LARGE_BATCH_WARNING_THRESHOLD) {
+    logger2.warn(`Large batch ${operation2} operation detected`, {
+      requestId,
+      resource,
+      recordCount,
+      warningThreshold: LARGE_BATCH_WARNING_THRESHOLD,
+      estimatedTimeoutRisk: "high",
+      recommendation: "Consider splitting the batch into smaller requests to avoid Lambda timeout (15 min limit)"
+    });
+  }
+}
+function calculateTimeoutRisk(startTime) {
+  const elapsedMs = Date.now() - startTime;
+  const remainingMs = LAMBDA_TIMEOUT_MS - elapsedMs;
+  const utilizationPercent = Math.round(elapsedMs / LAMBDA_TIMEOUT_MS * 100);
+  const risk = remainingMs < LAMBDA_TIMEOUT_MS * TIMEOUT_RISK_THRESHOLD ? "high" : "low";
+  return {
+    elapsedMs,
+    remainingMs,
+    risk,
+    utilizationPercent
+  };
+}
+function logPreparationTimeoutRisk(requestId, resource, totalRecords, chunkCount, riskInfo) {
+  logger2.info("Records prepared for chunk execution", {
+    requestId,
+    resource,
+    totalRecords,
+    chunkCount,
+    preparationTimeMs: riskInfo.elapsedMs,
+    remainingTimeMs: riskInfo.remainingMs,
+    timeoutRisk: riskInfo.risk
+  });
+  if (riskInfo.risk === "high") {
+    logger2.warn("High timeout risk detected during preparation phase", {
+      requestId,
+      resource,
+      preparationElapsedMs: riskInfo.elapsedMs,
+      remainingTimeMs: riskInfo.remainingMs,
+      lambdaTimeoutMs: LAMBDA_TIMEOUT_MS,
+      recommendation: "Consider reducing batch size or optimizing preparation logic"
+    });
+  }
+}
+function logBulkOperationComplete(operation2, requestId, resource, requested, succeeded, failed, riskInfo, additionalInfo) {
+  const totalElapsedSeconds = Math.round(riskInfo.elapsedMs / 1e3);
+  logger2.info(`${operation2} completed`, {
+    requestId,
+    resource,
+    requested,
+    succeeded,
+    totalFailed: failed,
+    totalExecutionTimeMs: riskInfo.elapsedMs,
+    totalExecutionTimeSeconds: totalElapsedSeconds,
+    lambdaTimeoutMs: LAMBDA_TIMEOUT_MS,
+    timeoutUtilization: `${riskInfo.utilizationPercent}%`,
+    ...additionalInfo
+  });
+}
+function logPartialFailure(operation2, requestId, resource, requested, succeeded, failed, errorCodes, additionalInfo) {
+  const failureRate = Math.round(failed / requested * 100);
+  logger2.warn(`Partial failure in ${operation2} operation`, {
+    requestId,
+    resource,
+    totalRequested: requested,
+    successCount: succeeded,
+    failedCount: failed,
+    failureRate: `${failureRate}%`,
+    errorCodes: [...new Set(errorCodes)],
+    ...additionalInfo
+  });
+}
+var logger2;
+var init_bulkOperations = __esm({
+  "src/server/utils/bulkOperations.ts"() {
+    "use strict";
+    init_shared();
+    logger2 = createLogger({ service: "records-lambda" });
+    __name(logLargeBatchWarning, "logLargeBatchWarning");
+    __name(calculateTimeoutRisk, "calculateTimeoutRisk");
+    __name(logPreparationTimeoutRisk, "logPreparationTimeoutRisk");
+    __name(logBulkOperationComplete, "logBulkOperationComplete");
+    __name(logPartialFailure, "logPartialFailure");
+  }
+});
+
+// src/server/utils/chunking.ts
+function calculateChunks(records, getItemCount) {
+  const chunks = [];
+  const itemCounts = [];
+  let currentChunk = [];
+  let currentItemCount = 0;
+  for (const record of records) {
+    const itemCount = getItemCount(record);
+    if (itemCount > DYNAMODB_TRANSACT_WRITE_MAX_ITEMS) {
+      const errorMsg = `Single record exceeds ${DYNAMODB_TRANSACT_WRITE_MAX_ITEMS} items limit: ${itemCount} items`;
+      logger3.error("Chunk validation failed", {
+        itemCount,
+        limit: DYNAMODB_TRANSACT_WRITE_MAX_ITEMS
+      });
+      throw new Error(errorMsg);
+    }
+    if (currentItemCount + itemCount > DYNAMODB_TRANSACT_WRITE_MAX_ITEMS) {
+      if (currentChunk.length > 0) {
+        chunks.push(currentChunk);
+        itemCounts.push(currentItemCount);
+      }
+      currentChunk = [record];
+      currentItemCount = itemCount;
+    } else {
+      currentChunk.push(record);
+      currentItemCount += itemCount;
+    }
+  }
+  if (currentChunk.length > 0) {
+    chunks.push(currentChunk);
+    itemCounts.push(currentItemCount);
+  }
+  logger3.info("Chunk calculation completed", {
+    totalRecords: records.length,
+    chunkCount: chunks.length,
+    itemCounts,
+    minItemsPerChunk: itemCounts.length > 0 ? Math.min(...itemCounts) : 0,
+    maxItemsPerChunk: itemCounts.length > 0 ? Math.max(...itemCounts) : 0,
+    avgItemsPerChunk: itemCounts.length > 0 ? Math.round(itemCounts.reduce((sum, count) => sum + count, 0) / itemCounts.length) : 0
+  });
+  return { chunks, itemCounts };
+}
+async function executeChunks(chunks, executeChunk, getRecordId) {
+  const successRecords = [];
+  const failedIds = [];
+  const errors = [];
+  const totalRecords = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+  const executionStartTime = Date.now();
+  logger3.info("Starting chunk execution", {
+    totalChunks: chunks.length,
+    totalRecords
+  });
+  for (let i4 = 0; i4 < chunks.length; i4++) {
+    const chunk = chunks[i4];
+    const chunkStartTime = Date.now();
+    try {
+      logger3.debug(`Executing chunk ${i4 + 1}/${chunks.length}`, {
+        chunkIndex: i4,
+        recordCount: chunk.length
+      });
+      const successfulRecords = await executeChunk(chunk);
+      successRecords.push(...successfulRecords);
+      const chunkDuration = Date.now() - chunkStartTime;
+      logger3.info(`Chunk ${i4 + 1}/${chunks.length} succeeded`, {
+        chunkIndex: i4,
+        recordCount: chunk.length,
+        durationMs: chunkDuration
+      });
+    } catch (error2) {
+      const chunkDuration = Date.now() - chunkStartTime;
+      const errorMessage = error2 instanceof Error ? error2.message : "Unknown error";
+      const errorCode = getErrorCode(error2);
+      logger3.error(`Chunk ${i4 + 1}/${chunks.length} failed`, {
+        chunkIndex: i4,
+        recordCount: chunk.length,
+        durationMs: chunkDuration,
+        error: errorMessage,
+        errorCode
+      });
+      for (const record of chunk) {
+        const recordId = getRecordId(record);
+        failedIds.push(recordId);
+        errors.push({
+          id: recordId,
+          code: errorCode,
+          message: errorMessage
+        });
+      }
+    }
+  }
+  const totalExecutionTime = Date.now() - executionStartTime;
+  logger3.info("Chunk execution completed", {
+    totalChunks: chunks.length,
+    totalRecords,
+    successCount: successRecords.length,
+    failedCount: failedIds.length,
+    totalExecutionTimeMs: totalExecutionTime,
+    avgTimePerChunkMs: chunks.length > 0 ? Math.round(totalExecutionTime / chunks.length) : 0
+  });
+  if (failedIds.length > 0) {
+    logger3.warn("Partial failure detected in chunk execution", {
+      totalRecords,
+      successCount: successRecords.length,
+      failedCount: failedIds.length,
+      failureRate: `${Math.round(failedIds.length / totalRecords * 100)}%`,
+      failedIds: failedIds.slice(0, 10),
+      // 最初の10件のみログ出力
+      errorSummary: errors.slice(0, 5).map((e4) => ({
+        id: e4.id,
+        code: e4.code,
+        message: e4.message.substring(0, 100)
+        // メッセージを100文字に制限
+      }))
+    });
+  }
+  return {
+    successRecords,
+    failedIds,
+    errors
+  };
+}
+function getErrorCode(error2) {
+  if (error2 && typeof error2 === "object") {
+    if ("name" in error2 && typeof error2.name === "string") {
+      return error2.name;
+    }
+    if ("code" in error2 && typeof error2.code === "string") {
+      return error2.code;
+    }
+  }
+  return "TRANSACTION_FAILED";
+}
+var logger3;
+var init_chunking = __esm({
+  "src/server/utils/chunking.ts"() {
+    "use strict";
+    init_shared();
+    logger3 = createLogger({ service: "records-lambda" });
+    __name(calculateChunks, "calculateChunks");
+    __name(executeChunks, "executeChunks");
+    __name(getErrorCode, "getErrorCode");
+  }
+});
+
 // src/server/utils/dynamodb.ts
 function getDBClient() {
   if (!dbClient) {
@@ -30564,7 +29984,7 @@ var init_dynamodb3 = __esm({
 });
 
 // src/server/utils/validation.ts
-function validateSortField2(_config, _resource, _sort) {
+function validateSortField(_config, _resource, _sort) {
   return;
 }
 function normalizePagination(pagination) {
@@ -30584,7 +30004,7 @@ function normalizeSort(config, _resource, sort) {
 var init_validation2 = __esm({
   "src/server/utils/validation.ts"() {
     "use strict";
-    __name(validateSortField2, "validateSortField");
+    __name(validateSortField, "validateSortField");
     __name(normalizePagination, "normalizePagination");
     __name(normalizeSort, "normalizeSort");
   }
@@ -31503,7 +30923,7 @@ async function handleFind(resource, params, requestId) {
   }
   const config = initializeFindConfig();
   const normalizedParams = normalizeFindParams(config, resource, params);
-  validateSortField2(config, resource, normalizedParams.sort);
+  validateSortField(config, resource, normalizedParams.sort);
   logger9.debug("Find parameters normalized", {
     requestId,
     resource,
@@ -31546,246 +30966,11 @@ var init_find = __esm({
   }
 });
 
-// src/server/handler.ts
-var handler_exports = {};
-__export(handler_exports, {
-  handler: () => handler
-});
-module.exports = __toCommonJS(handler_exports);
-init_http();
-init_shared();
-
-// src/server/operations/operationDispatcher.ts
-init_shared();
-
 // src/server/operations/deleteMany.ts
-var import_lib_dynamodb5 = __toESM(require_dist_cjs66(), 1);
-init_shared();
-init_shadow();
-
-// src/server/utils/bulkOperations.ts
-init_shared();
-var logger2 = createLogger({ service: "records-lambda" });
-function logLargeBatchWarning(operation2, recordCount, requestId, resource) {
-  if (recordCount > LARGE_BATCH_WARNING_THRESHOLD) {
-    logger2.warn(`Large batch ${operation2} operation detected`, {
-      requestId,
-      resource,
-      recordCount,
-      warningThreshold: LARGE_BATCH_WARNING_THRESHOLD,
-      estimatedTimeoutRisk: "high",
-      recommendation: "Consider splitting the batch into smaller requests to avoid Lambda timeout (15 min limit)"
-    });
-  }
-}
-__name(logLargeBatchWarning, "logLargeBatchWarning");
-function calculateTimeoutRisk(startTime) {
-  const elapsedMs = Date.now() - startTime;
-  const remainingMs = LAMBDA_TIMEOUT_MS - elapsedMs;
-  const utilizationPercent = Math.round(elapsedMs / LAMBDA_TIMEOUT_MS * 100);
-  const risk = remainingMs < LAMBDA_TIMEOUT_MS * TIMEOUT_RISK_THRESHOLD ? "high" : "low";
-  return {
-    elapsedMs,
-    remainingMs,
-    risk,
-    utilizationPercent
-  };
-}
-__name(calculateTimeoutRisk, "calculateTimeoutRisk");
-function logPreparationTimeoutRisk(requestId, resource, totalRecords, chunkCount, riskInfo) {
-  logger2.info("Records prepared for chunk execution", {
-    requestId,
-    resource,
-    totalRecords,
-    chunkCount,
-    preparationTimeMs: riskInfo.elapsedMs,
-    remainingTimeMs: riskInfo.remainingMs,
-    timeoutRisk: riskInfo.risk
-  });
-  if (riskInfo.risk === "high") {
-    logger2.warn("High timeout risk detected during preparation phase", {
-      requestId,
-      resource,
-      preparationElapsedMs: riskInfo.elapsedMs,
-      remainingTimeMs: riskInfo.remainingMs,
-      lambdaTimeoutMs: LAMBDA_TIMEOUT_MS,
-      recommendation: "Consider reducing batch size or optimizing preparation logic"
-    });
-  }
-}
-__name(logPreparationTimeoutRisk, "logPreparationTimeoutRisk");
-function logBulkOperationComplete(operation2, requestId, resource, requested, succeeded, failed, riskInfo, additionalInfo) {
-  const totalElapsedSeconds = Math.round(riskInfo.elapsedMs / 1e3);
-  logger2.info(`${operation2} completed`, {
-    requestId,
-    resource,
-    requested,
-    succeeded,
-    totalFailed: failed,
-    totalExecutionTimeMs: riskInfo.elapsedMs,
-    totalExecutionTimeSeconds: totalElapsedSeconds,
-    lambdaTimeoutMs: LAMBDA_TIMEOUT_MS,
-    timeoutUtilization: `${riskInfo.utilizationPercent}%`,
-    ...additionalInfo
-  });
-}
-__name(logBulkOperationComplete, "logBulkOperationComplete");
-function logPartialFailure(operation2, requestId, resource, requested, succeeded, failed, errorCodes, additionalInfo) {
-  const failureRate = Math.round(failed / requested * 100);
-  logger2.warn(`Partial failure in ${operation2} operation`, {
-    requestId,
-    resource,
-    totalRequested: requested,
-    successCount: succeeded,
-    failedCount: failed,
-    failureRate: `${failureRate}%`,
-    errorCodes: [...new Set(errorCodes)],
-    ...additionalInfo
-  });
-}
-__name(logPartialFailure, "logPartialFailure");
-
-// src/server/utils/chunking.ts
-init_shared();
-var logger3 = createLogger({ service: "records-lambda" });
-function calculateChunks(records, getItemCount) {
-  const chunks = [];
-  const itemCounts = [];
-  let currentChunk = [];
-  let currentItemCount = 0;
-  for (const record of records) {
-    const itemCount = getItemCount(record);
-    if (itemCount > DYNAMODB_TRANSACT_WRITE_MAX_ITEMS) {
-      const errorMsg = `Single record exceeds ${DYNAMODB_TRANSACT_WRITE_MAX_ITEMS} items limit: ${itemCount} items`;
-      logger3.error("Chunk validation failed", {
-        itemCount,
-        limit: DYNAMODB_TRANSACT_WRITE_MAX_ITEMS
-      });
-      throw new Error(errorMsg);
-    }
-    if (currentItemCount + itemCount > DYNAMODB_TRANSACT_WRITE_MAX_ITEMS) {
-      if (currentChunk.length > 0) {
-        chunks.push(currentChunk);
-        itemCounts.push(currentItemCount);
-      }
-      currentChunk = [record];
-      currentItemCount = itemCount;
-    } else {
-      currentChunk.push(record);
-      currentItemCount += itemCount;
-    }
-  }
-  if (currentChunk.length > 0) {
-    chunks.push(currentChunk);
-    itemCounts.push(currentItemCount);
-  }
-  logger3.info("Chunk calculation completed", {
-    totalRecords: records.length,
-    chunkCount: chunks.length,
-    itemCounts,
-    minItemsPerChunk: itemCounts.length > 0 ? Math.min(...itemCounts) : 0,
-    maxItemsPerChunk: itemCounts.length > 0 ? Math.max(...itemCounts) : 0,
-    avgItemsPerChunk: itemCounts.length > 0 ? Math.round(itemCounts.reduce((sum, count) => sum + count, 0) / itemCounts.length) : 0
-  });
-  return { chunks, itemCounts };
-}
-__name(calculateChunks, "calculateChunks");
-async function executeChunks(chunks, executeChunk, getRecordId) {
-  const successRecords = [];
-  const failedIds = [];
-  const errors = [];
-  const totalRecords = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
-  const executionStartTime = Date.now();
-  logger3.info("Starting chunk execution", {
-    totalChunks: chunks.length,
-    totalRecords
-  });
-  for (let i4 = 0; i4 < chunks.length; i4++) {
-    const chunk = chunks[i4];
-    const chunkStartTime = Date.now();
-    try {
-      logger3.debug(`Executing chunk ${i4 + 1}/${chunks.length}`, {
-        chunkIndex: i4,
-        recordCount: chunk.length
-      });
-      const successfulRecords = await executeChunk(chunk);
-      successRecords.push(...successfulRecords);
-      const chunkDuration = Date.now() - chunkStartTime;
-      logger3.info(`Chunk ${i4 + 1}/${chunks.length} succeeded`, {
-        chunkIndex: i4,
-        recordCount: chunk.length,
-        durationMs: chunkDuration
-      });
-    } catch (error2) {
-      const chunkDuration = Date.now() - chunkStartTime;
-      const errorMessage = error2 instanceof Error ? error2.message : "Unknown error";
-      const errorCode = getErrorCode(error2);
-      logger3.error(`Chunk ${i4 + 1}/${chunks.length} failed`, {
-        chunkIndex: i4,
-        recordCount: chunk.length,
-        durationMs: chunkDuration,
-        error: errorMessage,
-        errorCode
-      });
-      for (const record of chunk) {
-        const recordId = getRecordId(record);
-        failedIds.push(recordId);
-        errors.push({
-          id: recordId,
-          code: errorCode,
-          message: errorMessage
-        });
-      }
-    }
-  }
-  const totalExecutionTime = Date.now() - executionStartTime;
-  logger3.info("Chunk execution completed", {
-    totalChunks: chunks.length,
-    totalRecords,
-    successCount: successRecords.length,
-    failedCount: failedIds.length,
-    totalExecutionTimeMs: totalExecutionTime,
-    avgTimePerChunkMs: chunks.length > 0 ? Math.round(totalExecutionTime / chunks.length) : 0
-  });
-  if (failedIds.length > 0) {
-    logger3.warn("Partial failure detected in chunk execution", {
-      totalRecords,
-      successCount: successRecords.length,
-      failedCount: failedIds.length,
-      failureRate: `${Math.round(failedIds.length / totalRecords * 100)}%`,
-      failedIds: failedIds.slice(0, 10),
-      // 最初の10件のみログ出力
-      errorSummary: errors.slice(0, 5).map((e4) => ({
-        id: e4.id,
-        code: e4.code,
-        message: e4.message.substring(0, 100)
-        // メッセージを100文字に制限
-      }))
-    });
-  }
-  return {
-    successRecords,
-    failedIds,
-    errors
-  };
-}
-__name(executeChunks, "executeChunks");
-function getErrorCode(error2) {
-  if (error2 && typeof error2 === "object") {
-    if ("name" in error2 && typeof error2.name === "string") {
-      return error2.name;
-    }
-    if ("code" in error2 && typeof error2.code === "string") {
-      return error2.code;
-    }
-  }
-  return "TRANSACTION_FAILED";
-}
-__name(getErrorCode, "getErrorCode");
-
-// src/server/operations/deleteMany.ts
-init_dynamodb3();
-var logger10 = createLogger({ service: "records-lambda" });
+var deleteMany_exports = {};
+__export(deleteMany_exports, {
+  handleDeleteMany: () => handleDeleteMany
+});
 async function handleDeleteMany(resource, params, requestId) {
   const startTime = Date.now();
   let ids;
@@ -32009,324 +31194,156 @@ async function handleDeleteMany(resource, params, requestId) {
     errors: errorsMap
   };
 }
-__name(handleDeleteMany, "handleDeleteMany");
+var import_lib_dynamodb5, logger10;
+var init_deleteMany = __esm({
+  "src/server/operations/deleteMany.ts"() {
+    "use strict";
+    import_lib_dynamodb5 = __toESM(require_dist_cjs66(), 1);
+    init_shared();
+    init_shadow();
+    init_bulkOperations();
+    init_chunking();
+    init_dynamodb3();
+    logger10 = createLogger({ service: "records-lambda" });
+    __name(handleDeleteMany, "handleDeleteMany");
+  }
+});
 
-// src/server/operations/deleteOne.ts
-var import_lib_dynamodb6 = __toESM(require_dist_cjs66(), 1);
-init_shared();
-init_shadow();
-init_dynamodb3();
-var logger11 = createLogger({ service: "records-lambda" });
-async function handleDeleteOne(resource, params, requestId) {
-  let targetId;
-  if ("id" in params) {
-    targetId = params.id;
-    logger11.debug("Executing deleteOne with id", {
+// src/server/operations/findMany.ts
+async function handleFindMany(resource, params, requestId) {
+  if ("ids" in params) {
+    const { ids } = params;
+    logger12.debug("Executing findMany by ids", {
       requestId,
       resource,
-      id: targetId
+      count: ids.length
     });
-  } else {
-    logger11.debug("Executing deleteOne with filter", {
+    if (ids.length === 0) {
+      return [];
+    }
+    const dbClient2 = getDBClient();
+    const tableName = getTableName();
+    const keys = ids.map((id) => ({
+      PK: resource,
+      SK: generateMainRecordSK2(id)
+    }));
+    const result = await executeDynamoDBOperation(
+      () => dbClient2.send(
+        new import_lib_dynamodb6.BatchGetCommand({
+          RequestItems: {
+            [tableName]: {
+              Keys: keys,
+              ConsistentRead: true
+            }
+          }
+        })
+      ),
+      "BatchGetItem"
+    );
+    const items = result.Responses?.[tableName] || [];
+    const records = items.map((item) => extractCleanRecord(item));
+    logger12.info("findMany by ids succeeded", {
       requestId,
       resource,
-      filter: params.filter
+      requested: ids.length,
+      found: records.length
     });
-    const { handleFind: handleFind2 } = await Promise.resolve().then(() => (init_find(), find_exports));
-    const findResult = await handleFind2(
+    return records;
+  }
+  if ("filter" in params) {
+    const { filter } = params;
+    logger12.debug("Executing findMany by filter", {
+      requestId,
+      resource,
+      filter
+    });
+    const findResult = await handleFind(
       resource,
-      { filter: params.filter, pagination: { perPage: 1 } },
+      {
+        filter
+      },
       requestId
     );
-    if (findResult.items.length === 0) {
-      throw new ItemNotFoundError(`Record not found with filter`, {
-        resource,
-        filter: params.filter
-      });
-    }
-    const foundRecord = findResult.items[0];
-    targetId = foundRecord.id;
-  }
-  const dbClient2 = getDBClient();
-  const tableName = getTableName();
-  const mainSK = generateMainRecordSK2(targetId);
-  const getResult = await executeDynamoDBOperation(
-    () => dbClient2.send(
-      new import_lib_dynamodb6.GetCommand({
-        TableName: tableName,
-        Key: {
-          PK: resource,
-          SK: mainSK
-        },
-        ConsistentRead: true
-      })
-    ),
-    "GetItem"
-  );
-  if (!getResult.Item) {
-    throw new ItemNotFoundError(`Record not found: ${targetId}`, { resource, id: targetId });
-  }
-  const existingData = getResult.Item.data;
-  const shadowKeys = existingData.__shadowKeys || [];
-  const transactItems = [];
-  transactItems.push({
-    Delete: {
-      TableName: tableName,
-      Key: {
-        PK: resource,
-        SK: mainSK
-      }
-    }
-  });
-  for (const shadowSK of shadowKeys) {
-    transactItems.push({
-      Delete: {
-        TableName: tableName,
-        Key: {
-          PK: resource,
-          SK: shadowSK
-        }
-      }
+    logger12.info("findMany by filter succeeded", {
+      requestId,
+      resource,
+      filter,
+      found: findResult.items.length
     });
+    return findResult.items;
   }
-  await executeDynamoDBOperation(
-    () => dbClient2.send(
-      new import_lib_dynamodb6.TransactWriteCommand({
-        TransactItems: transactItems
-      })
-    ),
-    "TransactWriteItems"
-  );
-  logger11.info("deleteOne succeeded", {
-    requestId,
-    resource,
-    id: targetId,
-    shadowCount: shadowKeys.length
-  });
-  return { id: targetId };
+  throw new Error("findMany requires either ids or filter");
 }
-__name(handleDeleteOne, "handleDeleteOne");
-
-// src/server/operations/operationDispatcher.ts
-init_find();
-
-// src/server/operations/findMany.ts
-var import_lib_dynamodb7 = __toESM(require_dist_cjs66(), 1);
-init_shared();
-init_shadow();
-init_dynamodb3();
-var logger12 = createLogger({ service: "records-lambda" });
-async function handleFindMany(resource, params, requestId) {
-  const { ids } = params;
-  logger12.debug("Executing findMany", {
-    requestId,
-    resource,
-    count: ids.length
-  });
-  if (ids.length === 0) {
-    return [];
+var import_lib_dynamodb6, logger12;
+var init_findMany = __esm({
+  "src/server/operations/findMany.ts"() {
+    "use strict";
+    import_lib_dynamodb6 = __toESM(require_dist_cjs66(), 1);
+    init_shared();
+    init_shadow();
+    init_dynamodb3();
+    init_find();
+    logger12 = createLogger({ service: "records-lambda" });
+    __name(handleFindMany, "handleFindMany");
   }
-  const dbClient2 = getDBClient();
-  const tableName = getTableName();
-  const keys = ids.map((id) => ({
-    PK: resource,
-    SK: generateMainRecordSK2(id)
-  }));
-  const result = await executeDynamoDBOperation(
-    () => dbClient2.send(
-      new import_lib_dynamodb7.BatchGetCommand({
-        RequestItems: {
-          [tableName]: {
-            Keys: keys,
-            ConsistentRead: true
-          }
-        }
-      })
-    ),
-    "BatchGetItem"
-  );
-  const items = result.Responses?.[tableName] || [];
-  const records = items.map((item) => extractCleanRecord(item));
-  logger12.info("findMany succeeded", {
-    requestId,
-    resource,
-    requested: ids.length,
-    found: records.length
-  });
-  return records;
-}
-__name(handleFindMany, "handleFindMany");
+});
 
-// src/server/operations/findManyReference.ts
-var import_lib_dynamodb8 = __toESM(require_dist_cjs66(), 1);
-init_shared();
-init_shadow();
-init_dynamodb3();
-init_pagination();
-init_validation2();
-var logger13 = createLogger({ service: "records-lambda" });
-async function handleFindManyReference(resource, params, requestId) {
-  const { target, id, filter, sort: sortParam, pagination } = params;
-  logger13.debug("Executing findManyReference", {
-    requestId,
-    resource,
-    target,
-    id
-  });
-  const shadowConfig = getShadowConfig();
-  const sort = normalizeSort(shadowConfig, resource, sortParam);
-  validateSortField2(shadowConfig, resource, sort);
-  const { perPage, nextToken } = normalizePagination(pagination);
-  const dbClient2 = getDBClient();
-  const tableName = getTableName();
-  const skPrefix = `${sort.field}#`;
-  let exclusiveStartKey;
-  if (nextToken) {
-    const decoded = decodeNextToken(nextToken);
-    exclusiveStartKey = {
-      PK: decoded.PK,
-      SK: decoded.SK
-    };
-  }
-  const queryResult = await executeDynamoDBOperation(
-    () => dbClient2.send(
-      new import_lib_dynamodb8.QueryCommand({
-        TableName: tableName,
-        KeyConditionExpression: "PK = :pk AND begins_with(SK, :skPrefix)",
-        ExpressionAttributeValues: {
-          ":pk": resource,
-          ":skPrefix": skPrefix
-        },
-        ScanIndexForward: sort.order === "ASC",
-        Limit: perPage,
-        ExclusiveStartKey: exclusiveStartKey,
-        ConsistentRead: true
-      })
-    ),
-    "Query"
-  );
-  const shadowItems = queryResult.Items || [];
-  if (shadowItems.length === 0) {
-    return {
-      items: [],
-      pageInfo: {
-        hasNextPage: false,
-        hasPreviousPage: false
-      }
-    };
+// src/server/operations/findOne.ts
+var findOne_exports = {};
+__export(findOne_exports, {
+  handleFindOne: () => handleFindOne
+});
+async function handleFindOne(resource, params, requestId) {
+  if ("id" in params) {
+    const { id } = params;
+    logger14.debug("Executing findOne by id (using findMany)", {
+      requestId,
+      resource,
+      id
+    });
+    const results = await handleFindMany(resource, { ids: [id] }, requestId);
+    if (results.length === 0) {
+      throw new ItemNotFoundError(`Record not found: ${id}`, { resource, id });
+    }
+    logger14.info("findOne by id succeeded", {
+      requestId,
+      resource,
+      id
+    });
+    return results[0];
   }
-  const recordIds = shadowItems.map((item) => {
-    const sk = item.SK;
-    const parts = sk.split("#id#");
-    return parts[parts.length - 1];
-  });
-  const batchGetResult = await executeDynamoDBOperation(
-    () => dbClient2.send(
-      new import_lib_dynamodb8.BatchGetCommand({
-        RequestItems: {
-          [tableName]: {
-            Keys: recordIds.map((recordId) => ({
-              PK: resource,
-              SK: `id#${recordId}`
-            })),
-            ConsistentRead: true
-          }
-        }
-      })
-    ),
-    "BatchGetItem"
-  );
-  const mainRecords = batchGetResult.Responses?.[tableName] || [];
-  const recordMap = new Map(
-    mainRecords.map((item) => {
-      const data2 = item.data;
-      return [data2.id, extractCleanRecord(item)];
-    })
-  );
-  let items = recordIds.map((recordId) => recordMap.get(recordId)).filter((record) => record !== void 0);
-  items = items.filter((record) => record[target] === id);
-  if (filter && Object.keys(filter).length > 0) {
-    items = items.filter((record) => {
-      return Object.entries(filter).every(([key, value]) => {
-        return record[key] === value;
-      });
+  if ("filter" in params) {
+    const { filter } = params;
+    logger14.debug("Executing findOne by filter (using findMany)", {
+      requestId,
+      resource,
+      filter
     });
+    const results = await handleFindMany(resource, { filter }, requestId);
+    if (results.length === 0) {
+      throw new ItemNotFoundError(`Record not found with filter`, { resource, filter });
+    }
+    logger14.info("findOne by filter succeeded", {
+      requestId,
+      resource,
+      filter
+    });
+    return results[0];
   }
-  const hasNextPage = queryResult.LastEvaluatedKey !== void 0;
-  const nextTokenValue = hasNextPage && queryResult.LastEvaluatedKey ? encodeNextToken(
-    queryResult.LastEvaluatedKey.PK,
-    queryResult.LastEvaluatedKey.SK
-  ) : void 0;
-  logger13.info("findManyReference succeeded", {
-    requestId,
-    resource,
-    target,
-    id,
-    count: items.length,
-    hasNextPage
-  });
-  return {
-    items,
-    pageInfo: {
-      hasNextPage,
-      hasPreviousPage: !!nextToken
-    },
-    ...nextTokenValue && { nextToken: nextTokenValue }
-  };
+  throw new Error("findOne requires either id or filter");
 }
-__name(handleFindManyReference, "handleFindManyReference");
-
-// src/server/operations/findOne.ts
-var import_lib_dynamodb9 = __toESM(require_dist_cjs66(), 1);
-init_shared();
-init_shadow();
-init_dynamodb3();
-var logger14 = createLogger({ service: "records-lambda" });
-async function handleFindOne(resource, params, requestId) {
-  const { id } = params;
-  logger14.debug("Executing findOne", {
-    requestId,
-    resource,
-    id
-  });
-  const dbClient2 = getDBClient();
-  const tableName = getTableName();
-  const sk = generateMainRecordSK2(id);
-  const result = await executeDynamoDBOperation(
-    () => dbClient2.send(
-      new import_lib_dynamodb9.GetCommand({
-        TableName: tableName,
-        Key: {
-          PK: resource,
-          SK: sk
-        },
-        ConsistentRead: true
-      })
-    ),
-    "GetItem"
-  );
-  if (!result.Item) {
-    throw new ItemNotFoundError(`Record not found: ${id}`, { resource, id });
+var logger14;
+var init_findOne = __esm({
+  "src/server/operations/findOne.ts"() {
+    "use strict";
+    init_shared();
+    init_findMany();
+    logger14 = createLogger({ service: "records-lambda" });
+    __name(handleFindOne, "handleFindOne");
   }
-  const record = extractCleanRecord(result.Item);
-  logger14.info("findOne succeeded", {
-    requestId,
-    resource,
-    id
-  });
-  return record;
-}
-__name(handleFindOne, "handleFindOne");
-
-// src/server/operations/insertMany.ts
-var import_lib_dynamodb10 = __toESM(require_dist_cjs66(), 1);
-init_shared();
-init_shadow();
-init_shadow();
-init_dynamodb3();
+});
 
 // src/server/utils/timestamps.ts
-init_index2();
 function getTimestampFields() {
   const shadowConfig = getShadowConfig();
   return {
@@ -32334,7 +31351,6 @@ function getTimestampFields() {
     updatedAt: shadowConfig.updatedAtField
   };
 }
-__name(getTimestampFields, "getTimestampFields");
 function addCreateTimestamps(data2) {
   const timestampFields = getTimestampFields();
   if (!timestampFields) {
@@ -32347,7 +31363,6 @@ function addCreateTimestamps(data2) {
     [timestampFields.updatedAt]: now
   };
 }
-__name(addCreateTimestamps, "addCreateTimestamps");
 function addUpdateTimestamp(data2) {
   const timestampFields = getTimestampFields();
   if (!timestampFields) {
@@ -32359,11 +31374,17 @@ function addUpdateTimestamp(data2) {
     [timestampFields.updatedAt]: now
   };
 }
-__name(addUpdateTimestamp, "addUpdateTimestamp");
+var init_timestamps = __esm({
+  "src/server/utils/timestamps.ts"() {
+    "use strict";
+    init_index2();
+    __name(getTimestampFields, "getTimestampFields");
+    __name(addCreateTimestamps, "addCreateTimestamps");
+    __name(addUpdateTimestamp, "addUpdateTimestamp");
+  }
+});
 
 // src/server/utils/ttl.ts
-init_index2();
-var logger15 = createLogger({ service: "records-lambda" });
 function calculateTTL(resource, createdAt) {
   const envKey = `${resource.toUpperCase()}_TTL_DAYS`;
   const ttlDaysStr = process.env[envKey];
@@ -32387,7 +31408,6 @@ function calculateTTL(resource, createdAt) {
   });
   return ttl;
 }
-__name(calculateTTL, "calculateTTL");
 function addTTL(resource, recordData) {
   const createdAt = recordData.createdAt;
   if (!createdAt) {
@@ -32403,10 +31423,22 @@ function addTTL(resource, recordData) {
     ttl
   };
 }
-__name(addTTL, "addTTL");
+var logger15;
+var init_ttl = __esm({
+  "src/server/utils/ttl.ts"() {
+    "use strict";
+    init_index2();
+    logger15 = createLogger({ service: "records-lambda" });
+    __name(calculateTTL, "calculateTTL");
+    __name(addTTL, "addTTL");
+  }
+});
 
 // src/server/operations/insertMany.ts
-var logger16 = createLogger({ service: "records-lambda" });
+var insertMany_exports = {};
+__export(insertMany_exports, {
+  handleInsertMany: () => handleInsertMany
+});
 async function handleInsertMany(resource, params, requestId) {
   const { data: recordsData } = params;
   const startTime = Date.now();
@@ -32510,7 +31542,7 @@ async function handleInsertMany(resource, params, requestId) {
     }
     await executeDynamoDBOperation(
       () => dbClient2.send(
-        new import_lib_dynamodb10.TransactWriteCommand({
+        new import_lib_dynamodb8.TransactWriteCommand({
           TransactItems: transactItems
         })
       ),
@@ -32597,7 +31629,6 @@ async function handleInsertMany(resource, params, requestId) {
     errors: errorsMap
   };
 }
-__name(handleInsertMany, "handleInsertMany");
 function getPreparationErrorCode(error2) {
   if (error2 && typeof error2 === "object") {
     if ("code" in error2 && typeof error2.code === "string") {
@@ -32609,72 +31640,30 @@ function getPreparationErrorCode(error2) {
   }
   return "VALIDATION_ERROR" /* VALIDATION_ERROR */;
 }
-__name(getPreparationErrorCode, "getPreparationErrorCode");
-
-// src/server/operations/insertOne.ts
-var import_lib_dynamodb11 = __toESM(require_dist_cjs66(), 1);
-init_shared();
-init_shadow();
-init_shadow();
-init_dynamodb3();
-var logger17 = createLogger({ service: "records-lambda" });
-async function handleInsertOne(resource, params, requestId) {
-  logger17.debug("Executing insertOne", {
-    requestId,
-    resource
-  });
-  const dbClient2 = getDBClient();
-  const tableName = getTableName();
-  const id = params.data.id || ulid2();
-  let recordData = addCreateTimestamps({
-    ...params.data,
-    id
-  });
-  recordData = addTTL(resource, recordData);
-  const shadowConfig = getShadowConfig();
-  const shadowRecords = generateShadowRecords(recordData, resource, shadowConfig);
-  const mainSK = generateMainRecordSK2(id);
-  await executeDynamoDBOperation(
-    () => dbClient2.send(
-      new import_lib_dynamodb11.PutCommand({
-        TableName: tableName,
-        Item: {
-          PK: resource,
-          SK: mainSK,
-          data: recordData
-        }
-      })
-    ),
-    "PutItem"
-  );
-  for (const shadowRecord of shadowRecords) {
-    await executeDynamoDBOperation(
-      () => dbClient2.send(
-        new import_lib_dynamodb11.PutCommand({
-          TableName: tableName,
-          Item: shadowRecord
-        })
-      ),
-      "PutItem"
-    );
+var import_lib_dynamodb8, logger16;
+var init_insertMany = __esm({
+  "src/server/operations/insertMany.ts"() {
+    "use strict";
+    import_lib_dynamodb8 = __toESM(require_dist_cjs66(), 1);
+    init_shared();
+    init_shadow();
+    init_shadow();
+    init_bulkOperations();
+    init_chunking();
+    init_dynamodb3();
+    init_timestamps();
+    init_ttl();
+    logger16 = createLogger({ service: "records-lambda" });
+    __name(handleInsertMany, "handleInsertMany");
+    __name(getPreparationErrorCode, "getPreparationErrorCode");
   }
-  logger17.info("insertOne succeeded", {
-    requestId,
-    resource,
-    id,
-    shadowCount: shadowRecords.length
-  });
-  return recordData;
-}
-__name(handleInsertOne, "handleInsertOne");
+});
 
 // src/server/operations/updateMany.ts
-var import_lib_dynamodb12 = __toESM(require_dist_cjs66(), 1);
-init_shared();
-init_shadow();
-init_shadow();
-init_dynamodb3();
-var logger18 = createLogger({ service: "records-lambda" });
+var updateMany_exports = {};
+__export(updateMany_exports, {
+  handleUpdateMany: () => handleUpdateMany
+});
 function applyJsonMergePatch(target, patch) {
   const result = { ...target };
   for (const [key, value] of Object.entries(patch)) {
@@ -32691,7 +31680,6 @@ function applyJsonMergePatch(target, patch) {
   }
   return result;
 }
-__name(applyJsonMergePatch, "applyJsonMergePatch");
 async function handleUpdateMany(resource, params, requestId) {
   const { data: patchData } = params;
   const startTime = Date.now();
@@ -32735,7 +31723,7 @@ async function handleUpdateMany(resource, params, requestId) {
   }));
   const batchGetResult = await executeDynamoDBOperation(
     () => dbClient2.send(
-      new import_lib_dynamodb12.BatchGetCommand({
+      new import_lib_dynamodb9.BatchGetCommand({
         RequestItems: {
           [tableName]: {
             Keys: keys,
@@ -32854,7 +31842,7 @@ async function handleUpdateMany(resource, params, requestId) {
     }
     await executeDynamoDBOperation(
       () => dbClient2.send(
-        new import_lib_dynamodb12.TransactWriteCommand({
+        new import_lib_dynamodb9.TransactWriteCommand({
           TransactItems: transactItems
         })
       ),
@@ -32953,7 +31941,6 @@ async function handleUpdateMany(resource, params, requestId) {
     errors: errorsMap
   };
 }
-__name(handleUpdateMany, "handleUpdateMany");
 function getPreparationErrorCode2(error2) {
   if (error2 && typeof error2 === "object") {
     if ("code" in error2 && typeof error2.code === "string") {
@@ -32965,236 +31952,338 @@ function getPreparationErrorCode2(error2) {
   }
   return "VALIDATION_ERROR" /* VALIDATION_ERROR */;
 }
-__name(getPreparationErrorCode2, "getPreparationErrorCode");
+var import_lib_dynamodb9, logger18;
+var init_updateMany = __esm({
+  "src/server/operations/updateMany.ts"() {
+    "use strict";
+    import_lib_dynamodb9 = __toESM(require_dist_cjs66(), 1);
+    init_shared();
+    init_shadow();
+    init_shadow();
+    init_bulkOperations();
+    init_chunking();
+    init_dynamodb3();
+    init_timestamps();
+    logger18 = createLogger({ service: "records-lambda" });
+    __name(applyJsonMergePatch, "applyJsonMergePatch");
+    __name(handleUpdateMany, "handleUpdateMany");
+    __name(getPreparationErrorCode2, "getPreparationErrorCode");
+  }
+});
 
-// src/server/operations/updateOne.ts
-var import_lib_dynamodb13 = __toESM(require_dist_cjs66(), 1);
+// src/server/handler.ts
+var handler_exports = {};
+__export(handler_exports, {
+  handler: () => handler
+});
+module.exports = __toCommonJS(handler_exports);
+init_http();
 init_shared();
-init_shadow();
-init_shadow();
-init_dynamodb3();
-var logger19 = createLogger({ service: "records-lambda" });
-function applyJsonMergePatch2(target, patch) {
-  const result = { ...target };
-  for (const [key, value] of Object.entries(patch)) {
-    if (value === null) {
-      delete result[key];
-    } else if (typeof value === "object" && !Array.isArray(value) && value !== null && typeof result[key] === "object" && !Array.isArray(result[key]) && result[key] !== null) {
-      result[key] = applyJsonMergePatch2(
-        result[key],
-        value
-      );
-    } else {
-      result[key] = value;
-    }
-  }
-  return result;
-}
-__name(applyJsonMergePatch2, "applyJsonMergePatch");
-async function handleUpdateOne(resource, params, requestId) {
-  const { data: patchData, options } = params;
-  const upsert = options?.upsert ?? false;
+
+// src/server/operations/operationDispatcher.ts
+init_shared();
+init_deleteMany();
+
+// src/server/operations/deleteOne.ts
+init_shared();
+var logger11 = createLogger({ service: "records-lambda" });
+async function handleDeleteOne(resource, params, requestId) {
+  const { handleDeleteMany: handleDeleteMany2 } = await Promise.resolve().then(() => (init_deleteMany(), deleteMany_exports));
   let targetId;
-  let existingItem;
   if ("id" in params) {
     targetId = params.id;
-    logger19.debug("Executing updateOne with id", {
+    logger11.debug("Executing deleteOne with id", {
       requestId,
       resource,
-      id: targetId,
-      upsert
+      id: targetId
     });
-    const dbClient2 = getDBClient();
-    const tableName = getTableName();
-    const mainSK = generateMainRecordSK2(targetId);
-    const getResult = await executeDynamoDBOperation(
-      () => dbClient2.send(
-        new import_lib_dynamodb13.GetCommand({
-          TableName: tableName,
-          Key: {
-            PK: resource,
-            SK: mainSK
-          },
-          ConsistentRead: true
-        })
-      ),
-      "GetItem"
+    const deleteManyResult = await handleDeleteMany2(
+      resource,
+      {
+        ids: [targetId]
+      },
+      requestId
     );
-    existingItem = getResult.Item;
+    if (deleteManyResult.count === 0) {
+      const error2 = Object.values(deleteManyResult.errors)[0];
+      if (error2) {
+        throw new Error(`Failed to delete record: ${error2.message}`);
+      } else {
+        throw new Error(`Failed to delete record: ${targetId}`);
+      }
+    }
+    return { id: targetId };
   } else {
-    logger19.debug("Executing updateOne with filter", {
+    logger11.debug("Executing deleteOne with filter", {
       requestId,
       resource,
-      filter: params.filter,
-      upsert
+      filter: params.filter
     });
-    const { handleFind: handleFind2 } = await Promise.resolve().then(() => (init_find(), find_exports));
-    const findResult = await handleFind2(
+    const deleteManyResult = await handleDeleteMany2(
       resource,
-      { filter: params.filter, pagination: { perPage: 1 } },
+      {
+        filter: params.filter
+      },
       requestId
     );
-    if (findResult.items.length > 0) {
-      const foundRecord = findResult.items[0];
-      targetId = foundRecord.id;
-      const dbClient2 = getDBClient();
-      const tableName = getTableName();
-      const mainSK = generateMainRecordSK2(targetId);
-      const getResult = await executeDynamoDBOperation(
-        () => dbClient2.send(
-          new import_lib_dynamodb13.GetCommand({
-            TableName: tableName,
-            Key: {
-              PK: resource,
-              SK: mainSK
-            },
-            ConsistentRead: true
-          })
-        ),
-        "GetItem"
-      );
-      existingItem = getResult.Item;
-    } else {
-      if (!upsert) {
-        throw new ItemNotFoundError(`Record not found with filter`, {
-          resource,
-          filter: params.filter
-        });
+    if (deleteManyResult.count === 0) {
+      const error2 = Object.values(deleteManyResult.errors)[0];
+      if (error2) {
+        throw new Error(`Failed to delete record: ${error2.message}`);
+      } else {
+        throw new Error(`No records found matching filter`);
       }
-      const { ulid: ulid3 } = await Promise.resolve().then(() => (init_shared(), shared_exports));
-      targetId = ulid3();
     }
-  }
-  if (!existingItem) {
-    if (!upsert) {
-      throw new ItemNotFoundError(`Record not found: ${targetId}`, { resource, id: targetId });
+    const deletedId = Object.values(deleteManyResult.successIds)[0];
+    if (!deletedId) {
+      throw new Error("Failed to get deleted record ID");
     }
-    return await handleUpsertCreate(resource, targetId, patchData, requestId);
+    logger11.info("deleteOne succeeded", {
+      requestId,
+      resource,
+      id: deletedId
+    });
+    return { id: deletedId };
   }
-  return await handleUpsertUpdate(resource, targetId, existingItem, patchData, requestId);
 }
-__name(handleUpdateOne, "handleUpdateOne");
-async function handleUpsertCreate(resource, id, data2, requestId) {
-  const $set = data2.$set || {};
-  const $setOnInsert = data2.$setOnInsert || {};
-  const mergedData = {
-    ...$setOnInsert,
-    ...$set
-  };
-  const recordData = addCreateTimestamps({ ...mergedData, id });
-  const shadowConfig = getShadowConfig();
-  const shadowRecords = generateShadowRecords(recordData, resource, shadowConfig);
-  const shadowKeys = shadowRecords.map((shadow) => shadow.SK);
-  const transactItems = [];
-  transactItems.push({
-    Put: {
-      TableName: getTableName(),
-      Item: {
-        PK: resource,
-        SK: generateMainRecordSK2(id),
-        data: {
-          ...recordData,
-          __shadowKeys: shadowKeys
-        }
-      }
-    }
+__name(handleDeleteOne, "handleDeleteOne");
+
+// src/server/operations/operationDispatcher.ts
+init_find();
+init_findMany();
+
+// src/server/operations/findManyReference.ts
+var import_lib_dynamodb7 = __toESM(require_dist_cjs66(), 1);
+init_shared();
+init_shadow();
+init_dynamodb3();
+init_pagination();
+init_validation2();
+var logger13 = createLogger({ service: "records-lambda" });
+async function handleFindManyReference(resource, params, requestId) {
+  const { target, id, filter, sort: sortParam, pagination } = params;
+  logger13.debug("Executing findManyReference", {
+    requestId,
+    resource,
+    target,
+    id
   });
-  for (const shadowRecord of shadowRecords) {
-    transactItems.push({
-      Put: {
-        TableName: getTableName(),
-        Item: shadowRecord
+  const shadowConfig = getShadowConfig();
+  const sort = normalizeSort(shadowConfig, resource, sortParam);
+  validateSortField(shadowConfig, resource, sort);
+  const { perPage, nextToken } = normalizePagination(pagination);
+  const dbClient2 = getDBClient();
+  const tableName = getTableName();
+  const skPrefix = `${sort.field}#`;
+  let exclusiveStartKey;
+  if (nextToken) {
+    const decoded = decodeNextToken(nextToken);
+    exclusiveStartKey = {
+      PK: decoded.PK,
+      SK: decoded.SK
+    };
+  }
+  const queryResult = await executeDynamoDBOperation(
+    () => dbClient2.send(
+      new import_lib_dynamodb7.QueryCommand({
+        TableName: tableName,
+        KeyConditionExpression: "PK = :pk AND begins_with(SK, :skPrefix)",
+        ExpressionAttributeValues: {
+          ":pk": resource,
+          ":skPrefix": skPrefix
+        },
+        ScanIndexForward: sort.order === "ASC",
+        Limit: perPage,
+        ExclusiveStartKey: exclusiveStartKey,
+        ConsistentRead: true
+      })
+    ),
+    "Query"
+  );
+  const shadowItems = queryResult.Items || [];
+  if (shadowItems.length === 0) {
+    return {
+      items: [],
+      pageInfo: {
+        hasNextPage: false,
+        hasPreviousPage: false
       }
-    });
+    };
   }
-  await executeDynamoDBOperation(
-    () => getDBClient().send(
-      new import_lib_dynamodb13.TransactWriteCommand({
-        TransactItems: transactItems
+  const recordIds = shadowItems.map((item) => {
+    const sk = item.SK;
+    const parts = sk.split("#id#");
+    return parts[parts.length - 1];
+  });
+  const batchGetResult = await executeDynamoDBOperation(
+    () => dbClient2.send(
+      new import_lib_dynamodb7.BatchGetCommand({
+        RequestItems: {
+          [tableName]: {
+            Keys: recordIds.map((recordId) => ({
+              PK: resource,
+              SK: `id#${recordId}`
+            })),
+            ConsistentRead: true
+          }
+        }
       })
     ),
-    "TransactWriteItems"
+    "BatchGetItem"
+  );
+  const mainRecords = batchGetResult.Responses?.[tableName] || [];
+  const recordMap = new Map(
+    mainRecords.map((item) => {
+      const data2 = item.data;
+      return [data2.id, extractCleanRecord(item)];
+    })
   );
-  logger19.info("updateOne upsert created", {
+  let items = recordIds.map((recordId) => recordMap.get(recordId)).filter((record) => record !== void 0);
+  items = items.filter((record) => record[target] === id);
+  if (filter && Object.keys(filter).length > 0) {
+    items = items.filter((record) => {
+      return Object.entries(filter).every(([key, value]) => {
+        return record[key] === value;
+      });
+    });
+  }
+  const hasNextPage = queryResult.LastEvaluatedKey !== void 0;
+  const nextTokenValue = hasNextPage && queryResult.LastEvaluatedKey ? encodeNextToken(
+    queryResult.LastEvaluatedKey.PK,
+    queryResult.LastEvaluatedKey.SK
+  ) : void 0;
+  logger13.info("findManyReference succeeded", {
     requestId,
     resource,
+    target,
     id,
-    shadowsCreated: shadowKeys.length
+    count: items.length,
+    hasNextPage
   });
   return {
-    ...removeShadowKeys(recordData),
-    __upsertedId: id
+    items,
+    pageInfo: {
+      hasNextPage,
+      hasPreviousPage: !!nextToken
+    },
+    ...nextTokenValue && { nextToken: nextTokenValue }
   };
 }
-__name(handleUpsertCreate, "handleUpsertCreate");
-async function handleUpsertUpdate(resource, id, existingItem, patchData, requestId) {
-  const existingData = existingItem.data;
-  const oldShadowKeys = existingData.__shadowKeys || [];
-  const actualPatchData = patchData.$set ? patchData.$set : patchData;
-  const mergedData = applyJsonMergePatch2(removeShadowKeys(existingData), actualPatchData);
-  const updatedData = addUpdateTimestamp({
-    ...mergedData,
-    id
-    // IDは変更不可
+__name(handleFindManyReference, "handleFindManyReference");
+
+// src/server/operations/operationDispatcher.ts
+init_findOne();
+init_insertMany();
+
+// src/server/operations/insertOne.ts
+init_shared();
+var logger17 = createLogger({ service: "records-lambda" });
+async function handleInsertOne(resource, params, requestId) {
+  logger17.debug("Executing insertOne", {
+    requestId,
+    resource
   });
-  const shadowConfig = getShadowConfig();
-  const newShadowRecords = generateShadowRecords(updatedData, resource, shadowConfig);
-  const newShadowKeys = newShadowRecords.map((shadow) => shadow.SK);
-  const shadowDiff = calculateShadowDiff(oldShadowKeys, newShadowKeys);
-  const transactItems = [];
-  transactItems.push({
-    Put: {
-      TableName: getTableName(),
-      Item: {
-        PK: resource,
-        SK: generateMainRecordSK2(id),
-        data: {
-          ...updatedData,
-          __shadowKeys: newShadowKeys
-        }
-      }
+  const { handleInsertMany: handleInsertMany2 } = await Promise.resolve().then(() => (init_insertMany(), insertMany_exports));
+  const insertManyResult = await handleInsertMany2(
+    resource,
+    {
+      data: [params.data]
+    },
+    requestId
+  );
+  if (insertManyResult.count === 0) {
+    const error2 = Object.values(insertManyResult.errors)[0];
+    if (error2) {
+      throw new Error(`Failed to create record: ${error2.message}`);
+    } else {
+      throw new Error("Failed to create record");
     }
-  });
-  for (const shadowSK of shadowDiff.toDelete) {
-    transactItems.push({
-      Delete: {
-        TableName: getTableName(),
-        Key: {
-          PK: resource,
-          SK: shadowSK
-        }
-      }
-    });
   }
-  for (const shadowRecord of newShadowRecords) {
-    if (shadowDiff.toAdd.includes(shadowRecord.SK)) {
-      transactItems.push({
-        Put: {
-          TableName: getTableName(),
-          Item: shadowRecord
-        }
-      });
-    }
+  const createdId = Object.values(insertManyResult.successIds)[0];
+  if (!createdId) {
+    throw new Error("Failed to get created record ID");
   }
-  await executeDynamoDBOperation(
-    () => getDBClient().send(
-      new import_lib_dynamodb13.TransactWriteCommand({
-        TransactItems: transactItems
-      })
-    ),
-    "TransactWriteItems"
-  );
-  logger19.info("updateOne upsert updated", {
+  const { handleFindOne: handleFindOne2 } = await Promise.resolve().then(() => (init_findOne(), findOne_exports));
+  const createdRecord = await handleFindOne2(resource, { id: createdId }, requestId);
+  logger17.info("insertOne succeeded", {
     requestId,
     resource,
-    id,
-    shadowDiffEmpty: isDiffEmpty(shadowDiff),
-    shadowsDeleted: shadowDiff.toDelete.length,
-    shadowsAdded: shadowDiff.toAdd.length
+    id: createdId
   });
-  return removeShadowKeys(updatedData);
+  return createdRecord;
+}
+__name(handleInsertOne, "handleInsertOne");
+
+// src/server/operations/operationDispatcher.ts
+init_updateMany();
+
+// src/server/operations/updateOne.ts
+init_shared();
+var logger19 = createLogger({ service: "records-lambda" });
+async function handleUpdateOne(resource, params, requestId) {
+  const { data: patchData, options } = params;
+  const { handleUpdateMany: handleUpdateMany2 } = await Promise.resolve().then(() => (init_updateMany(), updateMany_exports));
+  let targetId;
+  if ("id" in params) {
+    targetId = params.id;
+    logger19.debug("Executing updateOne with id", {
+      requestId,
+      resource,
+      id: targetId,
+      upsert: options?.upsert
+    });
+    const updateManyResult = await handleUpdateMany2(
+      resource,
+      {
+        ids: [targetId],
+        data: patchData
+      },
+      requestId
+    );
+    if (updateManyResult.count === 0) {
+      const error2 = Object.values(updateManyResult.errors)[0];
+      if (error2) {
+        throw new Error(`Failed to update record: ${error2.message}`);
+      } else {
+        throw new Error(`Failed to update record: ${targetId}`);
+      }
+    }
+    const { handleFindOne: handleFindOne2 } = await Promise.resolve().then(() => (init_findOne(), findOne_exports));
+    const updatedRecord = await handleFindOne2(resource, { id: targetId }, requestId);
+    return updatedRecord;
+  } else {
+    logger19.debug("Executing updateOne with filter", {
+      requestId,
+      resource,
+      filter: params.filter,
+      upsert: options?.upsert
+    });
+    const updateManyResult = await handleUpdateMany2(
+      resource,
+      {
+        filter: params.filter,
+        data: patchData
+      },
+      requestId
+    );
+    if (updateManyResult.count === 0) {
+      const error2 = Object.values(updateManyResult.errors)[0];
+      if (error2) {
+        throw new Error(`Failed to update record: ${error2.message}`);
+      } else {
+        throw new Error(`No records found matching filter`);
+      }
+    }
+    const updatedId = Object.values(updateManyResult.successIds)[0];
+    if (!updatedId) {
+      throw new Error("Failed to get updated record ID");
+    }
+    const { handleFindOne: handleFindOne2 } = await Promise.resolve().then(() => (init_findOne(), findOne_exports));
+    const updatedRecord = await handleFindOne2(resource, { id: updatedId }, requestId);
+    return updatedRecord;
+  }
 }
-__name(handleUpsertUpdate, "handleUpsertUpdate");
+__name(handleUpdateOne, "handleUpdateOne");
 
 // src/server/operations/parameterConverter.ts
 function convertFindParams(mongoParams) {
@@ -33219,17 +32308,26 @@ function convertFindParams(mongoParams) {
 }
 __name(convertFindParams, "convertFindParams");
 function convertFindOneParams(mongoParams) {
-  const id = typeof mongoParams.filter?.id === "string" ? mongoParams.filter.id : void 0;
-  if (!id) {
-    throw new Error("findOne requires filter.id");
+  if (!mongoParams.filter) {
+    throw new Error("findOne requires filter");
   }
-  return { id };
+  const id = typeof mongoParams.filter.id === "string" ? mongoParams.filter.id : void 0;
+  if (id) {
+    return { id };
+  }
+  return { filter: mongoParams.filter };
 }
 __name(convertFindOneParams, "convertFindOneParams");
 function convertFindManyParams(mongoParams) {
-  const idFilter = mongoParams.filter?.id;
-  const ids = typeof idFilter === "object" && idFilter !== null && "$in" in idFilter ? idFilter.$in || [] : [];
-  return { ids };
+  if (!mongoParams.filter) {
+    throw new Error("findMany requires filter");
+  }
+  const idFilter = mongoParams.filter.id;
+  if (typeof idFilter === "object" && idFilter !== null && "$in" in idFilter) {
+    const ids = idFilter.$in || [];
+    return { ids };
+  }
+  return { filter: mongoParams.filter };
 }
 __name(convertFindManyParams, "convertFindManyParams");
 function convertInsertOneParams(mongoParams) {
@@ -34807,7 +33905,7 @@ async function handler(event) {
       return createCorsResponse(HTTP_STATUS.OK);
     }
     if (event.requestContext.http.method === "GET" && event.requestContext.http.path === "/version") {
-      const version = "1.3.34";
+      const version = "1.3.36";
       return createSuccessResponse({ version, timestamp: (/* @__PURE__ */ new Date()).toISOString() }, requestId);
     }
     if (event.requestContext.http.method !== "POST") {