@batchactions/state-sequelize 0.0.1

package/dist/index.cjs

@@ -0,0 +1,651 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  SequelizeStateStore: () => SequelizeStateStore
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/models/JobModel.ts
+var import_sequelize = require("sequelize");
+function defineJobModel(sequelize) {
+  return sequelize.define(
+    "BatchActionsJob",
+    {
+      id: {
+        type: import_sequelize.DataTypes.STRING(36),
+        primaryKey: true,
+        allowNull: false
+      },
+      status: {
+        type: import_sequelize.DataTypes.STRING(20),
+        allowNull: false
+      },
+      config: {
+        type: import_sequelize.DataTypes.JSON,
+        allowNull: false
+      },
+      batches: {
+        type: import_sequelize.DataTypes.JSON,
+        allowNull: false,
+        defaultValue: []
+      },
+      totalRecords: {
+        type: import_sequelize.DataTypes.INTEGER,
+        allowNull: false,
+        defaultValue: 0
+      },
+      startedAt: {
+        type: import_sequelize.DataTypes.BIGINT,
+        allowNull: true
+      },
+      completedAt: {
+        type: import_sequelize.DataTypes.BIGINT,
+        allowNull: true
+      },
+      distributed: {
+        type: import_sequelize.DataTypes.BOOLEAN,
+        allowNull: false,
+        defaultValue: false
+      }
+    },
+    {
+      tableName: "bulkimport_jobs",
+      timestamps: false
+    }
+  );
+}
+
+// src/models/RecordModel.ts
+var import_sequelize2 = require("sequelize");
+function defineRecordModel(sequelize) {
+  return sequelize.define(
+    "BatchActionsRecord",
+    {
+      id: {
+        type: import_sequelize2.DataTypes.INTEGER,
+        primaryKey: true,
+        autoIncrement: true
+      },
+      jobId: {
+        type: import_sequelize2.DataTypes.STRING(36),
+        allowNull: false
+      },
+      batchId: {
+        type: import_sequelize2.DataTypes.STRING(36),
+        allowNull: false
+      },
+      recordIndex: {
+        type: import_sequelize2.DataTypes.INTEGER,
+        allowNull: false
+      },
+      status: {
+        type: import_sequelize2.DataTypes.STRING(10),
+        allowNull: false
+      },
+      raw: {
+        type: import_sequelize2.DataTypes.JSON,
+        allowNull: false
+      },
+      parsed: {
+        type: import_sequelize2.DataTypes.JSON,
+        allowNull: false
+      },
+      errors: {
+        type: import_sequelize2.DataTypes.JSON,
+        allowNull: false,
+        defaultValue: []
+      },
+      processingError: {
+        type: import_sequelize2.DataTypes.TEXT,
+        allowNull: true
+      }
+    },
+    {
+      tableName: "bulkimport_records",
+      timestamps: false,
+      indexes: [
+        { fields: ["jobId", "status"] },
+        { fields: ["jobId", "batchId"] },
+        { unique: true, fields: ["jobId", "recordIndex"] }
+      ]
+    }
+  );
+}
+
+// src/models/BatchModel.ts
+var import_sequelize3 = require("sequelize");
+function defineBatchModel(sequelize) {
+  return sequelize.define(
+    "BatchActionsBatch",
+    {
+      id: {
+        type: import_sequelize3.DataTypes.STRING(36),
+        primaryKey: true,
+        allowNull: false
+      },
+      jobId: {
+        type: import_sequelize3.DataTypes.STRING(36),
+        allowNull: false
+      },
+      batchIndex: {
+        type: import_sequelize3.DataTypes.INTEGER,
+        allowNull: false
+      },
+      status: {
+        type: import_sequelize3.DataTypes.STRING(20),
+        allowNull: false,
+        defaultValue: "PENDING"
+      },
+      workerId: {
+        type: import_sequelize3.DataTypes.STRING(128),
+        allowNull: true
+      },
+      claimedAt: {
+        type: import_sequelize3.DataTypes.BIGINT,
+        allowNull: true
+      },
+      recordStartIndex: {
+        type: import_sequelize3.DataTypes.INTEGER,
+        allowNull: false,
+        defaultValue: 0
+      },
+      recordEndIndex: {
+        type: import_sequelize3.DataTypes.INTEGER,
+        allowNull: false,
+        defaultValue: 0
+      },
+      processedCount: {
+        type: import_sequelize3.DataTypes.INTEGER,
+        allowNull: false,
+        defaultValue: 0
+      },
+      failedCount: {
+        type: import_sequelize3.DataTypes.INTEGER,
+        allowNull: false,
+        defaultValue: 0
+      },
+      version: {
+        type: import_sequelize3.DataTypes.INTEGER,
+        allowNull: false,
+        defaultValue: 0
+      }
+    },
+    {
+      tableName: "bulkimport_batches",
+      timestamps: false,
+      indexes: [{ fields: ["jobId", "status"] }, { unique: true, fields: ["jobId", "batchIndex"] }]
+    }
+  );
+}
+
+// src/utils/parseJson.ts
+function parseJson(value) {
+  if (typeof value === "string") {
+    return JSON.parse(value);
+  }
+  return value;
+}
+
+// src/mappers/JobMapper.ts
+function stripNonSerializableFields(config) {
+  if (!config.schema) return config;
+  const schema = config.schema;
+  if (!schema.fields || !Array.isArray(schema.fields)) return config;
+  const rawFields = schema.fields;
+  const fields = rawFields.map((f) => {
+    const name = typeof f["name"] === "string" ? f["name"] : "";
+    const type = typeof f["type"] === "string" ? f["type"] : "";
+    const required = typeof f["required"] === "boolean" ? f["required"] : false;
+    const result = { name, type, required };
+    if (f["defaultValue"] !== void 0) result["defaultValue"] = f["defaultValue"];
+    if (f["separator"] !== void 0) result["separator"] = f["separator"];
+    if (f["aliases"] !== void 0) result["aliases"] = f["aliases"];
+    return result;
+  });
+  return {
+    ...config,
+    schema: {
+      ...config.schema,
+      fields
+    }
+  };
+}
+function toRow(state) {
+  return {
+    id: state.id,
+    status: state.status,
+    config: stripNonSerializableFields(state.config),
+    batches: state.batches.map((b) => ({
+      id: b.id,
+      index: b.index,
+      status: b.status,
+      records: [],
+      processedCount: b.processedCount,
+      failedCount: b.failedCount
+    })),
+    totalRecords: state.totalRecords,
+    startedAt: state.startedAt ?? null,
+    completedAt: state.completedAt ?? null,
+    distributed: state.distributed ?? false
+  };
+}
+function toDomain(row) {
+  const config = parseJson(row.config);
+  const batches = parseJson(row.batches);
+  const base = {
+    id: row.id,
+    config,
+    status: row.status,
+    batches,
+    totalRecords: row.totalRecords
+  };
+  const result = { ...base };
+  if (row.startedAt !== null) {
+    result["startedAt"] = Number(row.startedAt);
+  }
+  if (row.completedAt !== null) {
+    result["completedAt"] = Number(row.completedAt);
+  }
+  if (row.distributed) {
+    result["distributed"] = true;
+  }
+  return result;
+}
+
+// src/mappers/RecordMapper.ts
+function toRow2(jobId, batchId, record) {
+  return {
+    jobId,
+    batchId,
+    recordIndex: record.index,
+    status: record.status,
+    raw: record.raw,
+    parsed: record.parsed,
+    errors: record.errors,
+    processingError: record.processingError ?? null
+  };
+}
+function toDomain2(row) {
+  const result = {
+    index: row.recordIndex,
+    raw: parseJson(row.raw),
+    parsed: parseJson(row.parsed),
+    status: row.status,
+    errors: parseJson(row.errors)
+  };
+  if (row.processingError !== null) {
+    return { ...result, processingError: row.processingError };
+  }
+  return result;
+}
+
+// src/SequelizeStateStore.ts
+var SequelizeStateStore = class {
+  constructor(sequelize, _options) {
+    this.sequelize = sequelize;
+    this.Job = defineJobModel(this.sequelize);
+    this.Record = defineRecordModel(this.sequelize);
+    this.Batch = defineBatchModel(this.sequelize);
+  }
+  async initialize() {
+    await this.Job.sync();
+    await this.Record.sync();
+    await this.Batch.sync();
+  }
+  // ── StateStore methods ──────────────────────────────────────────────
+  async saveJobState(job) {
+    const row = toRow(job);
+    await this.Job.upsert(row);
+  }
+  async getJobState(jobId) {
+    const row = await this.Job.findByPk(jobId);
+    if (!row) return null;
+    return toDomain(row.get({ plain: true }));
+  }
+  async updateBatchState(jobId, batchId, state) {
+    const row = await this.Job.findByPk(jobId);
+    if (!row) return;
+    const plain = row.get({ plain: true });
+    const batches = parseJson(plain.batches);
+    const updated = batches.map(
+      (b) => b.id === batchId ? { ...b, status: state.status, processedCount: state.processedCount, failedCount: state.failedCount } : b
+    );
+    await row.update({ batches: updated });
+    const batchRow = await this.Batch.findByPk(batchId);
+    if (batchRow) {
+      await batchRow.update({
+        status: state.status,
+        processedCount: state.processedCount,
+        failedCount: state.failedCount
+      });
+    }
+  }
+  async saveProcessedRecord(jobId, batchId, record) {
+    const row = toRow2(jobId, batchId, record);
+    const existing = await this.Record.findOne({
+      where: { jobId, recordIndex: record.index }
+    });
+    if (existing) {
+      await existing.update(row);
+    } else {
+      await this.Record.create(row);
+    }
+  }
+  async getFailedRecords(jobId) {
+    const { Op } = await import("sequelize");
+    const rows = await this.Record.findAll({
+      where: { jobId, status: { [Op.in]: ["failed", "invalid"] } },
+      order: [["recordIndex", "ASC"]]
+    });
+    return rows.map((r) => toDomain2(r.get({ plain: true })));
+  }
+  async getPendingRecords(jobId) {
+    const { Op } = await import("sequelize");
+    const rows = await this.Record.findAll({
+      where: { jobId, status: { [Op.in]: ["pending", "valid"] } },
+      order: [["recordIndex", "ASC"]]
+    });
+    return rows.map((r) => toDomain2(r.get({ plain: true })));
+  }
+  async getProcessedRecords(jobId) {
+    const rows = await this.Record.findAll({
+      where: { jobId, status: "processed" },
+      order: [["recordIndex", "ASC"]]
+    });
+    return rows.map((r) => toDomain2(r.get({ plain: true })));
+  }
+  async getProgress(jobId) {
+    const jobRow = await this.Job.findByPk(jobId);
+    const plain = jobRow ? jobRow.get({ plain: true }) : null;
+    const { fn, col } = await import("sequelize");
+    const counts = await this.Record.findAll({
+      attributes: ["status", [fn("COUNT", col("status")), "count"]],
+      where: { jobId },
+      group: ["status"],
+      raw: true
+    });
+    const countMap = /* @__PURE__ */ new Map();
+    for (const row of counts) {
+      countMap.set(row.status, parseInt(row.count, 10));
+    }
+    const processed = countMap.get("processed") ?? 0;
+    const failed = (countMap.get("failed") ?? 0) + (countMap.get("invalid") ?? 0);
+    const totalRecords = plain?.totalRecords ?? 0;
+    const pending = Math.max(0, totalRecords - processed - failed);
+    const completed = processed + failed;
+    const batches = plain ? parseJson(plain.batches) : [];
+    const completedBatches = batches.filter((b) => b.status === "COMPLETED").length;
+    const elapsed = plain?.startedAt ? Date.now() - Number(plain.startedAt) : 0;
+    return {
+      totalRecords,
+      processedRecords: processed,
+      failedRecords: failed,
+      pendingRecords: pending,
+      percentage: totalRecords > 0 ? Math.round(completed / totalRecords * 100) : 0,
+      currentBatch: completedBatches,
+      totalBatches: batches.length,
+      elapsedMs: elapsed
+    };
+  }
+  // ── DistributedStateStore methods ───────────────────────────────────
+  async claimBatch(jobId, workerId) {
+    const jobRow = await this.Job.findByPk(jobId);
+    if (!jobRow) {
+      return { claimed: false, reason: "JOB_NOT_FOUND" };
+    }
+    const plain = jobRow.get({ plain: true });
+    if (plain.status !== "PROCESSING") {
+      return { claimed: false, reason: "JOB_NOT_PROCESSING" };
+    }
+    return await this.sequelize.transaction(async (transaction) => {
+      const pendingBatch = await this.Batch.findOne({
+        where: { jobId, status: "PENDING" },
+        order: [["batchIndex", "ASC"]],
+        transaction,
+        lock: true
+      });
+      if (!pendingBatch) {
+        return { claimed: false, reason: "NO_PENDING_BATCHES" };
+      }
+      const batchPlain = pendingBatch.get({ plain: true });
+      const now = Date.now();
+      const [affectedRows] = await this.Batch.update(
+        {
+          status: "PROCESSING",
+          workerId,
+          claimedAt: now,
+          version: batchPlain.version + 1
+        },
+        {
+          where: {
+            id: batchPlain.id,
+            version: batchPlain.version
+          },
+          transaction
+        }
+      );
+      if (affectedRows === 0) {
+        return { claimed: false, reason: "NO_PENDING_BATCHES" };
+      }
+      const jobBatches = parseJson(plain.batches);
+      const updatedBatches = jobBatches.map((b) => b.id === batchPlain.id ? { ...b, status: "PROCESSING" } : b);
+      await jobRow.update({ batches: updatedBatches }, { transaction });
+      return {
+        claimed: true,
+        reservation: {
+          jobId,
+          batchId: batchPlain.id,
+          batchIndex: batchPlain.batchIndex,
+          workerId,
+          claimedAt: now,
+          recordStartIndex: batchPlain.recordStartIndex,
+          recordEndIndex: batchPlain.recordEndIndex
+        }
+      };
+    });
+  }
+  async releaseBatch(jobId, batchId, workerId) {
+    await this.sequelize.transaction(async (transaction) => {
+      const batch = await this.Batch.findOne({
+        where: { id: batchId, jobId, workerId },
+        transaction,
+        lock: true
+      });
+      if (!batch) return;
+      const batchPlain = batch.get({ plain: true });
+      await this.Batch.update(
+        {
+          status: "PENDING",
+          workerId: null,
+          claimedAt: null,
+          version: batchPlain.version + 1
+        },
+        {
+          where: { id: batchId, version: batchPlain.version },
+          transaction
+        }
+      );
+      const jobRow = await this.Job.findByPk(jobId, { transaction });
+      if (jobRow) {
+        const plain = jobRow.get({ plain: true });
+        const jobBatches = parseJson(plain.batches);
+        const updatedBatches = jobBatches.map((b) => b.id === batchId ? { ...b, status: "PENDING" } : b);
+        await jobRow.update({ batches: updatedBatches }, { transaction });
+      }
+    });
+  }
+  async reclaimStaleBatches(jobId, timeoutMs) {
+    const cutoff = Date.now() - timeoutMs;
+    const { Op } = await import("sequelize");
+    return await this.sequelize.transaction(async (transaction) => {
+      const staleBatches = await this.Batch.findAll({
+        where: {
+          jobId,
+          status: "PROCESSING",
+          claimedAt: { [Op.lt]: cutoff }
+        },
+        transaction,
+        lock: true
+      });
+      if (staleBatches.length === 0) return 0;
+      let reclaimed = 0;
+      for (const batch of staleBatches) {
+        const batchPlain = batch.get({ plain: true });
+        const [affected] = await this.Batch.update(
+          {
+            status: "PENDING",
+            workerId: null,
+            claimedAt: null,
+            version: batchPlain.version + 1
+          },
+          {
+            where: { id: batchPlain.id, version: batchPlain.version },
+            transaction
+          }
+        );
+        reclaimed += affected;
+      }
+      if (reclaimed > 0) {
+        const reclaimedIds = new Set(staleBatches.map((b) => b.get({ plain: true }).id));
+        const jobRow = await this.Job.findByPk(jobId, { transaction });
+        if (jobRow) {
+          const plain = jobRow.get({ plain: true });
+          const jobBatches = parseJson(plain.batches);
+          const updatedBatches = jobBatches.map((b) => reclaimedIds.has(b.id) ? { ...b, status: "PENDING" } : b);
+          await jobRow.update({ batches: updatedBatches }, { transaction });
+        }
+      }
+      return reclaimed;
+    });
+  }
+  async saveBatchRecords(jobId, batchId, records) {
+    const rows = records.map((r) => toRow2(jobId, batchId, r));
+    await this.Record.bulkCreate(rows);
+  }
+  async getBatchRecords(jobId, batchId) {
+    const rows = await this.Record.findAll({
+      where: { jobId, batchId },
+      order: [["recordIndex", "ASC"]]
+    });
+    return rows.map((r) => toDomain2(r.get({ plain: true })));
+  }
+  async getDistributedStatus(jobId) {
+    const { fn, col } = await import("sequelize");
+    const counts = await this.Batch.findAll({
+      attributes: ["status", [fn("COUNT", col("status")), "count"]],
+      where: { jobId },
+      group: ["status"],
+      raw: true
+    });
+    const countMap = /* @__PURE__ */ new Map();
+    let total = 0;
+    for (const row of counts) {
+      const count = parseInt(row.count, 10);
+      countMap.set(row.status, count);
+      total += count;
+    }
+    const completed = countMap.get("COMPLETED") ?? 0;
+    const failed = countMap.get("FAILED") ?? 0;
+    const processing = countMap.get("PROCESSING") ?? 0;
+    const pending = countMap.get("PENDING") ?? 0;
+    return {
+      jobId,
+      totalBatches: total,
+      completedBatches: completed,
+      failedBatches: failed,
+      processingBatches: processing,
+      pendingBatches: pending,
+      isComplete: total > 0 && pending === 0 && processing === 0
+    };
+  }
+  async tryFinalizeJob(jobId) {
+    return await this.sequelize.transaction(async (transaction) => {
+      const jobRow = await this.Job.findByPk(jobId, { transaction, lock: true });
+      if (!jobRow) return false;
+      const plain = jobRow.get({ plain: true });
+      if (plain.status !== "PROCESSING") return false;
+      const status = await this.getDistributedStatusInTransaction(jobId, transaction);
+      if (!status.isComplete) return false;
+      const finalStatus = status.failedBatches > 0 ? "FAILED" : "COMPLETED";
+      const [affectedRows] = await this.Job.update(
+        {
+          status: finalStatus,
+          completedAt: Date.now()
+        },
+        {
+          where: { id: jobId, status: "PROCESSING" },
+          transaction
+        }
+      );
+      return affectedRows > 0;
+    });
+  }
+  /**
+   * Internal helper to get distributed status within an existing transaction.
+   * Avoids creating a nested transaction in tryFinalizeJob.
+   */
+  async getDistributedStatusInTransaction(jobId, transaction) {
+    const { fn, col } = await import("sequelize");
+    const counts = await this.Batch.findAll({
+      attributes: ["status", [fn("COUNT", col("status")), "count"]],
+      where: { jobId },
+      group: ["status"],
+      raw: true,
+      transaction
+    });
+    const countMap = /* @__PURE__ */ new Map();
+    let total = 0;
+    for (const row of counts) {
+      const count = parseInt(row.count, 10);
+      countMap.set(row.status, count);
+      total += count;
+    }
+    const completed = countMap.get("COMPLETED") ?? 0;
+    const failed = countMap.get("FAILED") ?? 0;
+    const processing = countMap.get("PROCESSING") ?? 0;
+    const pending = countMap.get("PENDING") ?? 0;
+    return {
+      jobId,
+      totalBatches: total,
+      completedBatches: completed,
+      failedBatches: failed,
+      processingBatches: processing,
+      pendingBatches: pending,
+      isComplete: total > 0 && pending === 0 && processing === 0
+    };
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SequelizeStateStore
+});
+//# sourceMappingURL=index.cjs.map