@commercelayer/sdk-utils/lib/chunk-C3GAO7XD.js

Commerce Layer Javascript SDK Utils library

import { headerRateLimits, computeRateLimits } from './chunk-5DLBI7WA.js';
import { sleep, invalidToken } from './chunk-PDAZISCK.js';
import { init_default } from './chunk-XGJBRQ3X.js';

// src/batch.ts
var InvalidTokenError = class extends Error {
  cause;
  constructor(error) {
    super(error.first().detail);
    this.cause = error;
  }
};
var isCRUDTask = (task) => {
  return task.resource && ["create", "retrieve", "update", "delete"].includes(task.operation);
};
var taskRateLimit = (batch2, task, info) => {
  if (info) {
    if (!batch2.rateLimits) batch2.rateLimits = {};
    Object.assign(batch2.rateLimits || {}, { [task.resourceType]: { [task.operation]: info } });
  }
  const resLimits = batch2.rateLimits?.[task.resourceType];
  return resLimits ? resLimits[task.operation] : void 0;
};
var executeTask = async (task, options = {}) => {
  const client = init_default().api(task.resourceType);
  let out;
  try {
    task.executed = false;
    const op = client[task.operation];
    if (!op) throw new Error(`Unsupported operation [resource: ${task.resourceType}, operation: ${task.operation}]`);
    switch (task.operation) {
      case "list": {
        out = await client[task.operation](task.params, task.options);
        break;
      }
      case "delete": {
        await client[task.operation](task.resource, task.options);
        break;
      }
      case "create":
      case "retrieve":
      case "update": {
        out = await client[task.operation](task.resource, task.params, task.options);
        break;
      }
    }
    if (!task.onSuccess) task.onSuccess = {};
    const success = task.onSuccess;
    success.result = out;
    if (success.callback) try {
      await success.callback(success.result, task);
    } catch (err) {
    }
    return out;
  } catch (error) {
    if (invalidToken(error)) throw new InvalidTokenError(error);
    if (!task.onFailure) task.onFailure = {};
    const failure = task.onFailure;
    failure.error = error;
    let halt = options.haltOnError || failure.haltOnError;
    if (failure.errorHandler) try {
      halt = halt || await failure.errorHandler(failure.error, task);
    } catch (err) {
    }
    if (halt) throw error;
  } finally {
    task.executed = true;
  }
};
var resolvePlaceholders = (resource, last) => {
};
var executeBatch = async (batch2) => {
  const cl = init_default().sdk;
  const rrr = cl.addRawResponseReader({ headers: true });
  batch2.running = false;
  const result = {
    startedAt: /* @__PURE__ */ new Date()
  };
  let runningIndex = -1;
  let lastResult;
  for (const task of batch2.tasks) {
    runningIndex++;
    batch2.running = true;
    batch2.runningTask = task.label || String(runningIndex);
    let rateLimit = taskRateLimit(batch2, task);
    if (rateLimit) await sleep(rateLimit.delay);
    try {
      if (lastResult && isCRUDTask(task)) {
        let modRes;
        try {
          if (task.resource && task.prepareResource) modRes = await task.prepareResource(task.resource, lastResult);
          else modRes = await resolvePlaceholders(task.resource, lastResult);
        } catch (e) {
          modRes = void 0;
        }
        if (modRes) task.resource = modRes;
      }
      lastResult = void 0;
      lastResult = await executeTask(task, batch2.options);
    } catch (err) {
      if (err instanceof InvalidTokenError && batch2.options?.refreshToken) {
        const newAccessToken = await batch2.options.refreshToken(err, task);
        cl.config({ accessToken: newAccessToken });
        await executeTask(task, batch2.options);
      } else throw err;
    } finally {
      batch2.running = false;
      batch2.runningTask = void 0;
    }
    if (!rateLimit) try {
      const rateLimits = headerRateLimits(rrr.headers);
      rateLimit = computeRateLimits(rateLimits, task, batch2.tasks);
      taskRateLimit(batch2, task, rateLimit);
    } catch (error) {
    }
  }
  if (cl && rrr) cl.removeRawResponseReader();
  result.finishedAt = /* @__PURE__ */ new Date();
  return result;
};
var batch = {
  execute: executeBatch
};

export { InvalidTokenError, batch, executeBatch };
//# sourceMappingURL=chunk-C3GAO7XD.js.map
//# sourceMappingURL=chunk-C3GAO7XD.js.map