@objectstack/rest 12.1.0 → 12.3.0

package/dist/index.cjs

@@ -667,9 +667,9 @@ function runImport(opts) {
           resolveRef
         });
         if (errors.length > 0) {
-          const first = errors[0];
+          const first2 = errors[0];
           errCount++;
-          results.push({ row: rowNo, ok: false, action: "failed", field: first.field, code: first.code, error: first.message });
+          results.push({ row: rowNo, ok: false, action: "failed", field: first2.field, code: first2.code, error: first2.message });
         } else {
           let existing = "none";
           let handled = false;
@@ -747,6 +747,116 @@ function runImport(opts) {
   })();
 }
 
+// src/import-mapping.ts
+function unwrapEnvelope(r) {
+  if (r && typeof r === "object" && "item" in r) {
+    return r.item;
+  }
+  return r;
+}
+async function resolveNamedMapping(p, opts) {
+  const { mappingName, objectName, detectedFormat } = opts;
+  if (typeof p?.getMetaItem !== "function") {
+    return { ok: false, status: 500, code: "INTERNAL", error: "Metadata protocol unavailable; cannot resolve mappingName" };
+  }
+  let artifact;
+  try {
+    artifact = unwrapEnvelope(await p.getMetaItem({ type: "mapping", name: mappingName }));
+  } catch {
+  }
+  if (!artifact || typeof artifact !== "object" || !Array.isArray(artifact.fieldMapping)) {
+    return { ok: false, status: 404, code: "MAPPING_NOT_FOUND", error: `No mapping artifact named "${mappingName}" is registered` };
+  }
+  if (artifact.targetObject !== objectName) {
+    return {
+      ok: false,
+      status: 400,
+      code: "MAPPING_TARGET_MISMATCH",
+      error: `Mapping "${mappingName}" targets object "${artifact.targetObject}", not "${objectName}"`
+    };
+  }
+  const declared = artifact.sourceFormat;
+  if (declared === "xml" || declared === "sql") {
+    return {
+      ok: false,
+      status: 400,
+      code: "MAPPING_FORMAT_UNSUPPORTED",
+      error: `Mapping "${mappingName}" declares sourceFormat "${declared}", which the import endpoint does not accept (csv/json/xlsx)`
+    };
+  }
+  const compatible = declared === void 0 || declared === "json" && detectedFormat === "json" || declared === "csv" && (detectedFormat === "csv" || detectedFormat === "xlsx");
+  if (!compatible) {
+    return {
+      ok: false,
+      status: 400,
+      code: "MAPPING_FORMAT_MISMATCH",
+      error: `Mapping "${mappingName}" declares sourceFormat "${declared}" but the payload is "${detectedFormat}"`
+    };
+  }
+  for (const entry of artifact.fieldMapping) {
+    if (entry?.transform === "javascript") {
+      return {
+        ok: false,
+        status: 400,
+        code: "UNSUPPORTED_TRANSFORM",
+        error: `Mapping "${mappingName}" uses transform "javascript", which the import path does not execute (no server-side sandbox; see framework#2611)`
+      };
+    }
+  }
+  return { ok: true, artifact };
+}
+var first = (v) => Array.isArray(v) ? v[0] : v;
+function applyMappingToRows(rows, artifact) {
+  const out = [];
+  for (const row of rows) {
+    const mapped = {};
+    for (const entry of artifact.fieldMapping) {
+      const transform = entry.transform ?? "none";
+      const sep = entry.params?.separator ?? " ";
+      switch (transform) {
+        case "none":
+        case "lookup": {
+          mapped[first(entry.target)] = row[first(entry.source)];
+          break;
+        }
+        case "constant": {
+          mapped[first(entry.target)] = entry.params?.value;
+          break;
+        }
+        case "map": {
+          const raw = row[first(entry.source)];
+          const valueMap = entry.params?.valueMap ?? {};
+          mapped[first(entry.target)] = typeof raw === "string" && raw in valueMap ? valueMap[raw] : raw;
+          break;
+        }
+        case "split": {
+          const raw = row[first(entry.source)];
+          const targets = Array.isArray(entry.target) ? entry.target : [entry.target];
+          const parts = typeof raw === "string" ? raw.split(sep) : [];
+          targets.forEach((t, i) => {
+            mapped[t] = parts[i]?.trim();
+          });
+          break;
+        }
+        case "join": {
+          const sources = Array.isArray(entry.source) ? entry.source : [entry.source];
+          mapped[first(entry.target)] = sources.map((s) => row[s]).filter((v) => v !== void 0 && v !== null && v !== "").join(sep);
+          break;
+        }
+        default:
+          return {
+            ok: false,
+            status: 400,
+            code: "UNSUPPORTED_TRANSFORM",
+            error: `Mapping "${artifact.name}" uses unknown transform "${transform}"`
+          };
+      }
+    }
+    out.push(mapped);
+  }
+  return { ok: true, rows: out };
+}
+
 // src/rest-server.ts
 var import_meta = {};
 var logError = (...args) => globalThis.console?.error(...args);
@@ -1011,13 +1121,34 @@ async function parseXlsxToRows(buffer, mapping = {}, sheet) {
 async function prepareImportRequest(body, opts) {
   const { p, objectName, environmentId, maxRows } = opts;
   const dryRun = body?.dryRun === true;
-  const writeMode = body?.writeMode === "update" || body?.writeMode === "upsert" ? body.writeMode : "insert";
-  const matchFields = Array.isArray(body?.matchFields) ? body.matchFields.filter((f) => typeof f === "string" && f.length > 0) : [];
+  let writeMode = body?.writeMode === "update" || body?.writeMode === "upsert" ? body.writeMode : "insert";
+  let matchFields = Array.isArray(body?.matchFields) ? body.matchFields.filter((f) => typeof f === "string" && f.length > 0) : [];
   const runAutomations = body?.runAutomations === true;
   const trimWhitespace = body?.trimWhitespace !== false;
   const nullValues = Array.isArray(body?.nullValues) ? body.nullValues.filter((v) => typeof v === "string") : void 0;
   const createMissingOptions = body?.createMissingOptions === true;
   const skipBlankMatchKey = body?.skipBlankMatchKey === true;
+  const mappingName = typeof body?.mappingName === "string" && body.mappingName.length > 0 ? body.mappingName : void 0;
+  const hasInlineMapping = Array.isArray(body?.mapping) && body.mapping.length > 0 || !Array.isArray(body?.mapping) && body?.mapping && typeof body.mapping === "object" && Object.keys(body.mapping).length > 0;
+  if (mappingName && hasInlineMapping) {
+    return { ok: false, status: 400, code: "CONFLICTING_MAPPING", error: "Provide either mappingName or an inline mapping, not both" };
+  }
+  let mappingArtifact;
+  if (mappingName) {
+    const detectedFormat = body?.format === "json" && Array.isArray(body?.rows) || Array.isArray(body) ? "json" : typeof body?.csv === "string" ? "csv" : typeof body?.xlsxBase64 === "string" ? "xlsx" : void 0;
+    if (!detectedFormat) {
+      return { ok: false, status: 400, code: "INVALID_REQUEST", error: 'Provide format:"csv" with csv text, format:"json" with rows[], or format:"xlsx" with xlsxBase64' };
+    }
+    const resolved = await resolveNamedMapping(p, { mappingName, objectName, detectedFormat });
+    if (!resolved.ok) return resolved;
+    mappingArtifact = resolved.artifact;
+    if (body?.writeMode === void 0 && (mappingArtifact.mode === "update" || mappingArtifact.mode === "upsert")) {
+      writeMode = mappingArtifact.mode;
+    }
+    if (matchFields.length === 0 && Array.isArray(mappingArtifact.upsertKey)) {
+      matchFields = mappingArtifact.upsertKey.filter((f) => typeof f === "string" && f.length > 0);
+    }
+  }
   if (writeMode !== "insert" && matchFields.length === 0) {
     return { ok: false, status: 400, code: "INVALID_REQUEST", error: `writeMode "${writeMode}" requires a non-empty matchFields[]` };
   }
@@ -1059,6 +1190,11 @@ async function prepareImportRequest(body, opts) {
   if (rows.length > maxRows) {
     return { ok: false, status: 413, code: "PAYLOAD_TOO_LARGE", error: `Import limit is ${maxRows} rows per request (got ${rows.length}).` };
   }
+  if (mappingArtifact) {
+    const applied = applyMappingToRows(rows, mappingArtifact);
+    if (!applied.ok) return applied;
+    rows = applied.rows;
+  }
   let metaMap = /* @__PURE__ */ new Map();
   try {
     let schema = void 0;