@exabugs/dynamodb-client 0.2.2 → 0.3.1

package/dist/server/handler.cjs

@@ -1,5 +1,5 @@
-// @exabugs/dynamodb-client v0.2.2
-// Built: 2025-12-01T05:04:46.205Z
+// @exabugs/dynamodb-client v0.3.1
+// Built: 2025-12-02T03:53:33.771Z
 "use strict";
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -27446,14 +27446,6 @@ var ConfigError = class extends AppError {
     super("CONFIG_ERROR" /* CONFIG_ERROR */, message, 500, details);
   }
 };
-var InvalidFilterError = class extends AppError {
-  static {
-    __name(this, "InvalidFilterError");
-  }
-  constructor(message, details) {
-    super("INVALID_FILTER" /* INVALID_FILTER */, message, 400, details);
-  }
-};
 var InvalidTokenError = class extends AppError {
   static {
     __name(this, "InvalidTokenError");
@@ -27668,22 +27660,86 @@ function ulid2() {
 }
 __name(ulid2, "ulid");
 
+// src/server/shadow/typeInference.ts
+function inferFieldType(value) {
+  if (value === null || value === void 0) {
+    return null;
+  }
+  if (typeof value === "string") {
+    if (/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/.test(value)) {
+      return "datetime";
+    }
+    return "string";
+  }
+  if (typeof value === "number") {
+    return "number";
+  }
+  if (typeof value === "boolean") {
+    return "boolean";
+  }
+  if (Array.isArray(value)) {
+    return "array";
+  }
+  if (typeof value === "object") {
+    return "object";
+  }
+  return null;
+}
+__name(inferFieldType, "inferFieldType");
+
 // src/server/shadow/generator.ts
+function normalizeJson(value) {
+  if (value === null || value === void 0)
+    return value;
+  if (Array.isArray(value))
+    return value.map((item) => normalizeJson(item));
+  if (typeof value === "object") {
+    const obj = value;
+    const sorted = {};
+    if ("id" in obj)
+      sorted.id = normalizeJson(obj.id);
+    const otherKeys = Object.keys(obj).filter((key) => key !== "id" && key !== "createdAt" && key !== "updatedAt").sort();
+    for (const key of otherKeys) {
+      sorted[key] = normalizeJson(obj[key]);
+    }
+    if ("createdAt" in obj)
+      sorted.createdAt = normalizeJson(obj.createdAt);
+    if ("updatedAt" in obj)
+      sorted.updatedAt = normalizeJson(obj.updatedAt);
+    return sorted;
+  }
+  return value;
+}
+__name(normalizeJson, "normalizeJson");
+function truncateString(value, maxBytes) {
+  const encoder = new TextEncoder();
+  const bytes = encoder.encode(value);
+  if (bytes.length <= maxBytes) {
+    return value;
+  }
+  const decoder = new TextDecoder("utf-8", { fatal: false });
+  let truncated = decoder.decode(bytes.slice(0, maxBytes));
+  truncated = truncated.replace(/[\uFFFD]$/, "");
+  return truncated;
+}
+__name(truncateString, "truncateString");
 function escapeString(value) {
   return value.replace(/#/g, "##").replace(/ /g, "#");
 }
 __name(escapeString, "escapeString");
-function formatNumber(value) {
-  if (value === null || value === void 0) {
-    return "";
-  }
+function formatNumberWithOffset(value, padding) {
   if (!Number.isFinite(value)) {
     throw new Error(`Invalid number value: ${value}`);
   }
-  const normalized = Math.max(0, Math.floor(value));
-  return normalized.toString().padStart(20, "0");
+  const maxValue = Math.pow(10, padding);
+  if (value < -maxValue || value >= maxValue) {
+    throw new Error(`Number ${value} is out of range (-10^${padding} to 10^${padding})`);
+  }
+  const offset = maxValue;
+  const adjusted = Math.floor(value) + offset;
+  return adjusted.toString().padStart(padding + 1, "0");
 }
-__name(formatNumber, "formatNumber");
+__name(formatNumberWithOffset, "formatNumberWithOffset");
 function formatDatetime(value) {
   if (value === null || value === void 0) {
     return "";
@@ -27702,19 +27758,30 @@ function formatBoolean(value) {
   return value ? "1" : "0";
 }
 __name(formatBoolean, "formatBoolean");
-function formatFieldValue(type, value) {
+function formatFieldValue(type, value, config) {
   switch (type) {
-    case "string":
+    case "string": {
       if (value === null || value === void 0) {
         return "";
       }
-      return escapeString(String(value));
+      const str = String(value);
+      const truncated = truncateString(str, config.stringMaxBytes);
+      return escapeString(truncated);
+    }
     case "number":
-      return formatNumber(value);
+      return formatNumberWithOffset(value, config.numberPadding);
     case "datetime":
       return formatDatetime(value);
     case "boolean":
       return formatBoolean(value);
+    case "array":
+    case "object": {
+      const normalized = normalizeJson(value);
+      const jsonStr = JSON.stringify(normalized);
+      const maxBytes = config.stringMaxBytes * 2;
+      const truncated = truncateString(jsonStr, maxBytes);
+      return escapeString(truncated);
+    }
     default:
       throw new Error(`Unknown shadow field type: ${type}`);
   }
@@ -27724,14 +27791,23 @@ function generateMainRecordSK(recordId) {
   return `id#${recordId}`;
 }
 __name(generateMainRecordSK, "generateMainRecordSK");
-function generateShadowRecords(record, schema) {
+function generateShadowRecords(record, resourceName, config) {
   const shadows = [];
-  for (const [fieldName, fieldDef] of Object.entries(schema.sortableFields)) {
-    const value = record[fieldName];
-    const normalizedValue = formatFieldValue(fieldDef.type, value);
-    const sk = `${fieldName}#${normalizedValue}#id#${record.id}`;
+  for (const [fieldName, value] of Object.entries(record)) {
+    if (fieldName.startsWith("__")) {
+      continue;
+    }
+    if (value === null || value === void 0) {
+      continue;
+    }
+    const type = inferFieldType(value);
+    if (!type) {
+      continue;
+    }
+    const formattedValue = formatFieldValue(type, value, config);
+    const sk = `${fieldName}#${formattedValue}#id#${record.id}`;
     shadows.push({
-      PK: schema.resource,
+      PK: resourceName,
       SK: sk,
       data: { id: record.id }
     });
@@ -27761,81 +27837,22 @@ __name(isDiffEmpty, "isDiffEmpty");
 var cachedShadowConfig = null;
 function getShadowConfig() {
   if (!cachedShadowConfig) {
-    const configBase64 = process.env.SHADOW_CONFIG;
-    if (!configBase64) {
-      throw new Error("SHADOW_CONFIG environment variable is not set");
+    cachedShadowConfig = {
+      createdAtField: process.env.SHADOW_CREATED_AT_FIELD || "createdAt",
+      updatedAtField: process.env.SHADOW_UPDATED_AT_FIELD || "updatedAt",
+      stringMaxBytes: parseInt(process.env.SHADOW_STRING_MAX_BYTES || "100", 10),
+      numberPadding: parseInt(process.env.SHADOW_NUMBER_PADDING || "15", 10)
+    };
+    if (cachedShadowConfig.stringMaxBytes <= 0) {
+      throw new Error("SHADOW_STRING_MAX_BYTES must be positive");
     }
-    try {
-      const configJson = Buffer.from(configBase64, "base64").toString("utf-8");
-      cachedShadowConfig = JSON.parse(configJson);
-      if (!cachedShadowConfig.$schemaVersion) {
-        throw new Error("Missing $schemaVersion in shadow config");
-      }
-      if (!cachedShadowConfig.resources || typeof cachedShadowConfig.resources !== "object") {
-        throw new Error("Missing or invalid resources in shadow config");
-      }
-    } catch (error2) {
-      if (error2 instanceof SyntaxError) {
-        throw new Error(`Invalid JSON in SHADOW_CONFIG environment variable: ${error2.message}`);
-      }
-      throw error2;
+    if (cachedShadowConfig.numberPadding <= 0 || cachedShadowConfig.numberPadding > 15) {
+      throw new Error("SHADOW_NUMBER_PADDING must be between 1 and 15");
     }
   }
   return cachedShadowConfig;
 }
 __name(getShadowConfig, "getShadowConfig");
-function getResourceSchema(config, resourceName) {
-  const resourceConfig = config.resources[resourceName];
-  if (!resourceConfig) {
-    throw new Error(`Resource '${resourceName}' not found in shadow config`);
-  }
-  return {
-    resource: resourceName,
-    sortableFields: resourceConfig.shadows
-  };
-}
-__name(getResourceSchema, "getResourceSchema");
-function getShadowConfigHash() {
-  getShadowConfig();
-  const configBase64 = process.env.SHADOW_CONFIG;
-  if (!configBase64) {
-    throw new Error("SHADOW_CONFIG environment variable is not set");
-  }
-  const crypto3 = require("crypto");
-  const hash = crypto3.createHash("sha256").update(configBase64).digest("hex");
-  return hash;
-}
-__name(getShadowConfigHash, "getShadowConfigHash");
-function getSchemaVersion() {
-  const config = getShadowConfig();
-  return config.$schemaVersion;
-}
-__name(getSchemaVersion, "getSchemaVersion");
-function getAllShadowFields(config, resourceName) {
-  const resourceConfig = config.resources[resourceName];
-  if (!resourceConfig) {
-    throw new Error(`Resource '${resourceName}' not found in shadow config`);
-  }
-  return resourceConfig.shadows;
-}
-__name(getAllShadowFields, "getAllShadowFields");
-function isValidShadowField(config, resourceName, fieldName) {
-  try {
-    const allFields = getAllShadowFields(config, resourceName);
-    return fieldName in allFields;
-  } catch {
-    return false;
-  }
-}
-__name(isValidShadowField, "isValidShadowField");
-function getDefaultSort(config, resourceName) {
-  const resourceConfig = config.resources[resourceName];
-  if (!resourceConfig) {
-    throw new Error(`Resource '${resourceName}' not found in shadow config`);
-  }
-  return resourceConfig.sortDefaults;
-}
-__name(getDefaultSort, "getDefaultSort");
 
 // src/server/utils/bulkOperations.ts
 var logger2 = createLogger({ service: "records-lambda" });
@@ -28513,17 +28530,8 @@ function decodeNextToken(token) {
 __name(decodeNextToken, "decodeNextToken");
 
 // src/server/utils/validation.ts
-function validateSortField(config, resource, sort) {
-  if (!sort) {
-    return;
-  }
-  const { field } = sort;
-  if (field === "id") {
-    return;
-  }
-  if (!isValidShadowField(config, resource, field)) {
-    throw new InvalidFilterError(`Invalid sort field: ${field}`, { field, resource });
-  }
+function validateSortField(_config, _resource, _sort) {
+  return;
 }
 __name(validateSortField, "validateSortField");
 function normalizePagination(pagination) {
@@ -28532,11 +28540,14 @@ function normalizePagination(pagination) {
   return { perPage, nextToken };
 }
 __name(normalizePagination, "normalizePagination");
-function normalizeSort(config, resource, sort) {
+function normalizeSort(config, _resource, sort) {
   if (sort) {
     return sort;
   }
-  return getDefaultSort(config, resource);
+  return {
+    field: config.updatedAtField,
+    order: "DESC"
+  };
 }
 __name(normalizeSort, "normalizeSort");
 
@@ -28552,8 +28563,8 @@ async function handleFind(resource, params, requestId) {
   logger7.debug("Shadow config loaded", {
     requestId,
     resource,
-    hasResources: !!shadowConfig.resources,
-    resourceNames: Object.keys(shadowConfig.resources || {})
+    createdAtField: shadowConfig.createdAtField,
+    updatedAtField: shadowConfig.updatedAtField
   });
   logger7.debug("Normalizing sort", {
     requestId,
@@ -28683,14 +28694,6 @@ async function handleFind(resource, params, requestId) {
       ...nextTokenValue2 && { nextToken: nextTokenValue2 }
     };
   }
-  const shadowSchema = getResourceSchema(shadowConfig, resource);
-  const sortFieldType = shadowSchema.sortableFields[sort.field]?.type;
-  if (!sortFieldType) {
-    throw new ConfigError(`Sort field type not found: ${sort.field}`, {
-      field: sort.field,
-      resource
-    });
-  }
   const optimizableFilter = findOptimizableFilter(sort.field, parsedFilters);
   const skPrefix = `${sort.field}#`;
   let exclusiveStartKey;
@@ -28916,14 +28919,6 @@ async function handleFindManyReference(resource, params, requestId) {
   const { perPage, nextToken } = normalizePagination(pagination);
   const dbClient2 = getDBClient();
   const tableName = getTableName();
-  const shadowSchema = getResourceSchema(shadowConfig, resource);
-  const sortFieldType = shadowSchema.sortableFields[sort.field]?.type;
-  if (!sortFieldType) {
-    throw new ConfigError(`Sort field type not found: ${sort.field}`, {
-      field: sort.field,
-      resource
-    });
-  }
   const skPrefix = `${sort.field}#`;
   let exclusiveStartKey;
   if (nextToken) {
@@ -29066,28 +29061,9 @@ var import_lib_dynamodb8 = __toESM(require_dist_cjs58(), 1);
 // src/server/utils/timestamps.ts
 function getTimestampFields() {
   const shadowConfig = getShadowConfig();
-  if (!shadowConfig.database) {
-    return {
-      createdAt: "createdAt",
-      updatedAt: "updatedAt"
-    };
-  }
-  const { timestamps } = shadowConfig.database;
-  if (!timestamps) {
-    return {
-      createdAt: "createdAt",
-      updatedAt: "updatedAt"
-    };
-  }
-  if (typeof timestamps === "object") {
-    return {
-      createdAt: timestamps.createdAt,
-      updatedAt: timestamps.updatedAt
-    };
-  }
   return {
-    createdAt: "createdAt",
-    updatedAt: "updatedAt"
+    createdAt: shadowConfig.createdAtField,
+    updatedAt: shadowConfig.updatedAtField
   };
 }
 __name(getTimestampFields, "getTimestampFields");
@@ -29120,14 +29096,16 @@ __name(addUpdateTimestamp, "addUpdateTimestamp");
 // src/server/utils/ttl.ts
 var logger11 = createLogger({ service: "records-lambda" });
 function calculateTTL(resource, createdAt) {
-  const shadowConfig = getShadowConfig();
-  const resourceConfig = shadowConfig.resources[resource];
-  if (!resourceConfig?.ttl) {
+  const envKey = `${resource.toUpperCase()}_TTL_DAYS`;
+  const ttlDaysStr = process.env[envKey];
+  if (!ttlDaysStr) {
+    return void 0;
+  }
+  const ttlDays = parseInt(ttlDaysStr, 10);
+  if (isNaN(ttlDays) || ttlDays <= 0) {
+    logger11.warn("Invalid TTL_DAYS value", { resource, envKey, value: ttlDaysStr });
     return void 0;
   }
-  const defaultDays = resourceConfig.ttl.days;
-  const envKey = `${resource.toUpperCase()}_TTL_DAYS`;
-  const ttlDays = parseInt(process.env[envKey] || String(defaultDays), 10);
   const createdAtMs = new Date(createdAt).getTime();
   const ttlMs = createdAtMs + ttlDays * 24 * 60 * 60 * 1e3;
   const ttl = Math.floor(ttlMs / 1e3);
@@ -29180,7 +29158,6 @@ async function handleInsertMany(resource, params, requestId) {
   const dbClient2 = getDBClient();
   const tableName = getTableName();
   const shadowConfig = getShadowConfig();
-  const shadowSchema = getResourceSchema(shadowConfig, resource);
   const preparedRecords = [];
   const preparationFailedIds = [];
   const preparationErrors = [];
@@ -29193,9 +29170,7 @@ async function handleInsertMany(resource, params, requestId) {
         id
       });
       fullRecordData = addTTL(resource, fullRecordData);
-      fullRecordData.__configVersion = getSchemaVersion();
-      fullRecordData.__configHash = getShadowConfigHash();
-      const shadowRecords = generateShadowRecords(fullRecordData, shadowSchema);
+      const shadowRecords = generateShadowRecords(fullRecordData, resource, shadowConfig);
       const shadowKeys = shadowRecords.map((shadow) => shadow.SK);
       const mainSK = generateMainRecordSK(id);
       preparedRecords.push({
@@ -29383,11 +29358,8 @@ async function handleInsertOne(resource, params, requestId) {
     id
   });
   recordData = addTTL(resource, recordData);
-  recordData.__configVersion = getSchemaVersion();
-  recordData.__configHash = getShadowConfigHash();
   const shadowConfig = getShadowConfig();
-  const shadowSchema = getResourceSchema(shadowConfig, resource);
-  const shadowRecords = generateShadowRecords(recordData, shadowSchema);
+  const shadowRecords = generateShadowRecords(recordData, resource, shadowConfig);
   const shadowKeys = shadowRecords.map((shadow) => shadow.SK);
   const mainSK = generateMainRecordSK(id);
   await executeDynamoDBOperation(
@@ -29492,7 +29464,6 @@ async function handleUpdateMany(resource, params, requestId) {
   );
   const notFoundIds = ids.filter((id) => !existingIds.has(id));
   const shadowConfig = getShadowConfig();
-  const shadowSchema = getResourceSchema(shadowConfig, resource);
   const preparedRecords = [];
   const preparationFailedIds = [];
   const preparationErrors = [];
@@ -29506,7 +29477,7 @@ async function handleUpdateMany(resource, params, requestId) {
         ...mergedData,
         id
       });
-      const newShadowRecords = generateShadowRecords(updatedData, shadowSchema);
+      const newShadowRecords = generateShadowRecords(updatedData, resource, shadowConfig);
       const newShadowKeys = newShadowRecords.map((shadow) => shadow.SK);
       const mainSK = generateMainRecordSK(id);
       preparedRecords.push({
@@ -29759,8 +29730,7 @@ async function handleUpdateOne(resource, params, requestId) {
     // IDは変更不可
   });
   const shadowConfig = getShadowConfig();
-  const shadowSchema = getResourceSchema(shadowConfig, resource);
-  const newShadowRecords = generateShadowRecords(updatedData, shadowSchema);
+  const newShadowRecords = generateShadowRecords(updatedData, resource, shadowConfig);
   const newShadowKeys = newShadowRecords.map((shadow) => shadow.SK);
   const shadowDiff = calculateShadowDiff(oldShadowKeys, newShadowKeys);
   const transactItems = [];
@@ -31056,18 +31026,7 @@ var logger17 = createLogger({
   service: "records-lambda",
   level: process.env.LOG_LEVEL || "info"
 });
-try {
-  const schemaVersion = getSchemaVersion();
-  const configHash = getShadowConfigHash();
-  logger17.info("Records Lambda started", {
-    schemaVersion,
-    configHash
-  });
-} catch (error2) {
-  logger17.warn("Failed to load shadow config at startup", {
-    error: error2 instanceof Error ? error2.message : String(error2)
-  });
-}
+logger17.info("Records Lambda started with automatic shadow field detection");
 var CORS_HEADERS = {};
 async function handler(event) {
   const requestId = event.requestContext.requestId;