@open-mercato/core 0.6.8-develop.6993.1.3fc50f3409 → 0.6.8-develop.7000.1.0ae682bad1

package/dist/modules/data_sync/lib/batch-stream.js

@@ -0,0 +1,56 @@
+import { createLogger } from "@open-mercato/shared/lib/logger";
+import {
+  withTelemetrySpan
+} from "@open-mercato/shared/lib/telemetry/runtime";
+const logger = createLogger("data_sync").child({ component: "batch-stream" });
+async function closeQuietly(iterator) {
+  if (!iterator.return) return;
+  try {
+    await iterator.return();
+  } catch (error) {
+    logger.warn("Data sync adapter stream did not close cleanly", { err: error });
+  }
+}
+async function forEachBatch(stream, options, handle) {
+  const iterator = stream[Symbol.asyncIterator]();
+  for (; ; ) {
+    let readThrew = false;
+    let outcome;
+    try {
+      outcome = await withTelemetrySpan(
+        options.spanName,
+        async (span) => {
+          let next;
+          try {
+            next = await iterator.next();
+          } catch (error) {
+            readThrew = true;
+            throw error;
+          }
+          if (next.done) {
+            span.updateName?.(options.drainSpanName);
+            return "exhausted";
+          }
+          return handle(next.value, span);
+        },
+        {
+          root: true,
+          attributes: options.attributes,
+          links: options.linkTo ? [options.linkTo] : void 0
+        }
+      );
+    } catch (error) {
+      if (!readThrew) await closeQuietly(iterator);
+      throw error;
+    }
+    if (outcome === "exhausted") return "completed";
+    if (outcome === "stop") {
+      await iterator.return?.();
+      return "stopped";
+    }
+  }
+}
+export {
+  forEachBatch
+};
+//# sourceMappingURL=batch-stream.js.map

package/dist/modules/data_sync/lib/batch-stream.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/modules/data_sync/lib/batch-stream.ts"],
+  "sourcesContent": ["import { createLogger } from '@open-mercato/shared/lib/logger'\nimport {\n  withTelemetrySpan,\n  type TelemetrySpan,\n  type TelemetrySpanAttributes,\n  type TelemetryTraceCarrier,\n} from '@open-mercato/shared/lib/telemetry/runtime'\n\nconst logger = createLogger('data_sync').child({ component: 'batch-stream' })\n\n/** What the handler wants the stream to do next. */\nexport type BatchOutcome = 'continue' | 'stop'\n\n/** Why the stream ended: the adapter ran out of batches, or a handler stopped it. */\nexport type BatchStreamResult = 'completed' | 'stopped'\n\nexport type BatchStreamOptions = {\n  spanName: string\n  /**\n   * Name for the read that turns out to have drained the stream. That read is\n   * real adapter work \u2014 it can be a full remote page fetch that comes back\n   * empty \u2014 so it stays traced, but it is not a batch: leaving it under\n   * `spanName` would report one batch more than the run actually processed and\n   * feed an unlabelled, counter-less sample into every batch latency panel.\n   */\n  drainSpanName: string\n  /** Run-level attributes repeated on every batch span (run id, entity type, scope). */\n  attributes?: TelemetrySpanAttributes\n  /** The run's trace, so a rooted batch still points back at what triggered it. */\n  linkTo?: TelemetryTraceCarrier\n}\n\n/**\n * Close the stream while an error is already in flight. That error is the one\n * worth propagating, so a secondary cleanup failure is logged rather than\n * allowed to mask it \u2014 which is what `for await` does on a body throw.\n */\nasync function closeQuietly(iterator: AsyncIterator<unknown>): Promise<void> {\n  if (!iterator.return) return\n  try {\n    await iterator.return()\n  } catch (error) {\n    logger.warn('Data sync adapter stream did not close cleanly', { err: error })\n  }\n}\n\n/**\n * Drive `stream` one batch at a time, running the adapter's read AND `handle`'s\n * bookkeeping for that batch inside a single ROOT span linked back to the run.\n *\n * Rooting per batch is the whole point. A sync run can last days, so leaving its\n * spans nested under the request that triggered it puts the entire run behind\n * one sampling decision \u2014 below ratio 1.0 a run can emit nothing at all, and at\n * 1.0 it becomes a single unrenderable trace. A batch is the unit the slowness\n * analysis actually reasons about, so it gets its own trace and its own\n * decision.\n *\n * The iterator is driven explicitly instead of with `for await` so the span can\n * wrap `next()`, which is where an adapter generator does its real work \u2014 it\n * reads, transforms and upserts before it ever yields. A stream is only known to\n * be drained once that read returns `done`, so the last span per run starts\n * under `spanName` and is renamed to `drainSpanName`: a run over N batches emits\n * N spans named `spanName` and exactly one named `drainSpanName`.\n *\n * Closing follows the language's own `IteratorClose` rules exactly, so adapter\n * cleanup behaves as it did under `for await`:\n *\n * - **exhausted** \u2014 the iterator already completed itself; no `return()` call.\n * - **stopped early** \u2014 `return()` is called and a failure to close *is* the\n *   result, the same as breaking out of `for await`.\n * - **`handle` threw** \u2014 `return()` is called, but its failure is swallowed so\n *   the handler's error still wins.\n * - **`next()` threw** \u2014 the iterator is already closed; no `return()` call.\n */\nexport async function forEachBatch<TBatch>(\n  stream: AsyncIterable<TBatch>,\n  options: BatchStreamOptions,\n  handle: (batch: TBatch, span: TelemetrySpan) => Promise<BatchOutcome>,\n): Promise<BatchStreamResult> {\n  const iterator = stream[Symbol.asyncIterator]()\n  for (;;) {\n    let readThrew = false\n    let outcome: BatchOutcome | 'exhausted'\n    try {\n      outcome = await withTelemetrySpan(\n        options.spanName,\n        async (span): Promise<BatchOutcome | 'exhausted'> => {\n          let next: IteratorResult<TBatch>\n          try {\n            next = await iterator.next()\n          } catch (error) {\n            readThrew = true\n            throw error\n          }\n          if (next.done) {\n            span.updateName?.(options.drainSpanName)\n            return 'exhausted'\n          }\n          return handle(next.value, span)\n        },\n        {\n          root: true,\n          attributes: options.attributes,\n          links: options.linkTo ? [options.linkTo] : undefined,\n        },\n      )\n    } catch (error) {\n      if (!readThrew) await closeQuietly(iterator)\n      throw error\n    }\n    if (outcome === 'exhausted') return 'completed'\n    if (outcome === 'stop') {\n      await iterator.return?.()\n      return 'stopped'\n    }\n  }\n}\n"],
+  "mappings": "AAAA,SAAS,oBAAoB;AAC7B;AAAA,EACE;AAAA,OAIK;AAEP,MAAM,SAAS,aAAa,WAAW,EAAE,MAAM,EAAE,WAAW,eAAe,CAAC;AA6B5E,eAAe,aAAa,UAAiD;AAC3E,MAAI,CAAC,SAAS,OAAQ;AACtB,MAAI;AACF,UAAM,SAAS,OAAO;AAAA,EACxB,SAAS,OAAO;AACd,WAAO,KAAK,kDAAkD,EAAE,KAAK,MAAM,CAAC;AAAA,EAC9E;AACF;AA8BA,eAAsB,aACpB,QACA,SACA,QAC4B;AAC5B,QAAM,WAAW,OAAO,OAAO,aAAa,EAAE;AAC9C,aAAS;AACP,QAAI,YAAY;AAChB,QAAI;AACJ,QAAI;AACF,gBAAU,MAAM;AAAA,QACd,QAAQ;AAAA,QACR,OAAO,SAA8C;AACnD,cAAI;AACJ,cAAI;AACF,mBAAO,MAAM,SAAS,KAAK;AAAA,UAC7B,SAAS,OAAO;AACd,wBAAY;AACZ,kBAAM;AAAA,UACR;AACA,cAAI,KAAK,MAAM;AACb,iBAAK,aAAa,QAAQ,aAAa;AACvC,mBAAO;AAAA,UACT;AACA,iBAAO,OAAO,KAAK,OAAO,IAAI;AAAA,QAChC;AAAA,QACA;AAAA,UACE,MAAM;AAAA,UACN,YAAY,QAAQ;AAAA,UACpB,OAAO,QAAQ,SAAS,CAAC,QAAQ,MAAM,IAAI;AAAA,QAC7C;AAAA,MACF;AAAA,IACF,SAAS,OAAO;AACd,UAAI,CAAC,UAAW,OAAM,aAAa,QAAQ;AAC3C,YAAM;AAAA,IACR;AACA,QAAI,YAAY,YAAa,QAAO;AACpC,QAAI,YAAY,QAAQ;AACtB,YAAM,SAAS,SAAS;AACxB,aAAO;AAAA,IACT;AAAA,EACF;AACF;",
+  "names": []
+}

package/dist/modules/data_sync/lib/run-parameters.js

@@ -0,0 +1,108 @@
+const RESERVED_PARAMETER_KEYS = /* @__PURE__ */ new Set(["__proto__"]);
+function isReservedRunParameterKey(key) {
+  return RESERVED_PARAMETER_KEYS.has(key);
+}
+function getApplicableRunParameters(declared, direction, entityType) {
+  if (!declared || declared.length === 0) return [];
+  return declared.filter((param) => {
+    if (isReservedRunParameterKey(param.key)) return false;
+    if (param.direction && param.direction !== direction) return false;
+    if (param.entityType !== void 0 && entityType !== void 0) {
+      const allowed = Array.isArray(param.entityType) ? param.entityType : [param.entityType];
+      if (!allowed.includes(entityType)) return false;
+    }
+    return true;
+  });
+}
+function isBlank(value) {
+  return value === void 0 || value === null || typeof value === "string" && value.trim().length === 0;
+}
+function coerceBoolean(value) {
+  if (typeof value === "boolean") return value;
+  if (typeof value === "number") {
+    if (value === 1) return true;
+    if (value === 0) return false;
+    return null;
+  }
+  if (typeof value === "string") {
+    const normalized = value.trim().toLowerCase();
+    if (["true", "1", "yes", "on"].includes(normalized)) return true;
+    if (["false", "0", "no", "off"].includes(normalized)) return false;
+  }
+  return null;
+}
+function coerceNumber(value) {
+  if (typeof value === "number") return Number.isFinite(value) ? value : null;
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (trimmed.length === 0) return null;
+    const parsed = Number(trimmed);
+    return Number.isFinite(parsed) ? parsed : null;
+  }
+  return null;
+}
+function buildRunParameterError(param, code, extra = {}) {
+  const message = code === "required" ? `${param.label} is required.` : code === "type" ? `${param.label} must be a ${extra.type}.` : code === "min" ? `${param.label} must be at least ${extra.min}.` : code === "max" ? `${param.label} must be at most ${extra.max}.` : `${param.label} must be one of: ${extra.options}.`;
+  return { key: param.key, code, params: { label: param.label, ...extra }, message };
+}
+function coerceDeclaredValue(param, raw) {
+  switch (param.type) {
+    case "boolean": {
+      const coerced = coerceBoolean(raw);
+      if (coerced === null) return { ok: false, error: buildRunParameterError(param, "type", { type: "boolean" }) };
+      return { ok: true, value: coerced };
+    }
+    case "number": {
+      const coerced = coerceNumber(raw);
+      if (coerced === null) return { ok: false, error: buildRunParameterError(param, "type", { type: "number" }) };
+      if (typeof param.min === "number" && coerced < param.min) {
+        return { ok: false, error: buildRunParameterError(param, "min", { min: param.min }) };
+      }
+      if (typeof param.max === "number" && coerced > param.max) {
+        return { ok: false, error: buildRunParameterError(param, "max", { max: param.max }) };
+      }
+      return { ok: true, value: coerced };
+    }
+    case "select": {
+      const candidate = String(raw);
+      const allowed = (param.options ?? []).map((option) => option.value);
+      if (!allowed.includes(candidate)) {
+        return { ok: false, error: buildRunParameterError(param, "select", { options: allowed.join(", ") }) };
+      }
+      return { ok: true, value: candidate };
+    }
+    case "string":
+    default:
+      return { ok: true, value: String(raw).trim() };
+  }
+}
+function normalizeRunParameters(declared, direction, raw, entityType) {
+  const params = getApplicableRunParameters(declared, direction, entityType);
+  const input = raw && typeof raw === "object" ? raw : {};
+  const values = {};
+  const errors = [];
+  for (const param of params) {
+    const provided = Object.prototype.hasOwnProperty.call(input, param.key) ? input[param.key] : void 0;
+    if (isBlank(provided)) {
+      if (param.defaultValue === void 0) {
+        if (param.required) errors.push(buildRunParameterError(param, "required"));
+        continue;
+      }
+      const fallback = coerceDeclaredValue(param, param.defaultValue);
+      if (fallback.ok) values[param.key] = fallback.value;
+      else errors.push(fallback.error);
+      continue;
+    }
+    const coerced = coerceDeclaredValue(param, provided);
+    if (coerced.ok) values[param.key] = coerced.value;
+    else errors.push(coerced.error);
+  }
+  if (errors.length > 0) return { ok: false, errors };
+  return { ok: true, values };
+}
+export {
+  getApplicableRunParameters,
+  isReservedRunParameterKey,
+  normalizeRunParameters
+};
+//# sourceMappingURL=run-parameters.js.map

package/dist/modules/data_sync/lib/run-parameters.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/modules/data_sync/lib/run-parameters.ts"],
+  "sourcesContent": ["import type { RunParameter, RunParameterValue } from './adapter'\n\nexport type RunParameterErrorCode = 'required' | 'type' | 'min' | 'max' | 'select'\n\nexport type RunParameterError = {\n  key: string\n  /**\n   * Machine-readable reason, so the client can render a translated message.\n   * The dashboard maps these to `data_sync.runParameters.errors.<code>`.\n   */\n  code: RunParameterErrorCode\n  /** Values the translated message interpolates (label, bound, option list). */\n  params: { label: string; type?: string; min?: number; max?: number; options?: string }\n  /**\n   * Pre-rendered English sentence. Kept for non-UI callers (API clients, logs)\n   * and as the client-side fallback; the UI prefers `code` + `params`.\n   */\n  message: string\n}\n\nexport type NormalizeRunParametersResult =\n  | { ok: true; values: Record<string, RunParameterValue> }\n  | { ok: false; errors: RunParameterError[] }\n\n/**\n * Keys that cannot round-trip through a plain object literal. Assigning a\n * primitive to `__proto__` is silently discarded rather than creating an own\n * property, so a parameter declared under that key would vanish between the\n * form and the adapter instead of failing loudly. Rejecting it here \u2014 the one\n * place every surface funnels through \u2014 keeps the dashboard, the default-value\n * builder and the normalizer agreeing on the same parameter set.\n *\n * (`constructor` / `prototype` assign normally and are left alone.)\n */\nconst RESERVED_PARAMETER_KEYS = new Set(['__proto__'])\n\nexport function isReservedRunParameterKey(key: string): boolean {\n  return RESERVED_PARAMETER_KEYS.has(key)\n}\n\n/**\n * Returns the declared parameters that apply to a given run. A parameter\n * without an explicit `direction` applies to both directions; one without an\n * explicit `entityType` applies to every entity. When `entityType` is omitted\n * here (the caller does not know the run's entity), entity scoping is skipped.\n * Parameters declared under a reserved key are dropped.\n */\nexport function getApplicableRunParameters(\n  declared: RunParameter[] | undefined,\n  direction: 'import' | 'export',\n  entityType?: string,\n): RunParameter[] {\n  if (!declared || declared.length === 0) return []\n  return declared.filter((param) => {\n    if (isReservedRunParameterKey(param.key)) return false\n    if (param.direction && param.direction !== direction) return false\n    if (param.entityType !== undefined && entityType !== undefined) {\n      const allowed = Array.isArray(param.entityType) ? param.entityType : [param.entityType]\n      if (!allowed.includes(entityType)) return false\n    }\n    return true\n  })\n}\n\nfunction isBlank(value: unknown): boolean {\n  return value === undefined || value === null || (typeof value === 'string' && value.trim().length === 0)\n}\n\nfunction coerceBoolean(value: unknown): boolean | null {\n  if (typeof value === 'boolean') return value\n  if (typeof value === 'number') {\n    if (value === 1) return true\n    if (value === 0) return false\n    return null\n  }\n  if (typeof value === 'string') {\n    const normalized = value.trim().toLowerCase()\n    if (['true', '1', 'yes', 'on'].includes(normalized)) return true\n    if (['false', '0', 'no', 'off'].includes(normalized)) return false\n  }\n  return null\n}\n\nfunction coerceNumber(value: unknown): number | null {\n  if (typeof value === 'number') return Number.isFinite(value) ? value : null\n  if (typeof value === 'string') {\n    const trimmed = value.trim()\n    if (trimmed.length === 0) return null\n    const parsed = Number(trimmed)\n    return Number.isFinite(parsed) ? parsed : null\n  }\n  return null\n}\n\n/**\n * Validate and coerce an untrusted parameter object against an adapter's\n * declared `runParameters` for the given run direction and entity type.\n *\n * - Parameters that do not apply to the direction or entity type are ignored.\n * - Undeclared keys in the input are dropped (never passed through).\n * - Blank values fall back to `defaultValue`; a blank required value is an error.\n * - Values are coerced to the declared type; the result only contains declared keys.\n */\nfunction buildRunParameterError(\n  param: RunParameter,\n  code: RunParameterErrorCode,\n  extra: { type?: string; min?: number; max?: number; options?: string } = {},\n): RunParameterError {\n  const message = code === 'required' ? `${param.label} is required.`\n    : code === 'type' ? `${param.label} must be a ${extra.type}.`\n    : code === 'min' ? `${param.label} must be at least ${extra.min}.`\n    : code === 'max' ? `${param.label} must be at most ${extra.max}.`\n    : `${param.label} must be one of: ${extra.options}.`\n  return { key: param.key, code, params: { label: param.label, ...extra }, message }\n}\n\ntype CoerceResult =\n  | { ok: true; value: RunParameterValue }\n  | { ok: false; error: RunParameterError }\n\n/** Coerces and range-checks one non-blank value against its declaration. */\nfunction coerceDeclaredValue(param: RunParameter, raw: unknown): CoerceResult {\n  switch (param.type) {\n    case 'boolean': {\n      const coerced = coerceBoolean(raw)\n      if (coerced === null) return { ok: false, error: buildRunParameterError(param, 'type', { type: 'boolean' }) }\n      return { ok: true, value: coerced }\n    }\n    case 'number': {\n      const coerced = coerceNumber(raw)\n      if (coerced === null) return { ok: false, error: buildRunParameterError(param, 'type', { type: 'number' }) }\n      if (typeof param.min === 'number' && coerced < param.min) {\n        return { ok: false, error: buildRunParameterError(param, 'min', { min: param.min }) }\n      }\n      if (typeof param.max === 'number' && coerced > param.max) {\n        return { ok: false, error: buildRunParameterError(param, 'max', { max: param.max }) }\n      }\n      return { ok: true, value: coerced }\n    }\n    case 'select': {\n      const candidate = String(raw)\n      const allowed = (param.options ?? []).map((option) => option.value)\n      if (!allowed.includes(candidate)) {\n        return { ok: false, error: buildRunParameterError(param, 'select', { options: allowed.join(', ') }) }\n      }\n      return { ok: true, value: candidate }\n    }\n    case 'string':\n    default:\n      return { ok: true, value: String(raw).trim() }\n  }\n}\n\nexport function normalizeRunParameters(\n  declared: RunParameter[] | undefined,\n  direction: 'import' | 'export',\n  raw: Record<string, unknown> | null | undefined,\n  entityType?: string,\n): NormalizeRunParametersResult {\n  const params = getApplicableRunParameters(declared, direction, entityType)\n  const input = raw && typeof raw === 'object' ? raw : {}\n  const values: Record<string, RunParameterValue> = {}\n  const errors: RunParameterError[] = []\n\n  for (const param of params) {\n    // Own-property lookup only: a parameter declared under an inherited name\n    // (`constructor`, `toString`, `valueOf`) would otherwise read back the\n    // inherited function instead of `undefined`, so a required check would\n    // silently pass and a string parameter would coerce the function source.\n    const provided = Object.prototype.hasOwnProperty.call(input, param.key)\n      ? (input as Record<string, unknown>)[param.key]\n      : undefined\n\n    if (isBlank(provided)) {\n      if (param.defaultValue === undefined) {\n        if (param.required) errors.push(buildRunParameterError(param, 'required'))\n        continue\n      }\n      // The declared default goes through the same checks as a submitted\n      // value, so a misdeclared adapter (a `select` default outside its own\n      // options, a number below its own `min`) fails loudly here rather than\n      // shipping an invalid value to itself mid-run.\n      const fallback = coerceDeclaredValue(param, param.defaultValue)\n      if (fallback.ok) values[param.key] = fallback.value\n      else errors.push(fallback.error)\n      continue\n    }\n\n    const coerced = coerceDeclaredValue(param, provided)\n    if (coerced.ok) values[param.key] = coerced.value\n    else errors.push(coerced.error)\n  }\n\n  if (errors.length > 0) return { ok: false, errors }\n  return { ok: true, values }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/modules/data_sync/lib/start-run.js

@@ -29,6 +29,7 @@ async function startDataSyncRun(params) {
       direction: input.direction,
       cursor: input.cursor ?? null,
       triggeredBy: input.triggeredBy ?? scope.userId ?? null,
+      parameters: input.parameters ?? null,
       progressJobId: progressJob?.id ?? null
     },
     {

package/dist/modules/data_sync/lib/start-run.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../src/modules/data_sync/lib/start-run.ts"],
-  "sourcesContent": ["import type { ProgressService } from '../../progress/lib/progressService'\nimport type { SyncRunService } from './sync-run-service'\nimport { getSyncQueue } from './queue'\nimport { DATA_SYNC_EXPORT_QUEUE, DATA_SYNC_IMPORT_QUEUE } from './queue-policy'\n\nexport type DataSyncStartScope = {\n  organizationId: string\n  tenantId: string\n  userId?: string | null\n}\n\nexport type StartDataSyncRunInput = {\n  integrationId: string\n  entityType: string\n  direction: 'import' | 'export'\n  cursor?: string | null\n  triggeredBy?: string | null\n  batchSize?: number\n  createProgressJob?: boolean\n  progressJob?: {\n    jobType?: string\n    name?: string\n    description?: string\n    cancellable?: boolean\n    meta?: Record<string, unknown>\n  }\n}\n\nexport async function startDataSyncRun(params: {\n  syncRunService: SyncRunService\n  progressService: ProgressService\n  scope: DataSyncStartScope\n  input: StartDataSyncRunInput\n}) {\n  const { syncRunService, progressService, scope, input } = params\n  const createProgressJob = input.createProgressJob !== false\n\n  const progressJob = createProgressJob\n    ? await progressService.createJob(\n      {\n        jobType: input.progressJob?.jobType ?? `data_sync:${input.direction}`,\n        name: input.progressJob?.name ?? `Data sync ${input.integrationId} \u2014 ${input.entityType}`,\n        description: input.progressJob?.description ?? `${input.entityType} ${input.direction}`,\n        cancellable: input.progressJob?.cancellable ?? true,\n        meta: {\n          integrationId: input.integrationId,\n          entityType: input.entityType,\n          direction: input.direction,\n          ...(input.progressJob?.meta ?? {}),\n        },\n      },\n      {\n        tenantId: scope.tenantId,\n        organizationId: scope.organizationId,\n        userId: scope.userId,\n      },\n    )\n    : null\n\n  const run = await syncRunService.createRun(\n    {\n      integrationId: input.integrationId,\n      entityType: input.entityType,\n      direction: input.direction,\n      cursor: input.cursor ?? null,\n      triggeredBy: input.triggeredBy ?? scope.userId ?? null,\n      progressJobId: progressJob?.id ?? null,\n    },\n    {\n      organizationId: scope.organizationId,\n      tenantId: scope.tenantId,\n    },\n  )\n\n  const queueName = input.direction === 'import' ? DATA_SYNC_IMPORT_QUEUE : DATA_SYNC_EXPORT_QUEUE\n  const queue = getSyncQueue(queueName)\n  await queue.enqueue({\n    runId: run.id,\n    batchSize: input.batchSize ?? 100,\n    scope: {\n      organizationId: scope.organizationId,\n      tenantId: scope.tenantId,\n      userId: scope.userId ?? null,\n    },\n  })\n\n  return {\n    run,\n    progressJob,\n  }\n}\n"],
-  "mappings": "AAEA,SAAS,oBAAoB;AAC7B,SAAS,wBAAwB,8BAA8B;AAyB/D,eAAsB,iBAAiB,QAKpC;AACD,QAAM,EAAE,gBAAgB,iBAAiB,OAAO,MAAM,IAAI;AAC1D,QAAM,oBAAoB,MAAM,sBAAsB;AAEtD,QAAM,cAAc,oBAChB,MAAM,gBAAgB;AAAA,IACtB;AAAA,MACE,SAAS,MAAM,aAAa,WAAW,aAAa,MAAM,SAAS;AAAA,MACnE,MAAM,MAAM,aAAa,QAAQ,aAAa,MAAM,aAAa,WAAM,MAAM,UAAU;AAAA,MACvF,aAAa,MAAM,aAAa,eAAe,GAAG,MAAM,UAAU,IAAI,MAAM,SAAS;AAAA,MACrF,aAAa,MAAM,aAAa,eAAe;AAAA,MAC/C,MAAM;AAAA,QACJ,eAAe,MAAM;AAAA,QACrB,YAAY,MAAM;AAAA,QAClB,WAAW,MAAM;AAAA,QACjB,GAAI,MAAM,aAAa,QAAQ,CAAC;AAAA,MAClC;AAAA,IACF;AAAA,IACA;AAAA,MACE,UAAU,MAAM;AAAA,MAChB,gBAAgB,MAAM;AAAA,MACtB,QAAQ,MAAM;AAAA,IAChB;AAAA,EACF,IACE;AAEJ,QAAM,MAAM,MAAM,eAAe;AAAA,IAC/B;AAAA,MACE,eAAe,MAAM;AAAA,MACrB,YAAY,MAAM;AAAA,MAClB,WAAW,MAAM;AAAA,MACjB,QAAQ,MAAM,UAAU;AAAA,MACxB,aAAa,MAAM,eAAe,MAAM,UAAU;AAAA,MAClD,eAAe,aAAa,MAAM;AAAA,IACpC;AAAA,IACA;AAAA,MACE,gBAAgB,MAAM;AAAA,MACtB,UAAU,MAAM;AAAA,IAClB;AAAA,EACF;AAEA,QAAM,YAAY,MAAM,cAAc,WAAW,yBAAyB;AAC1E,QAAM,QAAQ,aAAa,SAAS;AACpC,QAAM,MAAM,QAAQ;AAAA,IAClB,OAAO,IAAI;AAAA,IACX,WAAW,MAAM,aAAa;AAAA,IAC9B,OAAO;AAAA,MACL,gBAAgB,MAAM;AAAA,MACtB,UAAU,MAAM;AAAA,MAChB,QAAQ,MAAM,UAAU;AAAA,IAC1B;AAAA,EACF,CAAC;AAED,SAAO;AAAA,IACL;AAAA,IACA;AAAA,EACF;AACF;",
+  "sourcesContent": ["import type { ProgressService } from '../../progress/lib/progressService'\nimport type { SyncRunService } from './sync-run-service'\nimport { getSyncQueue } from './queue'\nimport { DATA_SYNC_EXPORT_QUEUE, DATA_SYNC_IMPORT_QUEUE } from './queue-policy'\n\nexport type DataSyncStartScope = {\n  organizationId: string\n  tenantId: string\n  userId?: string | null\n}\n\nexport type StartDataSyncRunInput = {\n  integrationId: string\n  entityType: string\n  direction: 'import' | 'export'\n  cursor?: string | null\n  triggeredBy?: string | null\n  batchSize?: number\n  parameters?: Record<string, unknown> | null\n  createProgressJob?: boolean\n  progressJob?: {\n    jobType?: string\n    name?: string\n    description?: string\n    cancellable?: boolean\n    meta?: Record<string, unknown>\n  }\n}\n\nexport async function startDataSyncRun(params: {\n  syncRunService: SyncRunService\n  progressService: ProgressService\n  scope: DataSyncStartScope\n  input: StartDataSyncRunInput\n}) {\n  const { syncRunService, progressService, scope, input } = params\n  const createProgressJob = input.createProgressJob !== false\n\n  const progressJob = createProgressJob\n    ? await progressService.createJob(\n      {\n        jobType: input.progressJob?.jobType ?? `data_sync:${input.direction}`,\n        name: input.progressJob?.name ?? `Data sync ${input.integrationId} \u2014 ${input.entityType}`,\n        description: input.progressJob?.description ?? `${input.entityType} ${input.direction}`,\n        cancellable: input.progressJob?.cancellable ?? true,\n        meta: {\n          integrationId: input.integrationId,\n          entityType: input.entityType,\n          direction: input.direction,\n          ...(input.progressJob?.meta ?? {}),\n        },\n      },\n      {\n        tenantId: scope.tenantId,\n        organizationId: scope.organizationId,\n        userId: scope.userId,\n      },\n    )\n    : null\n\n  const run = await syncRunService.createRun(\n    {\n      integrationId: input.integrationId,\n      entityType: input.entityType,\n      direction: input.direction,\n      cursor: input.cursor ?? null,\n      triggeredBy: input.triggeredBy ?? scope.userId ?? null,\n      parameters: input.parameters ?? null,\n      progressJobId: progressJob?.id ?? null,\n    },\n    {\n      organizationId: scope.organizationId,\n      tenantId: scope.tenantId,\n    },\n  )\n\n  const queueName = input.direction === 'import' ? DATA_SYNC_IMPORT_QUEUE : DATA_SYNC_EXPORT_QUEUE\n  const queue = getSyncQueue(queueName)\n  await queue.enqueue({\n    runId: run.id,\n    batchSize: input.batchSize ?? 100,\n    scope: {\n      organizationId: scope.organizationId,\n      tenantId: scope.tenantId,\n      userId: scope.userId ?? null,\n    },\n  })\n\n  return {\n    run,\n    progressJob,\n  }\n}\n"],
+  "mappings": "AAEA,SAAS,oBAAoB;AAC7B,SAAS,wBAAwB,8BAA8B;AA0B/D,eAAsB,iBAAiB,QAKpC;AACD,QAAM,EAAE,gBAAgB,iBAAiB,OAAO,MAAM,IAAI;AAC1D,QAAM,oBAAoB,MAAM,sBAAsB;AAEtD,QAAM,cAAc,oBAChB,MAAM,gBAAgB;AAAA,IACtB;AAAA,MACE,SAAS,MAAM,aAAa,WAAW,aAAa,MAAM,SAAS;AAAA,MACnE,MAAM,MAAM,aAAa,QAAQ,aAAa,MAAM,aAAa,WAAM,MAAM,UAAU;AAAA,MACvF,aAAa,MAAM,aAAa,eAAe,GAAG,MAAM,UAAU,IAAI,MAAM,SAAS;AAAA,MACrF,aAAa,MAAM,aAAa,eAAe;AAAA,MAC/C,MAAM;AAAA,QACJ,eAAe,MAAM;AAAA,QACrB,YAAY,MAAM;AAAA,QAClB,WAAW,MAAM;AAAA,QACjB,GAAI,MAAM,aAAa,QAAQ,CAAC;AAAA,MAClC;AAAA,IACF;AAAA,IACA;AAAA,MACE,UAAU,MAAM;AAAA,MAChB,gBAAgB,MAAM;AAAA,MACtB,QAAQ,MAAM;AAAA,IAChB;AAAA,EACF,IACE;AAEJ,QAAM,MAAM,MAAM,eAAe;AAAA,IAC/B;AAAA,MACE,eAAe,MAAM;AAAA,MACrB,YAAY,MAAM;AAAA,MAClB,WAAW,MAAM;AAAA,MACjB,QAAQ,MAAM,UAAU;AAAA,MACxB,aAAa,MAAM,eAAe,MAAM,UAAU;AAAA,MAClD,YAAY,MAAM,cAAc;AAAA,MAChC,eAAe,aAAa,MAAM;AAAA,IACpC;AAAA,IACA;AAAA,MACE,gBAAgB,MAAM;AAAA,MACtB,UAAU,MAAM;AAAA,IAClB;AAAA,EACF;AAEA,QAAM,YAAY,MAAM,cAAc,WAAW,yBAAyB;AAC1E,QAAM,QAAQ,aAAa,SAAS;AACpC,QAAM,MAAM,QAAQ;AAAA,IAClB,OAAO,IAAI;AAAA,IACX,WAAW,MAAM,aAAa;AAAA,IAC9B,OAAO;AAAA,MACL,gBAAgB,MAAM;AAAA,MACtB,UAAU,MAAM;AAAA,MAChB,QAAQ,MAAM,UAAU;AAAA,IAC1B;AAAA,EACF,CAAC;AAED,SAAO;AAAA,IACL;AAAA,IACA;AAAA,EACF;AACF;",
   "names": []
 }

package/dist/modules/data_sync/lib/sync-engine.js

@@ -3,8 +3,23 @@ import { refreshCoverageSnapshot } from "../../query_index/lib/coverage.js";
 import { emitDataSyncEvent } from "../events.js";
 import { getDataSyncAdapter, resolveProviderKey } from "./adapter-registry.js";
 import { SyncRunOwnershipConflictError } from "./sync-run-service.js";
+import { forEachBatch } from "./batch-stream.js";
 import { createLogger } from "@open-mercato/shared/lib/logger";
+import {
+  captureTelemetryTrace
+} from "@open-mercato/shared/lib/telemetry/runtime";
 const logger = createLogger("data_sync").child({ component: "sync-engine" });
+function runSpanAttributes(run, providerKey, scope) {
+  return {
+    "data_sync.run_id": run.id,
+    "data_sync.integration_id": run.integrationId,
+    "data_sync.provider_key": providerKey,
+    "data_sync.entity_type": run.entityType,
+    "data_sync.direction": run.direction,
+    "om.tenant_id": scope.tenantId,
+    "om.organization_id": scope.organizationId
+  };
+}
 function applyImportCounters(batch) {
   let createdCount = 0;
   let updatedCount = 0;
@@ -409,59 +424,84 @@ function createSyncEngine(deps) {
       let processedCount = await seedProcessedCount(run.progressJobId, scope);
       let totalCount = null;
       let committedBatches = activeRun.batchesCompleted ?? 0;
+      const runTrace = captureTelemetryTrace();
+      const spanAttributes = runSpanAttributes(run, providerKey, scope);
       try {
-        for await (const batch of withHeartbeat(
-          adapter.streamImport({
-            entityType: run.entityType,
-            cursor: run.cursor ?? void 0,
-            batchSize,
-            credentials,
-            mapping,
-            scope: { organizationId: scope.organizationId, tenantId: scope.tenantId },
-            runId: run.id
-          }),
-          makeHeartbeatTick(run.progressJobId, scope),
-          HEARTBEAT_TICK_MS
-        )) {
-          if (run.progressJobId && await progressService.isCancellationRequested(run.progressJobId, scope.tenantId, scope.organizationId)) {
-            await finalizeRun(run.id, "cancelled", scope, void 0, operationalTelemetry);
-            return;
-          }
-          const delta = applyImportCounters(batch);
-          const processedBatchCount = batch.processedCount ?? batch.items.length;
-          processedCount += processedBatchCount;
-          totalCount = batch.totalEstimate ?? totalCount;
-          await syncRunService.commitBatchProgress(
-            run.id,
-            {
-              ...delta,
-              batchesCompleted: 1
-            },
-            batch.cursor,
-            scope,
-            { expectedBatchesCompleted: committedBatches, persistSharedCursor }
-          );
-          committedBatches += 1;
-          await updateProgress(run.progressJobId, processedCount, totalCount, scope);
-          await refreshCoverageSnapshots(batch.refreshCoverageEntityTypes, scope);
-          await logImportItemFailures(run.id, run.integrationId, batch.items, scope);
-          await writeOperationalLog({
-            integrationId: run.integrationId,
-            runId: run.id,
-            level: "info",
-            message: batch.message?.trim().length ? batch.message.trim() : `Processed import batch ${batch.batchIndex}`,
-            scope,
-            enabled: operationalTelemetry,
-            payload: {
-              operationalStatus: "running",
-              summary: `Processed ${processedCount}${totalCount ? ` of ${totalCount}` : ""} rows so far.`,
-              processedCount,
-              batchSize: batch.items.length,
-              processedBatchCount,
-              cursor: batch.cursor
+        const streamResult = await forEachBatch(
+          withHeartbeat(
+            adapter.streamImport({
+              entityType: run.entityType,
+              cursor: run.cursor ?? void 0,
+              batchSize,
+              credentials,
+              mapping,
+              scope: { organizationId: scope.organizationId, tenantId: scope.tenantId },
+              runId: run.id,
+              parameters: run.parameters ?? {}
+            }),
+            makeHeartbeatTick(run.progressJobId, scope),
+            HEARTBEAT_TICK_MS
+          ),
+          {
+            spanName: "data_sync.import.batch",
+            drainSpanName: "data_sync.import.drain",
+            attributes: spanAttributes,
+            linkTo: runTrace
+          },
+          async (batch, span) => {
+            span.setAttributes({
+              "data_sync.batch_index": batch.batchIndex,
+              "data_sync.batch_size": batch.items.length
+            });
+            if (run.progressJobId && await progressService.isCancellationRequested(run.progressJobId, scope.tenantId, scope.organizationId)) {
+              await finalizeRun(run.id, "cancelled", scope, void 0, operationalTelemetry);
+              return "stop";
             }
-          });
-        }
+            const delta = applyImportCounters(batch);
+            const processedBatchCount = batch.processedCount ?? batch.items.length;
+            processedCount += processedBatchCount;
+            totalCount = batch.totalEstimate ?? totalCount;
+            span.setAttributes({
+              "data_sync.processed_count": processedBatchCount,
+              "data_sync.created_count": delta.createdCount,
+              "data_sync.updated_count": delta.updatedCount,
+              "data_sync.skipped_count": delta.skippedCount,
+              "data_sync.failed_count": delta.failedCount
+            });
+            await syncRunService.commitBatchProgress(
+              run.id,
+              {
+                ...delta,
+                batchesCompleted: 1
+              },
+              batch.cursor,
+              scope,
+              { expectedBatchesCompleted: committedBatches, persistSharedCursor }
+            );
+            committedBatches += 1;
+            await updateProgress(run.progressJobId, processedCount, totalCount, scope);
+            await refreshCoverageSnapshots(batch.refreshCoverageEntityTypes, scope);
+            await logImportItemFailures(run.id, run.integrationId, batch.items, scope);
+            await writeOperationalLog({
+              integrationId: run.integrationId,
+              runId: run.id,
+              level: "info",
+              message: batch.message?.trim().length ? batch.message.trim() : `Processed import batch ${batch.batchIndex}`,
+              scope,
+              enabled: operationalTelemetry,
+              payload: {
+                operationalStatus: "running",
+                summary: `Processed ${processedCount}${totalCount ? ` of ${totalCount}` : ""} rows so far.`,
+                processedCount,
+                batchSize: batch.items.length,
+                processedBatchCount,
+                cursor: batch.cursor
+              }
+            });
+            return "continue";
+          }
+        );
+        if (streamResult === "stopped") return;
       } catch (error) {
         if (error instanceof SyncRunOwnershipConflictError) {
           logger.warn("Yielding import run to a concurrent worker that already advanced it", {
@@ -556,58 +596,82 @@ function createSyncEngine(deps) {
       const mapping = await resolveMapping(adapter, run.entityType, scope);
       let processedCount = await seedProcessedCount(run.progressJobId, scope);
       let committedBatches = activeRun.batchesCompleted ?? 0;
+      const runTrace = captureTelemetryTrace();
+      const spanAttributes = runSpanAttributes(run, providerKey, scope);
       try {
-        for await (const batch of withHeartbeat(
-          adapter.streamExport({
-            entityType: run.entityType,
-            cursor: run.cursor ?? void 0,
-            batchSize,
-            credentials,
-            mapping,
-            scope: { organizationId: scope.organizationId, tenantId: scope.tenantId },
-            runId: run.id
-          }),
-          makeHeartbeatTick(run.progressJobId, scope),
-          HEARTBEAT_TICK_MS
-        )) {
-          if (run.progressJobId && await progressService.isCancellationRequested(run.progressJobId, scope.tenantId, scope.organizationId)) {
-            await finalizeRun(run.id, "cancelled", scope, void 0, operationalTelemetry);
-            return;
-          }
-          const delta = applyExportCounters(batch);
-          processedCount += delta.processedCount;
-          await syncRunService.commitBatchProgress(
-            run.id,
-            {
-              createdCount: 0,
-              updatedCount: delta.updatedCount,
-              skippedCount: delta.skippedCount,
-              failedCount: delta.failedCount,
-              batchesCompleted: 1
-            },
-            batch.cursor,
-            scope,
-            { expectedBatchesCompleted: committedBatches, persistSharedCursor }
-          );
-          committedBatches += 1;
-          await updateProgress(run.progressJobId, processedCount, null, scope);
-          await logExportItemFailures(run.id, run.integrationId, batch.results, scope);
-          await writeOperationalLog({
-            integrationId: run.integrationId,
-            runId: run.id,
-            level: "info",
-            message: `Processed export batch ${batch.batchIndex}`,
-            scope,
-            enabled: operationalTelemetry,
-            payload: {
-              operationalStatus: "running",
-              summary: `Processed ${processedCount} export items so far.`,
-              processedCount,
-              batchSize: batch.results.length,
-              cursor: batch.cursor
+        const streamResult = await forEachBatch(
+          withHeartbeat(
+            adapter.streamExport({
+              entityType: run.entityType,
+              cursor: run.cursor ?? void 0,
+              batchSize,
+              credentials,
+              mapping,
+              scope: { organizationId: scope.organizationId, tenantId: scope.tenantId },
+              runId: run.id,
+              parameters: run.parameters ?? {}
+            }),
+            makeHeartbeatTick(run.progressJobId, scope),
+            HEARTBEAT_TICK_MS
+          ),
+          {
+            spanName: "data_sync.export.batch",
+            drainSpanName: "data_sync.export.drain",
+            attributes: spanAttributes,
+            linkTo: runTrace
+          },
+          async (batch, span) => {
+            span.setAttributes({
+              "data_sync.batch_index": batch.batchIndex,
+              "data_sync.batch_size": batch.results.length
+            });
+            if (run.progressJobId && await progressService.isCancellationRequested(run.progressJobId, scope.tenantId, scope.organizationId)) {
+              await finalizeRun(run.id, "cancelled", scope, void 0, operationalTelemetry);
+              return "stop";
             }
-          });
-        }
+            const delta = applyExportCounters(batch);
+            processedCount += delta.processedCount;
+            span.setAttributes({
+              "data_sync.processed_count": delta.processedCount,
+              "data_sync.updated_count": delta.updatedCount,
+              "data_sync.skipped_count": delta.skippedCount,
+              "data_sync.failed_count": delta.failedCount
+            });
+            await syncRunService.commitBatchProgress(
+              run.id,
+              {
+                createdCount: 0,
+                updatedCount: delta.updatedCount,
+                skippedCount: delta.skippedCount,
+                failedCount: delta.failedCount,
+                batchesCompleted: 1
+              },
+              batch.cursor,
+              scope,
+              { expectedBatchesCompleted: committedBatches, persistSharedCursor }
+            );
+            committedBatches += 1;
+            await updateProgress(run.progressJobId, processedCount, null, scope);
+            await logExportItemFailures(run.id, run.integrationId, batch.results, scope);
+            await writeOperationalLog({
+              integrationId: run.integrationId,
+              runId: run.id,
+              level: "info",
+              message: `Processed export batch ${batch.batchIndex}`,
+              scope,
+              enabled: operationalTelemetry,
+              payload: {
+                operationalStatus: "running",
+                summary: `Processed ${processedCount} export items so far.`,
+                processedCount,
+                batchSize: batch.results.length,
+                cursor: batch.cursor
+              }
+            });
+            return "continue";
+          }
+        );
+        if (streamResult === "stopped") return;
       } catch (error) {
         if (error instanceof SyncRunOwnershipConflictError) {
           logger.warn("Yielding export run to a concurrent worker that already advanced it", {