@rex0220/kintone-sql-tools 3.8.0 → 3.9.0

package/dist-cli/ksql.js

@@ -7904,26 +7904,55 @@ var VALIDATION_META_COLUMNS = [
   "$err_row",
   "$err_field",
   "$err_code",
-  "$err_message"
+  "$err_message",
+  "$err_value",
+  "$err_subtable",
+  "$err_subrow",
+  "$err_subrow_id"
 ];
-function validateDmlCandidates(candidates, operation, payloadFields, targetFields, fieldInfos, statementNumber, numberPrecision, checkGroups = [], validateMissingCreateFields = true, includePreErrors = true) {
+function materializeDmlUpdateModeSparseRecords(candidates, targetFields, fieldInfos) {
+  const infoByCode = new Map(fieldInfos.map((field) => [field.code, field]));
+  for (const candidate of candidates) {
+    if (candidate.mode !== "update") continue;
+    candidate.record ??= {};
+    for (const code of targetFields) {
+      if (!candidate.payload.has(code)) continue;
+      const original = candidate.payload.get(code);
+      const type = infoByCode.get(code).fieldType;
+      const preserveCodes = ["USER_SELECT", "ORGANIZATION_SELECT", "GROUP_SELECT"].includes(type) && Array.isArray(original) && original.every((item) => typeof item === "object" && item !== null && "code" in item);
+      let normalized = original;
+      try {
+        normalized = normalizeRaw(original, type);
+      } catch {
+      }
+      candidate.record[code] = { value: preserveCodes ? original : normalized };
+    }
+  }
+}
+function validateDmlCandidates(candidates, operation, payloadFields, targetFields, fieldInfos, statementNumber, numberPrecision, checkGroups = [], validateMissingCreateFields = true, includePreErrors = true, validationOptions = {}) {
   const infoByCode = new Map(fieldInfos.map((field) => [field.code, field]));
   const errors = [];
   const invalid = /* @__PURE__ */ new Set();
+  const candidateResults = [];
+  if (validationOptions.validateUpdateBuiltIns === false) {
+    materializeDmlUpdateModeSparseRecords(candidates, targetFields, fieldInfos);
+  }
   let firstEvaluationError;
   for (const candidate of candidates) {
     candidate.record ??= {};
-    const rowErrors = includePreErrors ? [...candidate.preErrors] : [];
+    const preErrors = includePreErrors ? [...candidate.preErrors] : [];
+    const builtInErrors = [];
+    const checkErrors = [];
+    const validateBuiltIns = candidate.mode === "create" || validationOptions.validateUpdateBuiltIns !== false;
     for (const code of targetFields) {
       if (!candidate.payload.has(code)) continue;
-      const result = validateAndNormalizeDmlValue(candidate.payload.get(code), infoByCode.get(code), numberPrecision);
-      if (!result.ok) rowErrors.push({ field: code, code: result.code, message: result.message });
-      else {
-        const original = candidate.payload.get(code);
-        const type = infoByCode.get(code).fieldType;
-        const preserveCodes = ["USER_SELECT", "ORGANIZATION_SELECT", "GROUP_SELECT"].includes(type) && Array.isArray(original) && original.every((item) => typeof item === "object" && item !== null && "code" in item);
-        candidate.record[code] = { value: preserveCodes ? original : result.value };
-      }
+      const original = candidate.payload.get(code);
+      const type = infoByCode.get(code).fieldType;
+      const preserveCodes = ["USER_SELECT", "ORGANIZATION_SELECT", "GROUP_SELECT"].includes(type) && Array.isArray(original) && original.every((item) => typeof item === "object" && item !== null && "code" in item);
+      if (!validateBuiltIns) continue;
+      const result = validateAndNormalizeDmlValue(original, infoByCode.get(code), numberPrecision);
+      if (!result.ok) builtInErrors.push({ field: code, code: result.code, message: result.message });
+      else candidate.record[code] = { value: preserveCodes ? original : result.value };
     }
     if (validateMissingCreateFields && candidate.mode === "create") {
       for (const info of fieldInfos) {
@@ -7932,7 +7961,7 @@ function validateDmlCandidates(candidates, operation, payloadFields, targetField
         const emptyDefault = isEmptyDmlValue(info.defaultValue);
         if (!emptyDefault) {
           const defaultResult = validateAndNormalizeDmlValue(info.defaultValue, info, numberPrecision);
-          if (!defaultResult.ok) rowErrors.push({
+          if (!defaultResult.ok) builtInErrors.push({
             field: info.code,
             code: defaultResult.code,
             message: `\u65E2\u5B9A\u5024: ${defaultResult.message}`
@@ -7940,9 +7969,9 @@ function validateDmlCandidates(candidates, operation, payloadFields, targetField
         } else {
           const emptyResult = validateAndNormalizeDmlValue("", info, numberPrecision);
           if (!emptyResult.ok) {
-            rowErrors.push({ field: info.code, code: emptyResult.code, message: emptyResult.message });
+            builtInErrors.push({ field: info.code, code: emptyResult.code, message: emptyResult.message });
           } else if (info.required) {
-            rowErrors.push({ field: info.code, code: "ERR_REQUIRED", message: `${info.code} \u306F\u5FC5\u9808\u3067\u3059` });
+            builtInErrors.push({ field: info.code, code: "ERR_REQUIRED", message: `${info.code} \u306F\u5FC5\u9808\u3067\u3059` });
           }
         }
       }
@@ -7958,14 +7987,13 @@ function validateDmlCandidates(candidates, operation, payloadFields, targetField
       };
       try {
         for (const custom of evaluateCustomChecks(checkGroups, row, resolveType)) {
-          rowErrors.push({ field: "", code: "ERR_CHECK", message: custom.message });
+          checkErrors.push({ field: "", code: "ERR_CHECK", message: custom.message });
         }
       } catch (error) {
         firstEvaluationError ??= error;
       }
     }
-    if (rowErrors.length > 0) invalid.add(candidate.rowNumber);
-    for (const error of rowErrors) {
+    const materializeErrors = (source) => source.map((error) => {
       const row = {};
       for (const field of payloadFields) row[field] = renderValidationValue(candidate.payload.get(field));
       row["$err_statement"] = String(statementNumber);
@@ -7974,11 +8002,25 @@ function validateDmlCandidates(candidates, operation, payloadFields, targetField
       row["$err_field"] = error.field;
       row["$err_code"] = error.code;
       row["$err_message"] = error.message;
-      errors.push(row);
-    }
+      row["$err_value"] = "";
+      row["$err_subtable"] = "";
+      row["$err_subrow"] = "";
+      row["$err_subrow_id"] = "";
+      return row;
+    });
+    const materialized = {
+      rowNumber: candidate.rowNumber,
+      preErrors: materializeErrors(preErrors),
+      builtInErrors: materializeErrors(builtInErrors),
+      checkErrors: materializeErrors(checkErrors)
+    };
+    candidateResults.push(materialized);
+    const rowErrors = [...materialized.preErrors, ...materialized.builtInErrors, ...materialized.checkErrors];
+    if (rowErrors.length > 0) invalid.add(candidate.rowNumber);
+    errors.push(...rowErrors);
   }
   if (firstEvaluationError !== void 0) throw firstEvaluationError;
-  return { errors, invalidRows: invalid.size, invalidRowNumbers: invalid };
+  return { errors, invalidRows: invalid.size, invalidRowNumbers: invalid, candidateResults };
 }
 function renderValidationValue(value) {
   if (value == null) return "";
@@ -8085,13 +8127,7 @@ var NON_AUDIT_SYSTEM_TYPES = /* @__PURE__ */ new Set([
   "CATEGORY",
   "REFERENCE_TABLE"
 ]);
-var POST_IMAGE_VALIDATION_SUFFIX_COLUMNS = [
-  ...VALIDATION_META_COLUMNS,
-  "$err_value",
-  "$err_subtable",
-  "$err_subrow",
-  "$err_subrow_id"
-];
+var POST_IMAGE_VALIDATION_SUFFIX_COLUMNS = VALIDATION_META_COLUMNS;
 function buildPostImageFieldIndex(fieldInfos, payloadFields = ["$id"]) {
   const metadata = buildValidationFieldMetadataIndex(fieldInfos);
   const topLevel = metadata.topLevel.filter((field) => field.fieldType !== "SUBTABLE" && field.fieldType !== "FILE" && !NON_AUDIT_SYSTEM_TYPES.has(field.fieldType));
@@ -10299,6 +10335,71 @@ function toFlatString(value) {
   }
 }
 
+// src/core/dmlPrevalidation.ts
+function collectDmlPrevalidationSnapshotFields(fieldIndex) {
+  return [
+    "$id",
+    .../* @__PURE__ */ new Set([
+      ...fieldIndex.topLevel.map((field) => field.code).filter((code) => code !== "$id" && code !== "$revision"),
+      ...fieldIndex.subtables.keys()
+    ])
+  ];
+}
+function buildDmlValidationPostImage(snapshot, sparseRecord) {
+  const postImage = deepClone(snapshot);
+  for (const [field, cell] of Object.entries(sparseRecord)) {
+    postImage[field] = deepClone(cell);
+  }
+  return postImage;
+}
+function mergeDmlCandidateValidation(input) {
+  const errors = [
+    ...input.preErrors.map((row) => normalizePlainError(row)),
+    ...input.postImageErrors.map((row) => normalizePlainError(row, row["$err_subtable"] !== "")),
+    ...input.checkErrors.map((row) => normalizePlainError(row))
+  ];
+  const invalidRowNumbers = /* @__PURE__ */ new Set();
+  if (errors.length > 0) invalidRowNumbers.add(input.rowNumber);
+  const writeRecord = {};
+  for (const field of new Set(input.setFields)) {
+    if (!Object.prototype.hasOwnProperty.call(input.normalizedPostImage, field)) {
+      throw new Error(`InternalError: normalized post-image is missing SET field: ${field}`);
+    }
+    writeRecord[field] = deepClone(input.normalizedPostImage[field]);
+  }
+  return {
+    errors,
+    invalidRows: invalidRowNumbers.size,
+    invalidRowNumbers,
+    writeRecord
+  };
+}
+function normalizePlainError(row, childCell = false) {
+  return {
+    ...row,
+    $err_value: childCell ? row["$err_value"] ?? "" : "",
+    $err_subtable: childCell ? row["$err_subtable"] ?? "" : "",
+    $err_subrow: childCell ? row["$err_subrow"] ?? "" : "",
+    $err_subrow_id: childCell ? row["$err_subrow_id"] ?? "" : ""
+  };
+}
+function deepClone(value, seen = /* @__PURE__ */ new Map()) {
+  if (value === null || typeof value !== "object") return value;
+  const object = value;
+  const existing = seen.get(object);
+  if (existing !== void 0) return existing;
+  if (Array.isArray(value)) {
+    const clone2 = [];
+    seen.set(object, clone2);
+    for (const item of value) clone2.push(deepClone(item, seen));
+    return clone2;
+  }
+  const clone = {};
+  seen.set(object, clone);
+  for (const [key, child] of Object.entries(value)) clone[key] = deepClone(child, seen);
+  return clone;
+}
+
 // src/core/optimization/whereCapability.ts
 var RANGE_AND_EQUALITY = ["=", "!=", ">", "<", ">=", "<="];
 var EQUALITY_IN = ["=", "!=", "in", "not in"];
@@ -14501,15 +14602,72 @@ async function prepareDmlValidation(stmt, client, options, cacheContext, tempTab
     await assertDmlWhereCapability(stmt, client, cacheContext);
   }
   const infoByCode = new Map(fieldInfos.map((field) => [field.code, field]));
-  const numberPrecision = await loadNumberPrecisionForTargets(
+  let numberPrecision = await loadNumberPrecisionForTargets(
     stmt.appId,
     targetFields,
     fieldInfos,
     client,
     cacheContext
   );
-  const candidates = await materializeValidationCandidates(stmt, operation, client, options, cacheContext, tempTables, infoByCode);
-  const { errors, invalidRows, invalidRowNumbers } = validateDmlCandidates(
+  const fieldIndex = buildPostImageFieldIndex(fieldInfos, payloadFields);
+  const snapshotFields = collectDmlPrevalidationSnapshotFields(fieldIndex);
+  const candidates = (await materializeValidationCandidates(
+    stmt,
+    operation,
+    client,
+    options,
+    cacheContext,
+    tempTables,
+    infoByCode,
+    stmt.type === "UPDATE" ? snapshotFields : void 0
+  )).sort((left, right) => left.rowNumber - right.rowNumber);
+  const updateCandidates = candidates.filter((candidate) => candidate.mode === "update");
+  const productionUpdateLoader = stmt.type === "UPDATE" ? loadMaterializedUpdateSnapshots : stmt.type.startsWith("UPSERT") ? (input) => loadUpsertValidationSnapshots(
+    input,
+    client,
+    options.maxRecords ?? 1e4
+  ) : void 0;
+  const updateSnapshotLoader = options.loadUpdateModeSnapshots ?? productionUpdateLoader;
+  const usePreparedPostImages = updateCandidates.length > 0 && updateSnapshotLoader !== void 0;
+  const preparedPostImages = /* @__PURE__ */ new Map();
+  if (usePreparedPostImages) {
+    materializeDmlUpdateModeSparseRecords(updateCandidates, targetFields, fieldInfos);
+    const snapshots = await updateSnapshotLoader({
+      appId: stmt.appId,
+      candidates: updateCandidates,
+      fields: snapshotFields
+    });
+    const postImages = /* @__PURE__ */ new Map();
+    for (const candidate of updateCandidates) {
+      if (candidate.targetId === void 0) {
+        throw new Error(`InternalError: update-mode validation candidate has no targetId (row=${candidate.rowNumber}).`);
+      }
+      const snapshot = snapshots.get(candidate.targetId);
+      if (!snapshot) {
+        throw new Error(`InternalError: update-mode snapshot is missing for record ${candidate.targetId}.`);
+      }
+      const postImage = buildDmlValidationPostImage(snapshot, candidate.record ?? {});
+      postImages.set(candidate.rowNumber, postImage);
+    }
+    if (numberPrecision === void 0 && [...postImages.values()].some(
+      (record) => postImageNeedsNumberPrecision(record, fieldIndex)
+    )) {
+      numberPrecision = await getNumberPrecisionCached(stmt.appId, client, cacheContext);
+    }
+    for (const candidate of updateCandidates) {
+      const postImage = postImages.get(candidate.rowNumber);
+      if (!postImage) throw new Error(`InternalError: validation post-image is missing for row ${candidate.rowNumber}.`);
+      preparedPostImages.set(candidate.rowNumber, validatePostImage(
+        postImage,
+        fieldIndex,
+        numberPrecision,
+        statementNumber,
+        candidate.rowNumber,
+        operation
+      ));
+    }
+  }
+  const candidateValidation = validateDmlCandidates(
     candidates,
     operation,
     payloadFields,
@@ -14519,8 +14677,41 @@ async function prepareDmlValidation(stmt, client, options, cacheContext, tempTab
     numberPrecision,
     stmt.checkGroups ?? [],
     validateMissingCreateFields,
-    includePreErrors
+    includePreErrors,
+    { validateUpdateBuiltIns: !usePreparedPostImages }
   );
+  let { errors, invalidRows, invalidRowNumbers } = candidateValidation;
+  if (usePreparedPostImages) {
+    const detailsByRow = new Map(candidateValidation.candidateResults.map((detail) => [detail.rowNumber, detail]));
+    errors = [];
+    invalidRowNumbers = /* @__PURE__ */ new Set();
+    for (const candidate of candidates) {
+      const detail = detailsByRow.get(candidate.rowNumber);
+      if (!detail) throw new Error(`InternalError: validation detail is missing for row ${candidate.rowNumber}.`);
+      if (candidate.mode === "create") {
+        const candidateErrors = [...detail.preErrors, ...detail.builtInErrors, ...detail.checkErrors];
+        errors.push(...candidateErrors);
+        if (candidateErrors.length > 0) invalidRowNumbers.add(candidate.rowNumber);
+        continue;
+      }
+      const postImageValidation = preparedPostImages.get(candidate.rowNumber);
+      if (!postImageValidation) {
+        throw new Error(`InternalError: prepared post-image validation is missing for row ${candidate.rowNumber}.`);
+      }
+      const merged = mergeDmlCandidateValidation({
+        rowNumber: candidate.rowNumber,
+        setFields: targetFields,
+        normalizedPostImage: postImageValidation.normalizedRecord,
+        preErrors: detail.preErrors,
+        postImageErrors: postImageValidation.errors,
+        checkErrors: detail.checkErrors
+      });
+      candidate.record = merged.writeRecord;
+      errors.push(...merged.errors);
+      for (const rowNumber of merged.invalidRowNumbers) invalidRowNumbers.add(rowNumber);
+    }
+    invalidRows = invalidRowNumbers.size;
+  }
   const columns = [...payloadFields, ...VALIDATION_META_COLUMNS];
   const result = {
     type: "VALIDATION",
@@ -14546,12 +14737,10 @@ async function prepareDmlValidation(stmt, client, options, cacheContext, tempTab
     const info = infoByCode.get(column);
     if (info) columnMeta.set(column, materializedMetaFromFieldInfo(info, stmt.appId));
   }
-  columnMeta.set("$err_statement", syntheticColumnMeta("number"));
-  columnMeta.set("$err_operation", syntheticColumnMeta("string"));
-  columnMeta.set("$err_row", syntheticColumnMeta("number"));
-  columnMeta.set("$err_field", syntheticColumnMeta("string"));
-  columnMeta.set("$err_code", syntheticColumnMeta("string"));
-  columnMeta.set("$err_message", syntheticColumnMeta("string"));
+  const numericValidationMeta = /* @__PURE__ */ new Set(["$err_statement", "$err_row"]);
+  for (const column of VALIDATION_META_COLUMNS) {
+    columnMeta.set(column, syntheticColumnMeta(numericValidationMeta.has(column) ? "number" : "string"));
+  }
   materializedMetaByValidationResult.set(result, columnMeta);
   return { result, candidates, invalidRowNumbers, columnMeta };
 }
@@ -14626,8 +14815,17 @@ async function executeOnErrorSkip(stmt, client, options, cacheContext, tempTable
   }
   return { type: "UPSERT", insertedCount, updatedCount: updates.length, ...common };
 }
-async function materializeValidationCandidates(stmt, operation, client, options, cacheContext, tempTables, infoByCode) {
-  if (stmt.type === "UPDATE") return materializeUpdateValidationCandidates(stmt, client, options, cacheContext, tempTables);
+async function materializeValidationCandidates(stmt, operation, client, options, cacheContext, tempTables, infoByCode, updateSnapshotFields) {
+  if (stmt.type === "UPDATE") {
+    return materializeUpdateValidationCandidates(
+      stmt,
+      client,
+      options,
+      cacheContext,
+      tempTables,
+      updateSnapshotFields
+    );
+  }
   let rows;
   let sourceRows;
   let sourcePresence;
@@ -14740,40 +14938,70 @@ function assertCheckComparisonTypes(stmt, types) {
     }
   }
 }
-async function materializeUpdateValidationCandidates(stmt, client, options, cacheContext, tempTables) {
-  if (stmt.from) return materializeUpdateFromValidationCandidates(stmt, stmt.from, client, options, cacheContext, tempTables);
+async function materializeUpdateValidationCandidates(stmt, client, options, cacheContext, tempTables, snapshotFields) {
+  if (stmt.from) {
+    return materializeUpdateFromValidationCandidates(
+      stmt,
+      stmt.from,
+      client,
+      options,
+      cacheContext,
+      tempTables,
+      snapshotFields
+    );
+  }
   await resolveSetSubqueries(stmt.assignments, client, options, cacheContext);
   const fieldTypes = await getFieldTypeMap(stmt.appId, client, cacheContext);
   const checkTargetFields = assertUpdateCheckRefs(stmt, fieldTypes);
   assertCheckComparisonTypes(stmt, updateEvaluationTypes(fieldTypes, stmt.appId));
   let records;
   let evaluationById = /* @__PURE__ */ new Map();
+  let snapshotsById = /* @__PURE__ */ new Map();
   if (hasRowDependentAssignment(stmt)) {
     const getParams = updateToGetQueryForArith(stmt);
-    const fields = [.../* @__PURE__ */ new Set([...getParams.fields, ...checkTargetFields])];
+    const fields = [.../* @__PURE__ */ new Set([...getParams.fields, ...checkTargetFields, ...snapshotFields ?? []])];
     const resolved = await fetchRecordsForSharedPlan(client.getRecords, getParams.app, getParams.query, fields, {
       maxRecords: options.maxRecords ?? 1e4,
       parallel: options.fetchParallel ?? 1,
       onLimit: "error"
     });
-    evaluationById = new Map(resolved.records.map((record) => [Number(record["$id"]?.value), record]));
+    snapshotsById = indexDmlUpdateSnapshots(resolved.records);
+    evaluationById = snapshotsById;
     records = updateToPutBatchesArith(stmt, resolved.records, fieldTypes).flatMap((batch) => batch.records);
   } else {
     const getParams = updateToGetQuery(stmt);
     if (checkTargetFields.length > 0) {
-      const resolved = await fetchRecordsForSharedPlan(client.getRecords, getParams.app, getParams.query, [.../* @__PURE__ */ new Set(["$id", ...checkTargetFields])], {
+      const fields = [.../* @__PURE__ */ new Set(["$id", ...checkTargetFields, ...snapshotFields ?? []])];
+      const resolved = await fetchRecordsForSharedPlan(client.getRecords, getParams.app, getParams.query, fields, {
         maxRecords: options.maxRecords ?? 1e4,
         parallel: options.fetchParallel ?? 1,
         onLimit: "error"
       });
-      evaluationById = new Map(resolved.records.map((record) => [Number(record["$id"]?.value), record]));
+      snapshotsById = indexDmlUpdateSnapshots(resolved.records);
+      evaluationById = snapshotsById;
       records = updateToPutBatches(stmt, [...evaluationById.keys()], fieldTypes).flatMap((batch) => batch.records);
     } else {
-      const resolved = await resolveDmlTargetIds(client.getRecords, getParams.app, getParams.query, {
-        maxRecords: options.maxRecords ?? 1e4,
-        parallel: options.fetchParallel ?? 1
-      });
-      records = updateToPutBatches(stmt, resolved.ids, fieldTypes).flatMap((batch) => batch.records);
+      if (snapshotFields) {
+        const resolved = await fetchRecordsForSharedPlan(
+          client.getRecords,
+          getParams.app,
+          getParams.query,
+          [...snapshotFields],
+          {
+            maxRecords: options.maxRecords ?? 1e4,
+            parallel: options.fetchParallel ?? 1,
+            onLimit: "error"
+          }
+        );
+        snapshotsById = indexDmlUpdateSnapshots(resolved.records);
+        records = updateToPutBatches(stmt, [...snapshotsById.keys()], fieldTypes).flatMap((batch) => batch.records);
+      } else {
+        const resolved = await resolveDmlTargetIds(client.getRecords, getParams.app, getParams.query, {
+          maxRecords: options.maxRecords ?? 1e4,
+          parallel: options.fetchParallel ?? 1
+        });
+        records = updateToPutBatches(stmt, resolved.ids, fieldTypes).flatMap((batch) => batch.records);
+      }
     }
   }
   return records.sort((a, b) => a.id - b.id).map((entry, index) => ({
@@ -14784,10 +15012,86 @@ async function materializeUpdateValidationCandidates(stmt, client, options, cach
     preErrors: [],
     record: entry.record,
     targetId: entry.id,
+    validationSnapshot: snapshotsById.get(entry.id),
     evaluationRow: updateEvaluationRow(evaluationById.get(entry.id), stmt.appId),
     evaluationFieldTypes: updateEvaluationTypes(fieldTypes, stmt.appId)
   }));
 }
+function indexDmlUpdateSnapshots(records) {
+  const snapshots = /* @__PURE__ */ new Map();
+  for (const record of records) {
+    const rawId = record["$id"]?.value;
+    const id = Number(rawId);
+    if (!Number.isSafeInteger(id) || id <= 0) {
+      throw new Error(`InternalError: invalid $id in UPDATE validation snapshot: ${String(rawId)}.`);
+    }
+    if (snapshots.has(id)) {
+      throw new Error(`InternalError: duplicate $id in UPDATE validation snapshot: ${id}.`);
+    }
+    snapshots.set(id, record);
+  }
+  return snapshots;
+}
+async function loadMaterializedUpdateSnapshots(input) {
+  const snapshots = /* @__PURE__ */ new Map();
+  for (const candidate of input.candidates) {
+    if (candidate.targetId === void 0 || !candidate.validationSnapshot) {
+      throw new Error(
+        `InternalError: update-mode snapshot is missing for record ${String(candidate.targetId)}.`
+      );
+    }
+    if (snapshots.has(candidate.targetId)) {
+      throw new Error(`InternalError: duplicate UPDATE validation candidate target: ${candidate.targetId}.`);
+    }
+    snapshots.set(candidate.targetId, candidate.validationSnapshot);
+  }
+  return snapshots;
+}
+async function loadUpsertValidationSnapshots(input, client, maxRecords) {
+  const updateIds = [...new Set(input.candidates.map((candidate) => {
+    const id = candidate.targetId;
+    if (!Number.isSafeInteger(id) || id === void 0 || id <= 0) {
+      throw new Error(
+        `InternalError: invalid targetId in UPSERT validation candidate: ${String(id)}.`
+      );
+    }
+    return id;
+  }))];
+  if (updateIds.length > maxRecords) {
+    throw new FetchAllLimitError(
+      `\u53D6\u5F97\u4EF6\u6570\u304C\u4E0A\u9650\uFF08${maxRecords} \u4EF6\uFF09\u3092\u8D85\u3048\u307E\u3057\u305F\u3002WHERE \u53E5\u3067\u7D5E\u308A\u8FBC\u3080\u304B\u3001maxRecords \u3092\u5F15\u304D\u4E0A\u3052\u3066\u304F\u3060\u3055\u3044\u3002`
+    );
+  }
+  const requestedIds = new Set(updateIds);
+  const snapshots = /* @__PURE__ */ new Map();
+  for (const ids of splitChunks(updateIds, 100)) {
+    const response = await client.getRecords({
+      app: input.appId,
+      query: `$id in (${ids.join(",")}) limit 500`,
+      fields: [...new Set(input.fields)]
+    });
+    for (const snapshot of response.records) {
+      const rawId = snapshot["$id"]?.value;
+      const id = Number(rawId);
+      if (!Number.isSafeInteger(id) || id <= 0) {
+        throw new Error(`InternalError: invalid $id in UPSERT validation snapshot: ${String(rawId)}.`);
+      }
+      if (!requestedIds.has(id)) {
+        throw new Error(`InternalError: unexpected $id in UPSERT validation snapshot: ${id}.`);
+      }
+      if (snapshots.has(id)) {
+        throw new Error(`InternalError: duplicate $id in UPSERT validation snapshot: ${id}.`);
+      }
+      snapshots.set(id, snapshot);
+    }
+  }
+  for (const id of updateIds) {
+    if (!snapshots.has(id)) {
+      throw new Error(`InternalError: update-mode snapshot is missing for record ${id}.`);
+    }
+  }
+  return snapshots;
+}
 function assertUpdateCheckRefs(stmt, targetTypes) {
   if (stmt.from) return [];
   const fields = /* @__PURE__ */ new Set();
@@ -14818,13 +15122,22 @@ function updateEvaluationTypes(types, appId) {
     [`APP${appId}.$id`, "RECORD_NUMBER"]
   ]);
 }
-async function materializeUpdateFromValidationCandidates(stmt, from, client, options, cacheContext, tempTables) {
+async function materializeUpdateFromValidationCandidates(stmt, from, client, options, cacheContext, tempTables, snapshotFields) {
   const scope = await resolveUpdateFromCheckScope(stmt, from, client, cacheContext, tempTables);
   assertCheckComparisonTypes(stmt, scope.evaluationTypes);
-  const matched = await resolveUpdateFromMatchedRecords(stmt, from, client, options, cacheContext, tempTables);
+  const matched = await resolveUpdateFromMatchedRecords(
+    stmt,
+    from,
+    client,
+    options,
+    cacheContext,
+    tempTables,
+    snapshotFields
+  );
   const fieldTypes = await getFieldTypeMap(stmt.appId, client, cacheContext);
   const records = updateFromToPutBatches(stmt, matched, fieldTypes).flatMap((batch) => batch.records);
   const matchedById = new Map(matched.map((pair) => [Number(pair.target["$id"]?.value), pair]));
+  const snapshotsById = snapshotFields ? indexDmlUpdateSnapshots(matched.map((pair) => pair.target)) : /* @__PURE__ */ new Map();
   return records.sort((a, b) => a.id - b.id).map((entry, index) => ({
     rowNumber: index + 1,
     operation: "UPDATE",
@@ -14833,6 +15146,7 @@ async function materializeUpdateFromValidationCandidates(stmt, from, client, opt
     preErrors: [],
     record: entry.record,
     targetId: entry.id,
+    validationSnapshot: snapshotsById.get(entry.id),
     evaluationRow: updateFromEvaluationRow(matchedById.get(entry.id), stmt.appId, from.alias),
     evaluationFieldTypes: scope.evaluationTypes
   }));
@@ -14846,7 +15160,7 @@ var UPDATE_FROM_UNSUPPORTED_SOURCE_TYPES = /* @__PURE__ */ new Set([
   "GROUP_SELECT",
   "FILE"
 ]);
-async function resolveUpdateFromMatchedRecords(stmt, from, client, options, cacheContext, tempTables) {
+async function resolveUpdateFromMatchedRecords(stmt, from, client, options, cacheContext, tempTables, snapshotFields) {
   const joinKind = await resolveUpdateFromTargetJoinKind(stmt, from, client, cacheContext);
   const checkScope = await resolveUpdateFromCheckScope(stmt, from, client, cacheContext, tempTables);
   const sourceFields = [...new Set(stmt.assignments.filter((a) => a.value.type === "SOURCE_FIELD").map((a) => a.value.type === "SOURCE_FIELD" ? a.value.field : "").concat(checkScope.sourceFields))];
@@ -14875,7 +15189,11 @@ async function resolveUpdateFromMatchedRecords(stmt, from, client, options, cach
   }
   if (sourceByKey.size === 0) return [];
   const maxRecords = options.maxRecords ?? 1e4;
-  const targetFields = [.../* @__PURE__ */ new Set([...collectUpdateFromTargetFields(stmt), ...checkScope.targetFields])];
+  const targetFields = [.../* @__PURE__ */ new Set([
+    ...collectUpdateFromTargetFields(stmt),
+    ...checkScope.targetFields,
+    ...snapshotFields ?? []
+  ])];
   const filterQuery = from.targetFilter === null ? "" : updateToGetQuery({ ...stmt, from: null, where: from.targetFilter, checkGroups: void 0 }).query;
   const targetRecords = [];
   const seenTargetIds = /* @__PURE__ */ new Set();
@@ -18484,6 +18802,189 @@ function getCursorLeaseManager(host, maxActive = DEFAULT_MAX_ACTIVE) {
   return manager;
 }
 
+// src/node/kintoneMetadata.ts
+var KINTONE_METADATA_RESOURCES = [
+  "app",
+  "fields",
+  "layout",
+  "settings",
+  "status",
+  "views",
+  "reports",
+  "customize"
+];
+var KINTONE_METADATA_LANGS = ["default", "user", "ja", "en", "zh"];
+var KINTONE_METADATA_MAX_RESPONSE_BYTES = 2097152;
+var ResponseTooLargeError = class extends Error {
+  constructor(maxBytes = KINTONE_METADATA_MAX_RESPONSE_BYTES, responseBytes) {
+    super(`ResponseTooLargeError: kintone metadata response exceeds ${maxBytes} bytes.`);
+    this.maxBytes = maxBytes;
+    this.responseBytes = responseBytes;
+    this.name = "ResponseTooLargeError";
+  }
+};
+var InvalidJsonResponseError = class extends Error {
+  constructor(cause) {
+    super("InvalidJsonResponseError: kintone metadata response is not valid JSON.");
+    this.name = "InvalidJsonResponseError";
+    this.cause = cause;
+  }
+};
+var ArgumentError = class extends Error {
+  constructor(message) {
+    super(`ArgumentError: ${message}`);
+    this.name = "ArgumentError";
+  }
+};
+var CapabilityError = class extends Error {
+  constructor(message) {
+    super(`CapabilityError: ${message}`);
+    this.name = "CapabilityError";
+  }
+};
+var RESOURCE_DEFINITIONS = {
+  app: {
+    productionPath: "/app.json",
+    appParameter: "id",
+    allowsLang: false,
+    authCapability: "token|userpass"
+  },
+  fields: {
+    productionPath: "/app/form/fields.json",
+    previewPath: "/preview/app/form/fields.json",
+    appParameter: "app",
+    allowsLang: true,
+    authCapability: "token|userpass"
+  },
+  layout: {
+    productionPath: "/app/form/layout.json",
+    previewPath: "/preview/app/form/layout.json",
+    appParameter: "app",
+    allowsLang: false,
+    authCapability: "token|userpass"
+  },
+  settings: {
+    productionPath: "/app/settings.json",
+    previewPath: "/preview/app/settings.json",
+    appParameter: "app",
+    allowsLang: true,
+    authCapability: "token|userpass"
+  },
+  status: {
+    productionPath: "/app/status.json",
+    previewPath: "/preview/app/status.json",
+    appParameter: "app",
+    allowsLang: true,
+    authCapability: "token|userpass"
+  },
+  views: {
+    productionPath: "/app/views.json",
+    previewPath: "/preview/app/views.json",
+    appParameter: "app",
+    allowsLang: true,
+    authCapability: "token|userpass"
+  },
+  reports: {
+    productionPath: "/app/reports.json",
+    previewPath: "/preview/app/reports.json",
+    appParameter: "app",
+    allowsLang: true,
+    authCapability: "token|userpass"
+  },
+  customize: {
+    productionPath: "/app/customize.json",
+    previewPath: "/preview/app/customize.json",
+    appParameter: "app",
+    allowsLang: false,
+    authCapability: "userpass-only"
+  }
+};
+var RESOURCE_SET = new Set(KINTONE_METADATA_RESOURCES);
+var LANG_SET = new Set(KINTONE_METADATA_LANGS);
+var API_BASE_PATH_PATTERN = /^\/k\/(?:guest\/([1-9]\d*)\/)?v1$/;
+function assertResolvedAppId(resolvedAppId) {
+  if (!Number.isSafeInteger(resolvedAppId) || resolvedAppId <= 0) {
+    throw new ArgumentError("resolved app ID must be a positive safe integer.");
+  }
+}
+function assertApiBasePath(apiBasePath) {
+  const match = API_BASE_PATH_PATTERN.exec(apiBasePath);
+  if (!match) {
+    throw new ArgumentError("apiBasePath must be /k/v1 or /k/guest/<positive safe integer>/v1.");
+  }
+  if (match[1] !== void 0) {
+    const guestSpaceId = Number(match[1]);
+    if (!Number.isSafeInteger(guestSpaceId) || guestSpaceId <= 0) {
+      throw new ArgumentError("apiBasePath guest space ID must be a positive safe integer.");
+    }
+  }
+}
+function validateRequest(request) {
+  if (typeof request !== "object" || request === null || Array.isArray(request)) {
+    throw new ArgumentError("metadata request must be an object.");
+  }
+  const candidate = request;
+  const resource = candidate.resource;
+  if (typeof resource !== "string" || !RESOURCE_SET.has(resource)) {
+    throw new ArgumentError(`unsupported metadata resource: ${String(resource)}.`);
+  }
+  const typedResource = resource;
+  const definition = RESOURCE_DEFINITIONS[typedResource];
+  const allowedKeys = definition.allowsLang ? /* @__PURE__ */ new Set(["resource", "preview", "lang"]) : /* @__PURE__ */ new Set(["resource", "preview"]);
+  const unexpectedKey = Object.keys(candidate).find((key) => !allowedKeys.has(key));
+  if (unexpectedKey !== void 0) {
+    throw new ArgumentError(`parameter "${unexpectedKey}" is not allowed for resource "${resource}".`);
+  }
+  if (candidate.preview !== void 0 && typeof candidate.preview !== "boolean") {
+    throw new ArgumentError("preview must be a boolean when specified.");
+  }
+  const preview = candidate.preview === true;
+  if (preview && definition.previewPath === void 0) {
+    throw new ArgumentError(`preview is not supported for resource "${resource}".`);
+  }
+  const rawLang = candidate.lang;
+  if (rawLang !== void 0) {
+    if (!definition.allowsLang) {
+      throw new ArgumentError(`lang is not allowed for resource "${resource}".`);
+    }
+    if (typeof rawLang !== "string" || !LANG_SET.has(rawLang)) {
+      throw new ArgumentError(`unsupported lang: ${String(rawLang)}.`);
+    }
+  }
+  return {
+    resource: typedResource,
+    preview,
+    lang: rawLang,
+    definition
+  };
+}
+function mapKintoneMetadataRequest(request, resolvedAppId, apiBasePath, authType) {
+  assertResolvedAppId(resolvedAppId);
+  assertApiBasePath(apiBasePath);
+  if (authType !== "token" && authType !== "userpass") {
+    throw new ArgumentError(`unsupported auth type: ${String(authType)}.`);
+  }
+  const { resource, preview, lang, definition } = validateRequest(request);
+  if (definition.authCapability === "userpass-only" && authType === "token") {
+    throw new CapabilityError(`resource "${resource}" requires userpass authentication.`);
+  }
+  const params = new URLSearchParams();
+  params.set(definition.appParameter, String(resolvedAppId));
+  if (lang !== void 0) params.set("lang", lang);
+  const pathFragment = preview ? definition.previewPath : definition.productionPath;
+  if (pathFragment === void 0) {
+    throw new ArgumentError(`preview is not supported for resource "${resource}".`);
+  }
+  return {
+    method: "GET",
+    path: `${apiBasePath}${pathFragment}`,
+    params,
+    environment: preview ? "preview" : "production",
+    resource,
+    authCapability: definition.authCapability
+  };
+}
+
 // src/cli/nodeKintoneClient.ts
 var KintoneApiError = class extends Error {
   constructor(status, code, bodyText) {
@@ -18494,10 +18995,10 @@ var KintoneApiError = class extends Error {
   }
 };
 var SEARCH_ABORTED_HEADER_VALUE = "Filter aborted because of too many search results";
-function createNodeKintoneClient(baseUrl, tokenResolver) {
+function createNodeKintoneConnection(baseUrl, tokenResolver) {
   const normalizedBaseUrl = baseUrl.replace(/\/+$/, "");
   const apiBasePath = tokenResolver.guestSpaceId && tokenResolver.guestSpaceId > 0 ? `/k/guest/${tokenResolver.guestSpaceId}/v1` : "/k/v1";
-  async function requestJsonResponse(path, init, appIdForToken) {
+  async function requestResponse(path, init, appIdForToken) {
     const headers = new Headers(init.headers ?? {});
     if (tokenResolver.auth.type === "token") {
       headers.set("X-Cybozu-API-Token", tokenResolver.auth.resolveToken(appIdForToken));
@@ -18553,13 +19054,68 @@ function createNodeKintoneClient(baseUrl, tokenResolver) {
     }
     const warning = res.headers.get("X-Cybozu-Warning") ?? "";
     return {
-      body: await res.json(),
+      response: res,
       searchAborted: warning.includes(SEARCH_ABORTED_HEADER_VALUE)
     };
   }
+  async function requestJsonResponse(path, init, appIdForToken) {
+    const { response, searchAborted } = await requestResponse(path, init, appIdForToken);
+    return {
+      body: await response.json(),
+      searchAborted
+    };
+  }
   async function requestJson(path, init, appIdForToken) {
     return (await requestJsonResponse(path, init, appIdForToken)).body;
   }
+  async function requestCappedMetadataJson(path, init, appIdForToken) {
+    const { response } = await requestResponse(path, init, appIdForToken);
+    const contentLength = response.headers.get("Content-Length");
+    if (contentLength !== null && /^\d+$/.test(contentLength.trim())) {
+      const declaredBytes = Number(contentLength);
+      if (declaredBytes > KINTONE_METADATA_MAX_RESPONSE_BYTES) {
+        try {
+          await response.body?.cancel();
+        } catch {
+        }
+        throw new ResponseTooLargeError(KINTONE_METADATA_MAX_RESPONSE_BYTES, declaredBytes);
+      }
+    }
+    const chunks = [];
+    let responseBytes = 0;
+    if (response.body !== null) {
+      const reader = response.body.getReader();
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        responseBytes += value.byteLength;
+        if (responseBytes > KINTONE_METADATA_MAX_RESPONSE_BYTES) {
+          try {
+            await reader.cancel();
+          } catch {
+          }
+          throw new ResponseTooLargeError(KINTONE_METADATA_MAX_RESPONSE_BYTES, responseBytes);
+        }
+        chunks.push(value);
+      }
+    }
+    const bytes = new Uint8Array(responseBytes);
+    let offset = 0;
+    for (const chunk3 of chunks) {
+      bytes.set(chunk3, offset);
+      offset += chunk3.byteLength;
+    }
+    let data;
+    try {
+      data = JSON.parse(new TextDecoder("utf-8").decode(bytes));
+    } catch (cause) {
+      throw new InvalidJsonResponseError(cause);
+    }
+    if (typeof data !== "object" || data === null || Array.isArray(data)) {
+      throw new InvalidJsonResponseError();
+    }
+    return { data, responseBytes };
+  }
   function shouldRetryWithRecordNumberOrder(path, bodyText) {
     if (!path.includes("/v1/records.json?")) return false;
     if (!bodyText.includes('"code":"CB_IL02"')) return false;
@@ -18579,7 +19135,7 @@ function createNodeKintoneClient(baseUrl, tokenResolver) {
     const nextQuery = encodeURIComponent(rewritten);
     return `${base}query=${nextQuery}${tail.length > 0 ? `&${tail.join("&")}` : ""}`;
   }
-  return {
+  const client = {
     async getRecords(params) {
       const queryPart = `query=${encodeURIComponent(params.query)}`;
       const appPart = `app=${encodeURIComponent(String(params.app))}`;
@@ -18751,6 +19307,34 @@ function createNodeKintoneClient(baseUrl, tokenResolver) {
       };
     }
   };
+  const metadataReader = {
+    async getMetadata(request, resolvedAppId) {
+      const plan = mapKintoneMetadataRequest(
+        request,
+        resolvedAppId,
+        apiBasePath,
+        tokenResolver.auth.type
+      );
+      const query = plan.params.toString();
+      const { data, responseBytes } = await requestCappedMetadataJson(
+        `${plan.path}${query.length > 0 ? `?${query}` : ""}`,
+        { method: "GET" },
+        resolvedAppId
+      );
+      return {
+        resource: plan.resource,
+        environment: plan.environment,
+        path: plan.path,
+        params: Object.fromEntries(plan.params.entries()),
+        responseBytes,
+        data
+      };
+    }
+  };
+  return { client, metadataReader };
+}
+function createNodeKintoneClient(baseUrl, tokenResolver) {
+  return createNodeKintoneConnection(baseUrl, tokenResolver).client;
 }
 
 // src/node/appProfiles.ts