@chidchanun/bcp 0.2.7 → 0.2.9

package/packages/client/src/jobs.mjs

@@ -0,0 +1,1040 @@
+// packages/server/src/jobs.ts
+import {
+  randomUUID
+} from "node:crypto";
+function createMemoryJobQueueAdapter() {
+  const jobs = /* @__PURE__ */ new Map();
+  return {
+    async enqueue(job) {
+      if (jobs.has(job.id)) {
+        throw new Error(
+          `BCP Jobs: job id "${job.id}" already exists.`
+        );
+      }
+      jobs.set(
+        job.id,
+        cloneJob(job)
+      );
+    },
+    async reserve(now) {
+      const candidate = Array.from(
+        jobs.values()
+      ).filter(
+        (job) => job.state === "queued" && job.availableAt <= now
+      ).sort(
+        (left, right) => left.availableAt - right.availableAt || left.createdAt - right.createdAt || left.id.localeCompare(right.id)
+      )[0];
+      if (!candidate) {
+        return null;
+      }
+      candidate.state = "running";
+      candidate.attempts += 1;
+      candidate.startedAt = now;
+      candidate.error = void 0;
+      return cloneJob(
+        candidate
+      );
+    },
+    async complete(id, completedAt) {
+      const job = jobs.get(id);
+      if (!job || job.state === "cancelled") {
+        return;
+      }
+      job.state = "succeeded";
+      job.completedAt = completedAt;
+      job.error = void 0;
+    },
+    async fail(id, options) {
+      const job = jobs.get(id);
+      if (!job || job.state === "cancelled") {
+        return;
+      }
+      job.error = options.error;
+      if (options.retryAt !== void 0 && job.attempts < job.maxAttempts) {
+        job.state = "queued";
+        job.availableAt = options.retryAt;
+        job.startedAt = void 0;
+        return;
+      }
+      job.state = "failed";
+      job.completedAt = options.failedAt;
+    },
+    async cancel(id, cancelledAt) {
+      const job = jobs.get(id);
+      if (!job || job.state === "succeeded" || job.state === "failed" || job.state === "cancelled") {
+        return false;
+      }
+      job.state = "cancelled";
+      job.completedAt = cancelledAt;
+      return true;
+    },
+    async get(id) {
+      const job = jobs.get(id);
+      return job ? cloneJob(job) : null;
+    },
+    async list() {
+      return Array.from(
+        jobs.values()
+      ).map(cloneJob).sort(
+        (left, right) => left.createdAt - right.createdAt || left.id.localeCompare(right.id)
+      );
+    },
+    clear() {
+      jobs.clear();
+    }
+  };
+}
+function createJobQueue(options = {}) {
+  const adapter = options.adapter ?? createMemoryJobQueueAdapter();
+  const handlers = /* @__PURE__ */ new Map();
+  const workers = /* @__PURE__ */ new Set();
+  const now = options.now ?? Date.now;
+  const idFactory = options.idFactory ?? randomUUID;
+  const defaultMaxAttempts = normalizePositiveInteger(
+    options.defaultMaxAttempts ?? 3,
+    "defaultMaxAttempts"
+  );
+  const retryDelay = options.retryDelayMs ?? ((attempt) => Math.min(
+    3e4,
+    1e3 * 2 ** Math.max(
+      0,
+      attempt - 1
+    )
+  ));
+  const queue = {
+    adapter,
+    register(name, handler) {
+      const normalizedName = normalizeJobName(name);
+      if (typeof handler !== "function") {
+        throw new TypeError(
+          "BCP Jobs: handler must be a function."
+        );
+      }
+      if (handlers.has(
+        normalizedName
+      )) {
+        throw new Error(
+          `BCP Jobs: handler "${normalizedName}" is already registered.`
+        );
+      }
+      const registeredHandler = handler;
+      handlers.set(
+        normalizedName,
+        registeredHandler
+      );
+      return () => {
+        if (handlers.get(
+          normalizedName
+        ) === registeredHandler) {
+          handlers.delete(
+            normalizedName
+          );
+        }
+      };
+    },
+    async enqueue(name, payload, enqueueOptions = {}) {
+      const createdAt = now();
+      const delayMs = normalizeNonNegativeNumber(
+        enqueueOptions.delayMs ?? 0,
+        "delayMs"
+      );
+      const maxAttempts = normalizePositiveInteger(
+        enqueueOptions.maxAttempts ?? defaultMaxAttempts,
+        "maxAttempts"
+      );
+      const id = normalizeJobId(
+        enqueueOptions.id ?? idFactory()
+      );
+      const job = {
+        id,
+        name: normalizeJobName(
+          name
+        ),
+        payload,
+        state: "queued",
+        attempts: 0,
+        maxAttempts,
+        createdAt,
+        availableAt: createdAt + delayMs
+      };
+      await adapter.enqueue(
+        job
+      );
+      return cloneJob(job);
+    },
+    get(id) {
+      return adapter.get(
+        normalizeJobId(id)
+      );
+    },
+    list() {
+      return adapter.list();
+    },
+    cancel(id) {
+      return adapter.cancel(
+        normalizeJobId(id),
+        now()
+      );
+    },
+    async processNext(signal = new AbortController().signal) {
+      if (signal.aborted) {
+        return false;
+      }
+      const job = await adapter.reserve(
+        now()
+      );
+      if (!job) {
+        return false;
+      }
+      const handler = handlers.get(
+        job.name
+      );
+      if (!handler) {
+        await adapter.fail(
+          job.id,
+          {
+            error: `No handler registered for job "${job.name}".`,
+            failedAt: now()
+          }
+        );
+        return true;
+      }
+      try {
+        await handler({
+          job: cloneJob(job),
+          payload: job.payload,
+          signal
+        });
+        await adapter.complete(
+          job.id,
+          now()
+        );
+      } catch (error) {
+        const failedAt = now();
+        const shouldRetry = job.attempts < job.maxAttempts;
+        const retryAt = shouldRetry ? failedAt + resolveRetryDelay(
+          retryDelay,
+          job.attempts
+        ) : void 0;
+        await adapter.fail(
+          job.id,
+          {
+            error: formatJobError(
+              error
+            ),
+            failedAt,
+            retryAt
+          }
+        );
+      }
+      return true;
+    },
+    startWorker(workerOptions = {}) {
+      const worker = createWorker(
+        queue,
+        workerOptions,
+        () => workers.delete(
+          worker
+        )
+      );
+      workers.add(worker);
+      return worker;
+    },
+    async close() {
+      await Promise.all(
+        Array.from(
+          workers,
+          (worker) => worker.stop()
+        )
+      );
+      if (adapter.close) {
+        await adapter.close();
+      }
+    }
+  };
+  return queue;
+}
+function createWorker(queue, options, onStop) {
+  const concurrency = normalizePositiveInteger(
+    options.concurrency ?? 1,
+    "concurrency"
+  );
+  const pollIntervalMs = normalizeNonNegativeNumber(
+    options.pollIntervalMs ?? 250,
+    "pollIntervalMs"
+  );
+  const controller = new AbortController();
+  let running = true;
+  let stopPromise = null;
+  const loops = Array.from(
+    {
+      length: concurrency
+    },
+    () => runWorkerLoop(
+      queue,
+      controller.signal,
+      pollIntervalMs
+    )
+  );
+  return {
+    get running() {
+      return running;
+    },
+    stop() {
+      if (stopPromise) {
+        return stopPromise;
+      }
+      running = false;
+      controller.abort();
+      stopPromise = Promise.allSettled(
+        loops
+      ).then(
+        () => {
+          onStop();
+        }
+      );
+      return stopPromise;
+    }
+  };
+}
+async function runWorkerLoop(queue, signal, pollIntervalMs) {
+  while (!signal.aborted) {
+    const processed = await queue.processNext(
+      signal
+    );
+    if (!processed && !signal.aborted) {
+      await sleep(
+        pollIntervalMs,
+        signal
+      );
+    }
+  }
+}
+function sleep(durationMs, signal) {
+  if (durationMs === 0 || signal.aborted) {
+    return Promise.resolve();
+  }
+  return new Promise(
+    (resolve) => {
+      const timeout = setTimeout(
+        finish,
+        durationMs
+      );
+      const onAbort = () => finish();
+      signal.addEventListener(
+        "abort",
+        onAbort,
+        {
+          once: true
+        }
+      );
+      function finish() {
+        clearTimeout(timeout);
+        signal.removeEventListener(
+          "abort",
+          onAbort
+        );
+        resolve();
+      }
+    }
+  );
+}
+function resolveRetryDelay(value, attempt) {
+  const delay = typeof value === "function" ? value(attempt) : value;
+  return normalizeNonNegativeNumber(
+    delay,
+    "retryDelayMs"
+  );
+}
+function normalizeJobName(value) {
+  const name = String(value).trim();
+  if (!name) {
+    throw new TypeError(
+      "BCP Jobs: job name must be a non-empty string."
+    );
+  }
+  if (name.length > 200) {
+    throw new TypeError(
+      "BCP Jobs: job name must not exceed 200 characters."
+    );
+  }
+  return name;
+}
+function normalizeJobId(value) {
+  const id = String(value).trim();
+  if (!id) {
+    throw new TypeError(
+      "BCP Jobs: job id must be a non-empty string."
+    );
+  }
+  if (id.length > 200) {
+    throw new TypeError(
+      "BCP Jobs: job id must not exceed 200 characters."
+    );
+  }
+  return id;
+}
+function normalizePositiveInteger(value, field) {
+  if (!Number.isInteger(value) || value <= 0) {
+    throw new TypeError(
+      `BCP Jobs: ${field} must be a positive integer.`
+    );
+  }
+  return value;
+}
+function normalizeNonNegativeNumber(value, field) {
+  if (!Number.isFinite(value) || value < 0) {
+    throw new TypeError(
+      `BCP Jobs: ${field} must be a non-negative finite number.`
+    );
+  }
+  return Math.floor(value);
+}
+function formatJobError(error) {
+  if (error instanceof Error) {
+    return error.message || error.name;
+  }
+  if (typeof error === "string") {
+    return error;
+  }
+  try {
+    const serialized = JSON.stringify(error);
+    return serialized ?? String(error);
+  } catch {
+    return String(error);
+  }
+}
+function cloneJob(job) {
+  return {
+    ...job
+  };
+}
+
+// packages/server/src/job-scheduler.ts
+import {
+  randomUUID as randomUUID2
+} from "node:crypto";
+function createMemoryJobScheduleStore() {
+  const schedules = /* @__PURE__ */ new Map();
+  return {
+    async upsert(schedule) {
+      schedules.set(
+        schedule.id,
+        cloneSchedule(
+          schedule
+        )
+      );
+    },
+    async get(id) {
+      const schedule = schedules.get(id);
+      return schedule ? cloneSchedule(
+        schedule
+      ) : null;
+    },
+    async list() {
+      return Array.from(
+        schedules.values()
+      ).map(
+        cloneSchedule
+      ).sort(
+        (left, right) => left.nextRunAt - right.nextRunAt || left.id.localeCompare(
+          right.id
+        )
+      );
+    },
+    async remove(id) {
+      return schedules.delete(id);
+    },
+    async acquireDue(now, options) {
+      const due = Array.from(
+        schedules.values()
+      ).filter(
+        (schedule) => schedule.nextRunAt <= now && (schedule.leaseUntil === void 0 || schedule.leaseUntil <= now)
+      ).sort(
+        (left, right) => left.nextRunAt - right.nextRunAt || left.id.localeCompare(
+          right.id
+        )
+      ).slice(
+        0,
+        options.limit
+      );
+      for (const schedule of due) {
+        schedule.leaseOwner = options.ownerId;
+        schedule.leaseUntil = now + options.leaseMs;
+      }
+      return due.map(
+        cloneSchedule
+      );
+    },
+    async complete(id, options) {
+      const schedule = schedules.get(id);
+      if (!schedule || schedule.leaseOwner !== options.ownerId) {
+        return;
+      }
+      schedule.lastRunAt = options.lastRunAt;
+      schedule.nextRunAt = options.nextRunAt;
+      schedule.updatedAt = options.updatedAt;
+      schedule.leaseOwner = void 0;
+      schedule.leaseUntil = void 0;
+    },
+    async release(id, ownerId) {
+      const schedule = schedules.get(id);
+      if (!schedule || schedule.leaseOwner !== ownerId) {
+        return;
+      }
+      schedule.leaseOwner = void 0;
+      schedule.leaseUntil = void 0;
+    },
+    clear() {
+      schedules.clear();
+    }
+  };
+}
+function createJobScheduler(options) {
+  if (!options || !options.queue) {
+    throw new TypeError(
+      "BCP Jobs: createJobScheduler requires a queue."
+    );
+  }
+  const queue = options.queue;
+  const store = options.store ?? createMemoryJobScheduleStore();
+  const now = options.now ?? Date.now;
+  const idFactory = options.idFactory ?? randomUUID2;
+  const ownerId = normalizeIdentifier(
+    options.ownerId ?? `scheduler-${randomUUID2()}`,
+    "scheduler owner id"
+  );
+  const runners = /* @__PURE__ */ new Set();
+  const scheduler = {
+    queue,
+    store,
+    ownerId,
+    async schedule(jobName, payload, scheduleOptions) {
+      const currentTime = normalizeTimestamp(
+        now(),
+        "current time"
+      );
+      const schedule = normalizeSchedule(
+        scheduleOptions
+      );
+      const id = normalizeIdentifier(
+        scheduleOptions.id ?? idFactory(),
+        "schedule id"
+      );
+      const startAt = scheduleOptions.startAt === void 0 ? void 0 : normalizeTimestamp(
+        scheduleOptions.startAt instanceof Date ? scheduleOptions.startAt.getTime() : scheduleOptions.startAt,
+        "startAt"
+      );
+      const maxAttempts = scheduleOptions.maxAttempts === void 0 ? void 0 : normalizePositiveInteger2(
+        scheduleOptions.maxAttempts,
+        "maxAttempts"
+      );
+      const nextRunAt = startAt ?? nextScheduleTime(
+        schedule,
+        currentTime
+      );
+      const record = {
+        id,
+        jobName: normalizeIdentifier(
+          jobName,
+          "job name"
+        ),
+        payload,
+        schedule,
+        createdAt: currentTime,
+        updatedAt: currentTime,
+        nextRunAt,
+        maxAttempts
+      };
+      await store.upsert(
+        record
+      );
+      return cloneSchedule(
+        record
+      );
+    },
+    get(id) {
+      return store.get(
+        normalizeIdentifier(
+          id,
+          "schedule id"
+        )
+      );
+    },
+    list() {
+      return store.list();
+    },
+    remove(id) {
+      return store.remove(
+        normalizeIdentifier(
+          id,
+          "schedule id"
+        )
+      );
+    },
+    async runDue(runOptions = {}) {
+      const currentTime = normalizeTimestamp(
+        now(),
+        "current time"
+      );
+      const limit = normalizePositiveInteger2(
+        runOptions.limit ?? 100,
+        "limit"
+      );
+      const leaseMs = normalizePositiveInteger2(
+        runOptions.leaseMs ?? 3e4,
+        "leaseMs"
+      );
+      const schedules = await store.acquireDue(
+        currentTime,
+        {
+          ownerId,
+          leaseMs,
+          limit
+        }
+      );
+      let enqueued = 0;
+      for (const scheduleRecord of schedules) {
+        const scheduledFor = scheduleRecord.nextRunAt;
+        const runId = createScheduledRunId(
+          scheduleRecord.id,
+          scheduledFor
+        );
+        try {
+          await queue.enqueue(
+            scheduleRecord.jobName,
+            scheduleRecord.payload,
+            {
+              id: runId,
+              maxAttempts: scheduleRecord.maxAttempts
+            }
+          );
+          enqueued += 1;
+        } catch (error) {
+          if (!isDuplicateJobIdError(
+            error
+          )) {
+            await store.release(
+              scheduleRecord.id,
+              ownerId
+            );
+            throw error;
+          }
+        }
+        const nextRunAt = nextScheduleTime(
+          scheduleRecord.schedule,
+          scheduledFor
+        );
+        await store.complete(
+          scheduleRecord.id,
+          {
+            ownerId,
+            lastRunAt: scheduledFor,
+            nextRunAt,
+            updatedAt: currentTime
+          }
+        );
+      }
+      return enqueued;
+    },
+    start(startOptions = {}) {
+      const runner = createSchedulerRunner(
+        scheduler,
+        startOptions,
+        () => runners.delete(
+          runner
+        )
+      );
+      runners.add(runner);
+      return runner;
+    },
+    async close() {
+      await Promise.all(
+        Array.from(
+          runners,
+          (runner) => runner.stop()
+        )
+      );
+      if (store.close) {
+        await store.close();
+      }
+    }
+  };
+  return scheduler;
+}
+function nextScheduleTime(schedule, after) {
+  const timestamp = normalizeTimestamp(
+    after,
+    "schedule reference time"
+  );
+  if (schedule.kind === "interval") {
+    return timestamp + normalizePositiveInteger2(
+      schedule.everyMs,
+      "everyMs"
+    );
+  }
+  return nextCronTime(
+    schedule.expression,
+    timestamp
+  );
+}
+function nextCronTime(expression, after) {
+  const cron = parseCronExpression(
+    expression
+  );
+  const afterTimestamp = normalizeTimestamp(
+    after,
+    "cron reference time"
+  );
+  const minute = 6e4;
+  let candidate = Math.floor(
+    afterTimestamp / minute
+  ) * minute + minute;
+  const maxIterations = 366 * 24 * 60 * 8;
+  for (let iteration = 0; iteration < maxIterations; iteration += 1) {
+    const date = new Date(candidate);
+    if (cron.month.has(
+      date.getUTCMonth() + 1
+    ) && cron.hour.has(
+      date.getUTCHours()
+    ) && cron.minute.has(
+      date.getUTCMinutes()
+    ) && matchesCronDay(
+      cron,
+      date
+    )) {
+      return candidate;
+    }
+    candidate += minute;
+  }
+  throw new RangeError(
+    `BCP Jobs: cron expression "${expression}" did not produce a run time within 8 years.`
+  );
+}
+function createSchedulerRunner(scheduler, options, onStop) {
+  const pollIntervalMs = normalizePositiveInteger2(
+    options.pollIntervalMs ?? 1e3,
+    "pollIntervalMs"
+  );
+  const runOptions = {
+    limit: options.limit,
+    leaseMs: options.leaseMs
+  };
+  const controller = new AbortController();
+  let running = true;
+  let stopPromise = null;
+  const loop = runSchedulerLoop(
+    scheduler,
+    controller.signal,
+    pollIntervalMs,
+    runOptions,
+    options.onError
+  );
+  return {
+    get running() {
+      return running;
+    },
+    stop() {
+      if (stopPromise) {
+        return stopPromise;
+      }
+      running = false;
+      controller.abort();
+      stopPromise = loop.finally(
+        onStop
+      );
+      return stopPromise;
+    }
+  };
+}
+async function runSchedulerLoop(scheduler, signal, pollIntervalMs, runOptions, onError) {
+  while (!signal.aborted) {
+    try {
+      await scheduler.runDue(
+        runOptions
+      );
+    } catch (error) {
+      if (onError) {
+        await onError(error);
+      }
+    }
+    if (!signal.aborted) {
+      await sleep2(
+        pollIntervalMs,
+        signal
+      );
+    }
+  }
+}
+function normalizeSchedule(options) {
+  if (!options) {
+    throw new TypeError(
+      "BCP Jobs: schedule options are required."
+    );
+  }
+  const hasInterval = options.everyMs !== void 0;
+  const hasCron = options.cron !== void 0;
+  if (hasInterval === hasCron) {
+    throw new TypeError(
+      "BCP Jobs: schedule requires exactly one of everyMs or cron."
+    );
+  }
+  if (hasInterval) {
+    return {
+      kind: "interval",
+      everyMs: normalizePositiveInteger2(
+        options.everyMs,
+        "everyMs"
+      )
+    };
+  }
+  const expression = String(options.cron).trim();
+  parseCronExpression(
+    expression
+  );
+  return {
+    kind: "cron",
+    expression
+  };
+}
+function parseCronExpression(expression) {
+  const parts = String(expression).trim().split(/\s+/);
+  if (parts.length !== 5) {
+    throw new TypeError(
+      "BCP Jobs: cron must contain 5 fields: minute hour day-of-month month day-of-week."
+    );
+  }
+  return {
+    minute: parseCronField(
+      parts[0],
+      0,
+      59,
+      "minute"
+    ).values,
+    hour: parseCronField(
+      parts[1],
+      0,
+      23,
+      "hour"
+    ).values,
+    dayOfMonth: parseCronField(
+      parts[2],
+      1,
+      31,
+      "day-of-month"
+    ).values,
+    month: parseCronField(
+      parts[3],
+      1,
+      12,
+      "month"
+    ).values,
+    dayOfWeek: parseCronField(
+      parts[4],
+      0,
+      7,
+      "day-of-week",
+      true
+    ).values,
+    dayOfMonthWildcard: parts[2] === "*",
+    dayOfWeekWildcard: parts[4] === "*"
+  };
+}
+function parseCronField(source, minimum, maximum, field, normalizeSunday = false) {
+  const values = /* @__PURE__ */ new Set();
+  for (const segment of source.split(",")) {
+    const [base, stepSource] = segment.split("/");
+    if (segment.split("/").length > 2) {
+      throwCronField(
+        field,
+        source
+      );
+    }
+    const step = stepSource === void 0 ? 1 : parseCronInteger(
+      stepSource,
+      1,
+      maximum - minimum + 1,
+      field,
+      source
+    );
+    let rangeStart;
+    let rangeEnd;
+    if (base === "*") {
+      rangeStart = minimum;
+      rangeEnd = maximum;
+    } else if (base.includes("-")) {
+      const bounds = base.split("-");
+      if (bounds.length !== 2) {
+        throwCronField(
+          field,
+          source
+        );
+      }
+      rangeStart = parseCronInteger(
+        bounds[0],
+        minimum,
+        maximum,
+        field,
+        source
+      );
+      rangeEnd = parseCronInteger(
+        bounds[1],
+        minimum,
+        maximum,
+        field,
+        source
+      );
+      if (rangeEnd < rangeStart) {
+        throwCronField(
+          field,
+          source
+        );
+      }
+    } else {
+      rangeStart = parseCronInteger(
+        base,
+        minimum,
+        maximum,
+        field,
+        source
+      );
+      rangeEnd = rangeStart;
+    }
+    for (let value = rangeStart; value <= rangeEnd; value += step) {
+      values.add(
+        normalizeSunday && value === 7 ? 0 : value
+      );
+    }
+  }
+  if (values.size === 0) {
+    throwCronField(
+      field,
+      source
+    );
+  }
+  return {
+    values
+  };
+}
+function parseCronInteger(source, minimum, maximum, field, fullSource) {
+  if (!/^\d+$/.test(source)) {
+    throwCronField(
+      field,
+      fullSource
+    );
+  }
+  const value = Number(source);
+  if (!Number.isInteger(value) || value < minimum || value > maximum) {
+    throwCronField(
+      field,
+      fullSource
+    );
+  }
+  return value;
+}
+function throwCronField(field, source) {
+  throw new TypeError(
+    `BCP Jobs: invalid cron ${field} field "${source}".`
+  );
+}
+function matchesCronDay(cron, date) {
+  const dayOfMonthMatches = cron.dayOfMonth.has(
+    date.getUTCDate()
+  );
+  const dayOfWeekMatches = cron.dayOfWeek.has(
+    date.getUTCDay()
+  );
+  if (cron.dayOfMonthWildcard && cron.dayOfWeekWildcard) {
+    return true;
+  }
+  if (cron.dayOfMonthWildcard) {
+    return dayOfWeekMatches;
+  }
+  if (cron.dayOfWeekWildcard) {
+    return dayOfMonthMatches;
+  }
+  return dayOfMonthMatches || dayOfWeekMatches;
+}
+function createScheduledRunId(scheduleId, scheduledFor) {
+  return `schedule:${scheduleId}:${scheduledFor}`;
+}
+function isDuplicateJobIdError(error) {
+  return error instanceof Error && /job id .* already exists/i.test(
+    error.message
+  );
+}
+function normalizeIdentifier(value, field) {
+  const normalized = String(value).trim();
+  if (!normalized) {
+    throw new TypeError(
+      `BCP Jobs: ${field} must be a non-empty string.`
+    );
+  }
+  if (normalized.length > 200) {
+    throw new TypeError(
+      `BCP Jobs: ${field} must not exceed 200 characters.`
+    );
+  }
+  return normalized;
+}
+function normalizeTimestamp(value, field) {
+  if (!Number.isFinite(value) || value < 0) {
+    throw new TypeError(
+      `BCP Jobs: ${field} must be a non-negative finite timestamp.`
+    );
+  }
+  return Math.floor(value);
+}
+function normalizePositiveInteger2(value, field) {
+  if (!Number.isInteger(value) || value <= 0) {
+    throw new TypeError(
+      `BCP Jobs: ${field} must be a positive integer.`
+    );
+  }
+  return value;
+}
+function sleep2(durationMs, signal) {
+  if (signal.aborted) {
+    return Promise.resolve();
+  }
+  return new Promise(
+    (resolve) => {
+      const timeout = setTimeout(
+        finish,
+        durationMs
+      );
+      const onAbort = () => finish();
+      signal.addEventListener(
+        "abort",
+        onAbort,
+        {
+          once: true
+        }
+      );
+      function finish() {
+        clearTimeout(timeout);
+        signal.removeEventListener(
+          "abort",
+          onAbort
+        );
+        resolve();
+      }
+    }
+  );
+}
+function cloneSchedule(schedule) {
+  return {
+    ...schedule,
+    schedule: {
+      ...schedule.schedule
+    }
+  };
+}
+export {
+  createJobQueue,
+  createJobScheduler,
+  createMemoryJobQueueAdapter,
+  createMemoryJobScheduleStore,
+  nextCronTime,
+  nextScheduleTime
+};