strapi-plugin-bulk-updater 1.0.0

package/dist/server/index.mjs

@@ -0,0 +1,1751 @@
+import crypto from "crypto";
+const routes = {
+  admin: {
+    type: "admin",
+    routes: [
+      {
+        method: "GET",
+        path: "/models",
+        handler: "bulkUpdater.getModels",
+        config: {
+          policies: []
+        }
+      },
+      {
+        method: "GET",
+        path: "/collections/:uid/entries",
+        handler: "bulkUpdater.getCollectionEntries",
+        config: {
+          policies: []
+        }
+      },
+      {
+        method: "GET",
+        path: "/relation-options",
+        handler: "bulkUpdater.getRelationOptions",
+        config: {
+          policies: []
+        }
+      },
+      {
+        method: "POST",
+        path: "/batch-update",
+        handler: "bulkUpdater.batchUpdate",
+        config: {
+          policies: []
+        }
+      },
+      {
+        method: "GET",
+        path: "/pending-batches",
+        handler: "bulkUpdater.getPendingBatches",
+        config: {
+          policies: []
+        }
+      },
+      {
+        method: "POST",
+        path: "/batches/:batchId/approve",
+        handler: "bulkUpdater.approveBatch",
+        config: {
+          policies: []
+        }
+      },
+      {
+        method: "POST",
+        path: "/batches/:batchId/reject",
+        handler: "bulkUpdater.rejectBatch",
+        config: {
+          policies: []
+        }
+      },
+      {
+        method: "POST",
+        path: "/batches/:batchId/execute-now",
+        handler: "bulkUpdater.executeNow",
+        config: {
+          policies: []
+        }
+      },
+      {
+        method: "GET",
+        path: "/license",
+        handler: "license.getStatus",
+        config: {
+          policies: []
+        }
+      },
+      {
+        method: "POST",
+        path: "/license/verify",
+        handler: "license.verify",
+        config: {
+          policies: []
+        }
+      },
+      {
+        method: "POST",
+        path: "/license/deactivate",
+        handler: "license.deactivate",
+        config: {
+          policies: []
+        }
+      },
+      {
+        method: "GET",
+        path: "/audit/history",
+        handler: "audit.getHistory",
+        config: {
+          policies: []
+        }
+      },
+      {
+        method: "POST",
+        path: "/audit/:batchId/rollback",
+        handler: "audit.rollback",
+        config: {
+          policies: []
+        }
+      }
+    ]
+  }
+};
+const bulkUpdaterController = ({ strapi }) => ({
+  async getModels(ctx) {
+    try {
+      const service = strapi.plugin("bulk-updater").service("bulkUpdater");
+      const data = await service.getModels();
+      if (data?.etag) {
+        ctx.set("ETag", data.etag);
+        ctx.set("Cache-Control", "private, no-cache");
+        if (ctx.request.headers["if-none-match"] === data.etag) {
+          ctx.status = 304;
+          return;
+        }
+      }
+      ctx.body = data;
+    } catch (err) {
+      ctx.status = 500;
+      ctx.body = { success: false, error: err.message };
+    }
+  },
+  async getCollectionEntries(ctx) {
+    try {
+      const { uid } = ctx.params;
+      const { page, pageSize, attribute, filterOperator, filterQuery, search, sortField, sortOrder } = ctx.query;
+      const service = strapi.plugin("bulk-updater").service("bulkUpdater");
+      const data = await service.getCollectionEntries(uid, {
+        page: page ? Number(page) : 1,
+        pageSize: pageSize ? Number(pageSize) : 10,
+        attribute: attribute ? String(attribute) : void 0,
+        filterOperator: filterOperator ? String(filterOperator) : void 0,
+        filterQuery: filterQuery !== void 0 ? String(filterQuery) : void 0,
+        search: search ? String(search) : void 0,
+        sortField: sortField ? String(sortField) : void 0,
+        sortOrder: sortOrder === "asc" ? "asc" : "desc"
+      });
+      if (data?.etag) {
+        ctx.set("ETag", data.etag);
+        ctx.set("Cache-Control", "private, no-cache");
+        if (ctx.request.headers["if-none-match"] === data.etag) {
+          ctx.status = 304;
+          return;
+        }
+      }
+      ctx.body = data;
+    } catch (err) {
+      ctx.status = 500;
+      ctx.body = { success: false, error: err.message };
+    }
+  },
+  async getRelationOptions(ctx) {
+    try {
+      const { targetUid } = ctx.query;
+      if (!targetUid) {
+        ctx.status = 400;
+        ctx.body = { success: false, error: "targetUid is required" };
+        return;
+      }
+      const service = strapi.plugin("bulk-updater").service("bulkUpdater");
+      const data = await service.getRelationOptions(String(targetUid));
+      ctx.body = { success: true, ...data };
+    } catch (err) {
+      ctx.status = 500;
+      ctx.body = { success: false, error: err.message };
+    }
+  },
+  async batchUpdate(ctx) {
+    try {
+      const service = strapi.plugin("bulk-updater").service("bulkUpdater");
+      const currentUser = ctx.state.user;
+      const result = await service.batchUpdate(ctx.request.body || {}, currentUser);
+      ctx.body = result;
+    } catch (err) {
+      ctx.status = 400;
+      ctx.body = { success: false, error: err.message };
+    }
+  },
+  async getPendingBatches(ctx) {
+    try {
+      const service = strapi.plugin("bulk-updater").service("bulkUpdater");
+      const result = await service.getPendingBatches();
+      ctx.body = result;
+    } catch (err) {
+      ctx.status = 500;
+      ctx.body = { success: false, error: err.message };
+    }
+  },
+  async approveBatch(ctx) {
+    try {
+      const { batchId } = ctx.params;
+      const { executeImmediately = true } = ctx.request.body || {};
+      const service = strapi.plugin("bulk-updater").service("bulkUpdater");
+      const currentUser = ctx.state.user;
+      const result = await service.approveBatch(batchId, currentUser, { executeImmediately });
+      ctx.body = result;
+    } catch (err) {
+      ctx.status = 400;
+      ctx.body = { success: false, error: err.message };
+    }
+  },
+  async rejectBatch(ctx) {
+    try {
+      const { batchId } = ctx.params;
+      const { reason } = ctx.request.body || {};
+      const service = strapi.plugin("bulk-updater").service("bulkUpdater");
+      const currentUser = ctx.state.user;
+      const result = await service.rejectBatch(batchId, currentUser, reason);
+      ctx.body = result;
+    } catch (err) {
+      ctx.status = 400;
+      ctx.body = { success: false, error: err.message };
+    }
+  },
+  async executeNow(ctx) {
+    try {
+      const { batchId } = ctx.params;
+      const service = strapi.plugin("bulk-updater").service("bulkUpdater");
+      const currentUser = ctx.state.user;
+      const result = await service.executeNow(batchId, currentUser);
+      ctx.body = result;
+    } catch (err) {
+      ctx.status = 400;
+      ctx.body = { success: false, error: err.message };
+    }
+  }
+});
+const licenseController = ({ strapi }) => ({
+  async getStatus(ctx) {
+    try {
+      const service = strapi.plugin("bulk-updater").service("license");
+      const license = await service.getLicenseStatus();
+      ctx.body = { success: true, license };
+    } catch (err) {
+      ctx.status = 500;
+      ctx.body = { success: false, error: err.message };
+    }
+  },
+  async verify(ctx) {
+    try {
+      const { licenseKey } = ctx.request.body || {};
+      const service = strapi.plugin("bulk-updater").service("license");
+      const result = await service.verifyAndActivateLicense(licenseKey);
+      if (!result.success) {
+        ctx.status = 400;
+        ctx.body = result;
+        return;
+      }
+      ctx.body = result;
+    } catch (err) {
+      ctx.status = 500;
+      ctx.body = { success: false, error: err.message };
+    }
+  },
+  async deactivate(ctx) {
+    try {
+      const service = strapi.plugin("bulk-updater").service("license");
+      const license = await service.deactivateLicense();
+      ctx.body = { success: true, license };
+    } catch (err) {
+      ctx.status = 500;
+      ctx.body = { success: false, error: err.message };
+    }
+  }
+});
+const auditController = ({ strapi }) => ({
+  async getHistory(ctx) {
+    try {
+      const service = strapi.plugin("bulk-updater").service("audit");
+      const data = await service.getHistory();
+      ctx.body = data;
+    } catch (err) {
+      ctx.status = 500;
+      ctx.body = { success: false, error: err.message };
+    }
+  },
+  async rollback(ctx) {
+    try {
+      const { batchId } = ctx.params;
+      const service = strapi.plugin("bulk-updater").service("audit");
+      const currentUser = ctx.state.user;
+      const result = await service.rollbackBatch(batchId, currentUser);
+      ctx.body = result;
+    } catch (err) {
+      ctx.status = 400;
+      ctx.body = { success: false, error: err.message };
+    }
+  }
+});
+const queryCache = /* @__PURE__ */ new Map();
+const modelsCache = /* @__PURE__ */ new Map();
+const MAX_QUERY_CACHE_SIZE = 500;
+const CACHE_TTL_MS = 60 * 1e3;
+let staticSchemaCache = null;
+function getSafeTimezone(timeZone) {
+  if (!timeZone || typeof timeZone !== "string") {
+    return Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";
+  }
+  try {
+    Intl.DateTimeFormat(void 0, { timeZone: timeZone.trim() });
+    return timeZone.trim();
+  } catch {
+    return "UTC";
+  }
+}
+function getTimeInTimezone(timeZone, date = /* @__PURE__ */ new Date()) {
+  const safeTz = getSafeTimezone(timeZone);
+  const formatter = new Intl.DateTimeFormat("en-GB", {
+    timeZone: safeTz,
+    hour: "2-digit",
+    minute: "2-digit",
+    hourCycle: "h23"
+  });
+  const timeString = formatter.format(date);
+  const [h, m] = timeString.split(":").map(Number);
+  return { hours: h, minutes: m, timeString };
+}
+function getExecutionWindowConfig(strapi) {
+  const pluginConfig = strapi.config.get("plugin::bulk-updater.executionWindow");
+  const configuredTz = pluginConfig?.timeZone || strapi.config.get("server.timeZone") || Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";
+  const timeZone = getSafeTimezone(configuredTz);
+  return {
+    enabled: pluginConfig?.enabled ?? true,
+    timeZone,
+    businessHours: {
+      start: pluginConfig?.businessHours?.start || "09:00",
+      end: pluginConfig?.businessHours?.end || "18:00"
+    },
+    offPeakStartTime: pluginConfig?.offPeakStartTime || "18:00",
+    autoQueueDuringBusinessHours: pluginConfig?.autoQueueDuringBusinessHours ?? true
+  };
+}
+function checkBusinessHours(config, testDate) {
+  const timeZone = getSafeTimezone(config.timeZone);
+  const { hours, minutes, timeString } = getTimeInTimezone(timeZone, /* @__PURE__ */ new Date());
+  const currentMinutes = hours * 60 + minutes;
+  const [startH, startM] = (config.businessHours.start || "09:00").split(":").map(Number);
+  const [endH, endM] = (config.businessHours.end || "18:00").split(":").map(Number);
+  const startMinutes = startH * 60 + startM;
+  const endMinutes = endH * 60 + endM;
+  const isBusinessHours = currentMinutes >= startMinutes && currentMinutes < endMinutes;
+  return {
+    isBusinessHours,
+    currentServerTime: timeString,
+    timeZone,
+    businessHours: config.businessHours,
+    offPeakStartTime: config.offPeakStartTime,
+    policyMessage: isBusinessHours ? `Server policy restricts bulk updates during peak business hours (${config.businessHours.start} - ${config.businessHours.end} ${timeZone}). Current time: ${timeString} (${timeZone}). Updates will be queued for off-peak execution at ${config.offPeakStartTime} ${timeZone}.` : `Currently in off-peak execution window (outside ${config.businessHours.start} - ${config.businessHours.end} ${timeZone}). Current time: ${timeString} (${timeZone}). Direct execution is permitted.`
+  };
+}
+const pendingBatches = /* @__PURE__ */ new Map();
+let isRunnerRunning = false;
+let runnerInterval = null;
+function invalidateCollectionCache(uid) {
+  modelsCache.delete(uid);
+  for (const key of queryCache.keys()) {
+    if (key.startsWith(`${uid}:`)) {
+      queryCache.delete(key);
+    }
+  }
+}
+async function getCollectionSignature(strapi, uid) {
+  const contentType = strapi.contentTypes[uid];
+  if (!contentType) return "invalid";
+  const isSingleType = contentType.kind === "singleType";
+  try {
+    if (isSingleType) {
+      const doc = await strapi.documents(uid).findFirst({
+        fields: ["updatedAt", "id"]
+      });
+      return doc ? `single:${doc.id}:${doc.updatedAt}` : "single:empty";
+    }
+    const [total, latest] = await Promise.all([
+      strapi.documents(uid).count(),
+      strapi.documents(uid).findMany({
+        limit: 1,
+        sort: { updatedAt: "desc" },
+        fields: ["updatedAt", "id"]
+      })
+    ]);
+    const latestDoc = latest && latest.length > 0 ? latest[0] : null;
+    return `${total}:${latestDoc?.updatedAt || "0"}:${latestDoc?.id || "0"}`;
+  } catch {
+    return `${Date.now()}`;
+  }
+}
+async function computeTargetsSummary(strapi, { selectedCollections = [], selectedEntries = [] }) {
+  const targetsMap = /* @__PURE__ */ new Map();
+  const breakdown = {};
+  for (const colUid of selectedCollections) {
+    const contentType = strapi.contentTypes[colUid];
+    const displayName = contentType?.info?.displayName || colUid;
+    try {
+      const entries = await strapi.documents(colUid).findMany();
+      const count = entries ? entries.length : 0;
+      breakdown[displayName] = (breakdown[displayName] || 0) + count;
+      for (const entry of entries || []) {
+        targetsMap.set(`${colUid}@@@${entry.documentId}`, { uid: colUid, documentId: entry.documentId });
+      }
+    } catch {
+    }
+  }
+  for (const item of selectedEntries) {
+    if (!item.uid || !item.documentId) continue;
+    const key = `${item.uid}@@@${item.documentId}`;
+    if (!targetsMap.has(key)) {
+      targetsMap.set(key, { uid: item.uid, documentId: item.documentId });
+      const contentType = strapi.contentTypes[item.uid];
+      const displayName = contentType?.info?.displayName || item.uid;
+      breakdown[displayName] = (breakdown[displayName] || 0) + 1;
+    }
+  }
+  return {
+    totalTargets: targetsMap.size,
+    collectionBreakdown: breakdown
+  };
+}
+async function executeBatchInternal(strapi, {
+  attribute,
+  value,
+  selectedEntries = [],
+  selectedCollections = [],
+  isRegex = false,
+  regexPattern = "",
+  publishOnApproval = true
+}, currentUser, existingBatchId) {
+  if (!attribute) {
+    throw new Error("Attribute name is required.");
+  }
+  const licenseService2 = strapi.plugin("bulk-updater").service("license");
+  const license = await licenseService2.getLicenseStatus();
+  if (isRegex && !license.isPro) {
+    throw new Error(
+      "Regex find & replace is a Pro feature. Please activate a Pro license in Plugin Settings."
+    );
+  }
+  const targetsMap = /* @__PURE__ */ new Map();
+  for (const colUid of selectedCollections) {
+    if (!strapi.contentTypes[colUid]) continue;
+    const entries = await strapi.documents(colUid).findMany();
+    for (const entry of entries || []) {
+      const key = `${colUid}@@@${entry.documentId}`;
+      targetsMap.set(key, { uid: colUid, documentId: entry.documentId });
+    }
+  }
+  for (const item of selectedEntries) {
+    if (!item.uid || !item.documentId) continue;
+    const key = `${item.uid}@@@${item.documentId}`;
+    targetsMap.set(key, { uid: item.uid, documentId: item.documentId });
+  }
+  if (targetsMap.size === 0) {
+    throw new Error("No collections or entries were selected for update.");
+  }
+  const batchId = existingBatchId || `batch_${Date.now()}_${Math.random().toString(36).substring(2, 7)}`;
+  const results = [];
+  let updatedCount = 0;
+  let skippedCount = 0;
+  let regexObj = null;
+  if (isRegex && regexPattern) {
+    regexObj = new RegExp(regexPattern, "g");
+  }
+  const targets = Array.from(targetsMap.values());
+  const CHUNK_SIZE = 25;
+  const documentLoader = /* @__PURE__ */ new Map();
+  const getDocumentDeduplicated = (uid, documentId) => {
+    const loaderKey = `${uid}@@@${documentId}`;
+    if (!documentLoader.has(loaderKey)) {
+      documentLoader.set(
+        loaderKey,
+        strapi.documents(uid).findOne({ documentId })
+      );
+    }
+    return documentLoader.get(loaderKey);
+  };
+  for (let i = 0; i < targets.length; i += CHUNK_SIZE) {
+    const chunk = targets.slice(i, i + CHUNK_SIZE);
+    const chunkPromises = chunk.map(async (target) => {
+      const contentType = strapi.contentTypes[target.uid];
+      const displayName = contentType?.info?.displayName || target.uid;
+      try {
+        const currentEntry = await getDocumentDeduplicated(target.uid, target.documentId);
+        const entryLabel = currentEntry?.name || currentEntry?.title || currentEntry?.email || `Entry #${target.documentId}`;
+        const attrDef = contentType?.attributes?.[attribute];
+        const hasAttribute = Boolean(attrDef);
+        if (hasAttribute) {
+          if (attrDef.type === "relation") {
+            const isMulti = attrDef.relation === "oneToMany" || attrDef.relation === "manyToMany";
+            const currentEntryWithPopulate = await strapi.documents(target.uid).findOne({
+              documentId: target.documentId,
+              populate: [attribute]
+            });
+            const currentRel = currentEntryWithPopulate?.[attribute];
+            let oldDocIds = [];
+            let oldDisplay = "";
+            if (isMulti && Array.isArray(currentRel)) {
+              oldDocIds = currentRel.map((r) => r.documentId).filter(Boolean);
+              oldDisplay = currentRel.map((r) => r.name || r.title || r.email || r.documentId).join(", ") || "(empty)";
+            } else if (currentRel) {
+              oldDocIds = currentRel.documentId ? [currentRel.documentId] : [];
+              oldDisplay = currentRel.name || currentRel.title || currentRel.email || currentRel.documentId || "(empty)";
+            } else {
+              oldDisplay = "(unlinked / none)";
+            }
+            let mode = "set";
+            let targetDocIds = [];
+            let newDisplay = "";
+            if (value === "__clear__" || value === "") {
+              mode = "clear";
+              newDisplay = "(cleared / unlinked)";
+            } else {
+              try {
+                const parsed = JSON.parse(value);
+                if (parsed && typeof parsed === "object" && parsed.mode) {
+                  mode = parsed.mode;
+                  targetDocIds = Array.isArray(parsed.documentIds) ? parsed.documentIds : parsed.documentId ? [parsed.documentId] : [];
+                  newDisplay = parsed.label || targetDocIds.join(", ") || `[${mode}]`;
+                } else if (Array.isArray(parsed)) {
+                  targetDocIds = parsed;
+                  newDisplay = targetDocIds.join(", ");
+                } else {
+                  targetDocIds = [value];
+                  newDisplay = value;
+                }
+              } catch {
+                targetDocIds = [value];
+                newDisplay = value;
+              }
+            }
+            let relationPayload;
+            if (mode === "clear") {
+              relationPayload = isMulti ? { set: [] } : null;
+            } else if (mode === "set") {
+              relationPayload = isMulti ? { set: targetDocIds } : targetDocIds[0] || null;
+            } else if (mode === "connect") {
+              relationPayload = { connect: targetDocIds };
+            } else if (mode === "disconnect") {
+              relationPayload = { disconnect: targetDocIds };
+            }
+            await strapi.documents(target.uid).update({
+              documentId: target.documentId,
+              data: {
+                [attribute]: relationPayload
+              }
+            });
+            const isDraftAndPublishRel = Boolean(contentType?.options?.draftAndPublish);
+            if (publishOnApproval && isDraftAndPublishRel) {
+              try {
+                await strapi.documents(target.uid).publish({
+                  documentId: target.documentId
+                });
+              } catch (publishErr) {
+                strapi.log.warn(`[bulk-updater] Failed to auto-publish ${target.uid}/${target.documentId}:`, publishErr);
+              }
+            }
+            invalidateCollectionCache(target.uid);
+            if (attrDef.target) {
+              invalidateCollectionCache(attrDef.target);
+            }
+            return {
+              uid: target.uid,
+              collectionName: displayName,
+              documentId: target.documentId,
+              label: entryLabel,
+              attribute,
+              oldValue: { isRelation: true, documentIds: oldDocIds, display: oldDisplay },
+              newValue: { isRelation: true, mode, documentIds: targetDocIds, display: newDisplay },
+              status: "updated",
+              message: `Successfully updated relation "${attribute}"`
+            };
+          }
+          let newValue = value;
+          const currentVal = currentEntry?.[attribute];
+          if (regexObj && typeof currentVal === "string") {
+            newValue = currentVal.replace(regexObj, value);
+          }
+          await strapi.documents(target.uid).update({
+            documentId: target.documentId,
+            data: {
+              [attribute]: newValue
+            }
+          });
+          const isDraftAndPublishScalar = Boolean(contentType?.options?.draftAndPublish);
+          if (publishOnApproval && isDraftAndPublishScalar) {
+            try {
+              await strapi.documents(target.uid).publish({
+                documentId: target.documentId
+              });
+            } catch (publishErr) {
+              strapi.log.warn(`[bulk-updater] Failed to auto-publish ${target.uid}/${target.documentId}:`, publishErr);
+            }
+          }
+          return {
+            uid: target.uid,
+            collectionName: displayName,
+            documentId: target.documentId,
+            label: entryLabel,
+            attribute,
+            oldValue: currentVal ?? null,
+            newValue,
+            status: "updated",
+            message: `Successfully updated ${attribute}`
+          };
+        } else {
+          return {
+            uid: target.uid,
+            collectionName: displayName,
+            documentId: target.documentId,
+            label: entryLabel,
+            attribute,
+            status: "skipped",
+            message: `Skipped: Attribute "${attribute}" does not exist in schema for ${displayName}`
+          };
+        }
+      } catch (updateErr) {
+        return {
+          uid: target.uid,
+          collectionName: displayName,
+          documentId: target.documentId,
+          label: `Entry #${target.documentId}`,
+          attribute,
+          status: "error",
+          message: updateErr.message
+        };
+      }
+    });
+    const chunkResults = await Promise.all(chunkPromises);
+    for (const res of chunkResults) {
+      if (res.status === "updated") updatedCount++;
+      else if (res.status === "skipped") skippedCount++;
+      results.push(res);
+    }
+  }
+  const affectedUids = new Set(targets.map((t) => t.uid));
+  affectedUids.forEach((uid) => {
+    invalidateCollectionCache(uid);
+  });
+  const batchSummary = {
+    batchId,
+    attribute,
+    value,
+    updatedCount,
+    skippedCount,
+    totalTargets: targetsMap.size,
+    publishOnApproval
+  };
+  await strapi.plugin("bulk-updater").service("audit").recordBatch(
+    batchSummary,
+    results,
+    currentUser
+  );
+  return {
+    success: true,
+    batchId,
+    attribute,
+    value,
+    updatedCount,
+    skippedCount,
+    totalTargets: targetsMap.size,
+    results
+  };
+}
+const bulkUpdaterService = ({ strapi }) => {
+  if (!runnerInterval) {
+    runnerInterval = setInterval(async () => {
+      if (isRunnerRunning) return;
+      isRunnerRunning = true;
+      try {
+        const config = getExecutionWindowConfig(strapi);
+        const { isBusinessHours } = checkBusinessHours(config);
+        for (const [id, batch] of pendingBatches.entries()) {
+          if (batch.status === "queued_offpeak" && !isBusinessHours) {
+            strapi.log.info(`[bulk-updater] Executing off-peak queued batch: ${id}`);
+            const result = await executeBatchInternal(strapi, batch.payload, batch.createdBy, id);
+            batch.status = "executed";
+            batch.executionResult = result;
+          }
+        }
+      } catch (err) {
+        strapi.log.error("[bulk-updater] Scheduled runner error:", err);
+      } finally {
+        isRunnerRunning = false;
+      }
+    }, 3e4);
+  }
+  return {
+    /**
+     * Lightweight Schema Discovery:
+     * Returns schema definitions, valid attributes, and total counts (<15KB payload)
+     * Previews up to 10 entries per collection to ensure instantaneous initial paint.
+     * Utilizes in-memory schema memoization and database high-watermark signature caching.
+     */
+    async getModels() {
+      const allContentTypes = strapi.contentTypes || {};
+      const auditConfig = strapi.plugin("bulk-updater").service("audit").getAuditConfig();
+      const auditContentType = auditConfig?.contentType;
+      if (!staticSchemaCache) {
+        const allAttributesSet = /* @__PURE__ */ new Set();
+        const systemFields = [
+          "createdAt",
+          "updatedAt",
+          "publishedAt",
+          "createdBy",
+          "updatedBy",
+          "locale",
+          "localizations"
+        ];
+        const configuredCollections = strapi.config.get(
+          "plugin::bulk-updater.collections"
+        );
+        let targetUids;
+        if (configuredCollections && Array.isArray(configuredCollections) && configuredCollections.length > 0) {
+          targetUids = configuredCollections.filter((uid) => uid in allContentTypes);
+        } else {
+          targetUids = Object.keys(allContentTypes).filter(
+            (uid) => uid.startsWith("api::") && !uid.includes("bulk-updater") && uid !== auditContentType
+          );
+        }
+        const metaByUid = {};
+        const allRelationsMeta = {};
+        for (const uid of targetUids) {
+          const contentType = allContentTypes[uid];
+          if (!contentType || contentType.kind !== "collectionType" && contentType.kind !== "singleType") continue;
+          const isSingleType = contentType.kind === "singleType";
+          const rawAttrs = contentType.attributes || {};
+          const relationsByAttr = {};
+          const validAttrs = Object.keys(rawAttrs).filter((attrKey) => {
+            if (systemFields.includes(attrKey)) return false;
+            if (rawAttrs[attrKey].type === "component" || rawAttrs[attrKey].type === "dynamiczone") return false;
+            if (rawAttrs[attrKey].type === "relation") {
+              const rel = rawAttrs[attrKey];
+              const targetUid = rel.target;
+              if (!targetUid || !allContentTypes[targetUid]) return false;
+              const targetInfo = allContentTypes[targetUid]?.info;
+              const isMulti = rel.relation === "oneToMany" || rel.relation === "manyToMany";
+              const relMeta = {
+                isRelation: true,
+                relationType: rel.relation,
+                targetUid,
+                targetDisplayName: targetInfo?.displayName || targetUid,
+                isMulti
+              };
+              relationsByAttr[attrKey] = relMeta;
+              allRelationsMeta[attrKey] = relMeta;
+              return true;
+            }
+            return true;
+          });
+          validAttrs.forEach((attr) => allAttributesSet.add(attr));
+          metaByUid[uid] = {
+            uid,
+            kind: contentType.kind,
+            isSingleType,
+            singularName: contentType.info?.singularName || uid,
+            pluralName: contentType.info?.pluralName || uid,
+            displayName: contentType.info?.displayName || uid,
+            attributes: validAttrs,
+            relations: relationsByAttr
+          };
+        }
+        staticSchemaCache = {
+          attributes: Array.from(allAttributesSet),
+          targetUids: Object.keys(metaByUid),
+          metaByUid,
+          relationsMeta: allRelationsMeta
+        };
+      }
+      const collections = [];
+      const signatures = [];
+      for (const uid of staticSchemaCache.targetUids) {
+        const meta = staticSchemaCache.metaByUid[uid];
+        if (!meta) continue;
+        const signature = await getCollectionSignature(strapi, uid);
+        signatures.push(`${uid}=${signature}`);
+        const cached = modelsCache.get(uid);
+        if (cached && cached.signature === signature) {
+          collections.push({
+            ...meta,
+            totalEntries: cached.totalCount,
+            entries: cached.entries
+          });
+        } else {
+          let entries = [];
+          let totalCount = 0;
+          try {
+            const relKeys = Object.keys(meta.relations || {});
+            const populateOption = relKeys.length > 0 ? relKeys.reduce((acc, k) => ({ ...acc, [k]: true }), {}) : void 0;
+            if (meta.isSingleType) {
+              const singleDoc = await strapi.documents(uid).findFirst({
+                populate: populateOption
+              });
+              if (singleDoc) {
+                entries = [singleDoc];
+                totalCount = 1;
+              }
+            } else {
+              totalCount = await strapi.documents(uid).count();
+              entries = await strapi.documents(uid).findMany({
+                limit: 10,
+                sort: { createdAt: "desc" },
+                populate: populateOption
+              });
+            }
+          } catch (err) {
+            strapi.log.error(`[bulk-updater] Failed to fetch entries for ${uid}:`, err);
+            entries = [];
+            totalCount = 0;
+          }
+          const formattedEntries = (entries || []).map((entry) => ({
+            id: entry.id,
+            documentId: entry.documentId,
+            ...entry
+          }));
+          modelsCache.set(uid, {
+            signature,
+            totalCount,
+            entries: formattedEntries
+          });
+          collections.push({
+            ...meta,
+            totalEntries: totalCount,
+            entries: formattedEntries
+          });
+        }
+      }
+      const licenseService2 = strapi.plugin("bulk-updater").service("license");
+      const license = await licenseService2.getLicenseStatus();
+      const executionConfig = getExecutionWindowConfig(strapi);
+      const windowStatus = checkBusinessHours(executionConfig);
+      const pendingCount = Array.from(pendingBatches.values()).filter(
+        (b) => b.status === "pending_approval" || b.status === "queued_offpeak"
+      ).length;
+      const etag = `W/"models-${crypto.createHash("md5").update(`${signatures.join("|")}:${license.tier}:${pendingCount}:${windowStatus.isBusinessHours}:${windowStatus.currentServerTime}:${windowStatus.timeZone}`).digest("hex")}"`;
+      return {
+        success: true,
+        attributes: staticSchemaCache.attributes,
+        collections,
+        relationsMeta: staticSchemaCache.relationsMeta,
+        license,
+        executionWindow: {
+          ...executionConfig,
+          ...windowStatus
+        },
+        pendingBatchesCount: pendingCount,
+        auditEnabled: Boolean(auditConfig?.enabled),
+        etag
+      };
+    },
+    /**
+     * On-Demand Paginated Collection Entries:
+     * Supports server-side pagination (limit / start) and database query pushdown for filters.
+     * Cached in-process with cross-pod high-watermark signature validation.
+     */
+    async getCollectionEntries(uid, {
+      page = 1,
+      pageSize = 10,
+      attribute,
+      filterOperator,
+      filterQuery,
+      search,
+      sortField,
+      sortOrder = "desc"
+    }) {
+      const contentType = strapi.contentTypes[uid];
+      if (!contentType) {
+        throw new Error(`Collection with UID "${uid}" does not exist.`);
+      }
+      const limit = Math.min(Math.max(Number(pageSize) || 10, 1), 100);
+      const currentPage = Math.max(Number(page) || 1, 1);
+      const start = (currentPage - 1) * limit;
+      const isSingleType = contentType.kind === "singleType";
+      const signature = await getCollectionSignature(strapi, uid);
+      const cacheKey = `${uid}:${limit}:${start}:${attribute || ""}:${filterOperator || ""}:${filterQuery || ""}:${search || ""}:${sortField || ""}:${sortOrder}`;
+      const cached = queryCache.get(cacheKey);
+      const etag = `W/"entry-${crypto.createHash("md5").update(`${cacheKey}:${signature}`).digest("hex")}"`;
+      if (cached && cached.signature === signature && Date.now() - cached.timestamp < CACHE_TTL_MS) {
+        return {
+          ...cached.data,
+          cached: true,
+          etag
+        };
+      }
+      let result;
+      if (isSingleType) {
+        const singleDoc = await strapi.documents(uid).findFirst();
+        result = {
+          uid,
+          displayName: contentType.info?.displayName || uid,
+          isSingleType: true,
+          entries: singleDoc ? [singleDoc] : [],
+          pagination: {
+            page: 1,
+            pageSize: 1,
+            total: singleDoc ? 1 : 0,
+            pageCount: singleDoc ? 1 : 0
+          }
+        };
+      } else {
+        const filters = {};
+        if (attribute && filterOperator && filterQuery !== void 0 && filterQuery !== "") {
+          switch (filterOperator) {
+            case "equals":
+              filters[attribute] = { $eq: filterQuery };
+              break;
+            case "notEquals":
+              filters[attribute] = { $ne: filterQuery };
+              break;
+            case "contains":
+              filters[attribute] = { $containsi: filterQuery };
+              break;
+            case "notContains":
+              filters[attribute] = { $notContainsi: filterQuery };
+              break;
+            case "startsWith":
+              filters[attribute] = { $startsWith: filterQuery };
+              break;
+            case "endsWith":
+              filters[attribute] = { $endsWith: filterQuery };
+              break;
+            case "empty":
+              filters[attribute] = { $null: true };
+              break;
+            case "notEmpty":
+              filters[attribute] = { $notNull: true };
+              break;
+          }
+        }
+        if (search && search.trim() !== "") {
+          const stringAttrs = Object.keys(contentType.attributes || {}).filter(
+            (k) => contentType.attributes[k].type === "string" || contentType.attributes[k].type === "text" || contentType.attributes[k].type === "email"
+          );
+          if (stringAttrs.length > 0) {
+            filters.$or = stringAttrs.slice(0, 5).map((attr) => ({
+              [attr]: { $containsi: search.trim() }
+            }));
+          }
+        }
+        const sortClause = {};
+        if (sortField && contentType.attributes?.[sortField]) {
+          sortClause[sortField] = sortOrder;
+        } else {
+          sortClause["createdAt"] = "desc";
+        }
+        const relationAttrs = Object.keys(contentType.attributes || {}).filter(
+          (k) => contentType.attributes[k].type === "relation"
+        );
+        const populateOption = relationAttrs.length > 0 ? relationAttrs.reduce((acc, k) => ({ ...acc, [k]: true }), {}) : void 0;
+        const [entries, totalEntries] = await Promise.all([
+          strapi.documents(uid).findMany({
+            start,
+            limit,
+            filters: Object.keys(filters).length > 0 ? filters : void 0,
+            sort: sortClause,
+            populate: populateOption
+          }),
+          strapi.documents(uid).count({
+            filters: Object.keys(filters).length > 0 ? filters : void 0
+          })
+        ]);
+        const totalPages = Math.ceil(totalEntries / limit);
+        result = {
+          uid,
+          displayName: contentType.info?.displayName || uid,
+          isSingleType: false,
+          entries: (entries || []).map((entry) => ({
+            id: entry.id,
+            documentId: entry.documentId,
+            ...entry
+          })),
+          pagination: {
+            page: currentPage,
+            pageSize: limit,
+            total: totalEntries,
+            pageCount: totalPages
+          }
+        };
+      }
+      if (queryCache.size >= MAX_QUERY_CACHE_SIZE) {
+        const toDelete = Array.from(queryCache.keys()).slice(0, 100);
+        toDelete.forEach((k) => queryCache.delete(k));
+      }
+      queryCache.set(cacheKey, { signature, data: result, timestamp: Date.now() });
+      return {
+        ...result,
+        cached: false,
+        etag
+      };
+    },
+    /**
+     * Get available target entities for a relation field:
+     * Cached in-process with cross-pod signature validation.
+     */
+    async getRelationOptions(targetUid) {
+      if (!targetUid || !strapi.contentTypes[targetUid]) {
+        throw new Error(`Target content type "${targetUid}" does not exist.`);
+      }
+      const cacheKey = `rel_options:${targetUid}`;
+      const signature = await getCollectionSignature(strapi, targetUid);
+      const cached = queryCache.get(cacheKey);
+      if (cached && cached.signature === signature) {
+        return cached.data;
+      }
+      const docs = await strapi.documents(targetUid).findMany({
+        limit: 100,
+        sort: { createdAt: "desc" }
+      });
+      const options = (docs || []).map((doc) => {
+        const label = doc.name || doc.title || doc.email || doc.username || `Entry #${doc.id || doc.documentId}`;
+        return {
+          documentId: doc.documentId,
+          label
+        };
+      });
+      const result = { targetUid, options };
+      queryCache.set(cacheKey, { signature, data: result, timestamp: Date.now() });
+      return result;
+    },
+    /**
+     * Batch Update API with Maker-Checker and Off-Peak Scheduling:
+     */
+    async batchUpdate({
+      attribute,
+      value,
+      selectedEntries = [],
+      selectedCollections = [],
+      isRegex = false,
+      regexPattern = "",
+      executionMode = "immediate",
+      makerNotes = "",
+      forceImmediate = false,
+      publishOnApproval = true
+    }, currentUser) {
+      if (!attribute) {
+        throw new Error("Attribute name is required.");
+      }
+      const licenseService2 = strapi.plugin("bulk-updater").service("license");
+      const license = await licenseService2.getLicenseStatus();
+      license.tier === "enterprise";
+      const executionConfig = getExecutionWindowConfig(strapi);
+      const { isBusinessHours, policyMessage } = checkBusinessHours(executionConfig);
+      if (executionMode === "maker_checker") {
+        const summary = await computeTargetsSummary(strapi, { selectedCollections, selectedEntries });
+        if (summary.totalTargets === 0) {
+          throw new Error("No collections or entries were selected for update.");
+        }
+        const batchId = `batch_${Date.now()}_${Math.random().toString(36).substring(2, 7)}`;
+        const batch = {
+          id: batchId,
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          createdBy: currentUser ? {
+            id: currentUser.id,
+            email: currentUser.email,
+            firstname: currentUser.firstname,
+            lastname: currentUser.lastname,
+            username: currentUser.username
+          } : { email: "admin@system.local" },
+          payload: { attribute, value, selectedEntries, selectedCollections, isRegex, regexPattern, publishOnApproval },
+          summary: {
+            attribute,
+            value,
+            totalTargets: summary.totalTargets,
+            collectionBreakdown: summary.collectionBreakdown,
+            publishOnApproval
+          },
+          status: "pending_approval",
+          executionMode: "maker_checker",
+          makerNotes
+        };
+        pendingBatches.set(batchId, batch);
+        return {
+          success: true,
+          pending: true,
+          batchId,
+          status: "pending_approval",
+          message: "Batch submitted for Checker authorization (4-Eyes Maker-Checker Workflow).",
+          batch
+        };
+      }
+      if (executionMode === "queue_offpeak") {
+        const summary = await computeTargetsSummary(strapi, { selectedCollections, selectedEntries });
+        if (summary.totalTargets === 0) {
+          throw new Error("No collections or entries were selected for update.");
+        }
+        const batchId = `batch_${Date.now()}_${Math.random().toString(36).substring(2, 7)}`;
+        const batch = {
+          id: batchId,
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          createdBy: currentUser ? {
+            id: currentUser.id,
+            email: currentUser.email,
+            firstname: currentUser.firstname,
+            lastname: currentUser.lastname,
+            username: currentUser.username
+          } : { email: "admin@system.local" },
+          payload: { attribute, value, selectedEntries, selectedCollections, isRegex, regexPattern, publishOnApproval },
+          summary: {
+            attribute,
+            value,
+            totalTargets: summary.totalTargets,
+            collectionBreakdown: summary.collectionBreakdown,
+            publishOnApproval
+          },
+          status: "queued_offpeak",
+          executionMode: "queue_offpeak",
+          scheduledFor: executionConfig.offPeakStartTime,
+          makerNotes
+        };
+        pendingBatches.set(batchId, batch);
+        return {
+          success: true,
+          pending: true,
+          batchId,
+          status: "queued_offpeak",
+          scheduledFor: executionConfig.offPeakStartTime,
+          message: `Batch queued for server off-peak maintenance window (${executionConfig.offPeakStartTime}).`,
+          batch
+        };
+      }
+      if (executionConfig.enabled && executionConfig.autoQueueDuringBusinessHours && isBusinessHours && !forceImmediate) {
+        const summary = await computeTargetsSummary(strapi, { selectedCollections, selectedEntries });
+        if (summary.totalTargets === 0) {
+          throw new Error("No collections or entries were selected for update.");
+        }
+        const batchId = `batch_${Date.now()}_${Math.random().toString(36).substring(2, 7)}`;
+        const batch = {
+          id: batchId,
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          createdBy: currentUser ? {
+            id: currentUser.id,
+            email: currentUser.email,
+            firstname: currentUser.firstname,
+            lastname: currentUser.lastname,
+            username: currentUser.username
+          } : { email: "admin@system.local" },
+          payload: { attribute, value, selectedEntries, selectedCollections, isRegex, regexPattern, publishOnApproval },
+          summary: {
+            attribute,
+            value,
+            totalTargets: summary.totalTargets,
+            collectionBreakdown: summary.collectionBreakdown,
+            publishOnApproval
+          },
+          status: "queued_offpeak",
+          executionMode: "queue_offpeak",
+          scheduledFor: executionConfig.offPeakStartTime,
+          makerNotes: "Automatically queued due to peak business hours restriction."
+        };
+        pendingBatches.set(batchId, batch);
+        return {
+          success: true,
+          pending: true,
+          batchId,
+          status: "queued_offpeak",
+          scheduledFor: executionConfig.offPeakStartTime,
+          message: policyMessage,
+          batch
+        };
+      }
+      return await executeBatchInternal(
+        strapi,
+        { attribute, value, selectedEntries, selectedCollections, isRegex, regexPattern, publishOnApproval },
+        currentUser
+      );
+    },
+    /**
+     * Get Pending & Queued Batches
+     */
+    getPendingBatches() {
+      const executionConfig = getExecutionWindowConfig(strapi);
+      const windowStatus = checkBusinessHours(executionConfig);
+      const batches = Array.from(pendingBatches.values()).sort(
+        (a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime()
+      );
+      return {
+        success: true,
+        batches,
+        executionWindow: {
+          ...executionConfig,
+          ...windowStatus
+        }
+      };
+    },
+    /**
+     * Checker Approves Batch
+     */
+    async approveBatch(batchId, checkerUser, options = { executeImmediately: true }) {
+      const batch = pendingBatches.get(batchId);
+      if (!batch) {
+        throw new Error(`Pending batch ${batchId} not found.`);
+      }
+      if (batch.status !== "pending_approval") {
+        throw new Error(`Batch ${batchId} is not pending approval (current status: ${batch.status}).`);
+      }
+      batch.approval = {
+        checkerUser: checkerUser ? {
+          id: checkerUser.id,
+          email: checkerUser.email,
+          firstname: checkerUser.firstname,
+          lastname: checkerUser.lastname,
+          username: checkerUser.username
+        } : { email: "checker@system.local" },
+        decisionDate: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      const config = getExecutionWindowConfig(strapi);
+      const { isBusinessHours } = checkBusinessHours(config);
+      if (options.executeImmediately || !isBusinessHours) {
+        batch.status = "approved";
+        const result = await executeBatchInternal(strapi, batch.payload, checkerUser, batch.id);
+        batch.status = "executed";
+        batch.executionResult = result;
+        return {
+          success: true,
+          batchId,
+          status: "executed",
+          message: "Batch approved and executed successfully by Checker.",
+          batch,
+          result
+        };
+      } else {
+        batch.status = "approved";
+        return {
+          success: true,
+          batchId,
+          status: "approved",
+          message: `Batch approved by Checker. Queued for execution during off-peak window (${config.offPeakStartTime}).`,
+          batch
+        };
+      }
+    },
+    /**
+     * Checker Rejects Batch
+     */
+    rejectBatch(batchId, checkerUser, reason = "Rejected by Checker") {
+      const batch = pendingBatches.get(batchId);
+      if (!batch) {
+        throw new Error(`Pending batch ${batchId} not found.`);
+      }
+      batch.status = "rejected";
+      batch.approval = {
+        checkerUser: checkerUser ? {
+          id: checkerUser.id,
+          email: checkerUser.email,
+          firstname: checkerUser.firstname,
+          lastname: checkerUser.lastname,
+          username: checkerUser.username
+        } : { email: "checker@system.local" },
+        decisionDate: (/* @__PURE__ */ new Date()).toISOString(),
+        rejectionReason: reason
+      };
+      return {
+        success: true,
+        batchId,
+        status: "rejected",
+        message: `Batch rejected by Checker: ${reason}`,
+        batch
+      };
+    },
+    /**
+     * Run Batch Immediately
+     */
+    async executeNow(batchId, currentUser) {
+      const batch = pendingBatches.get(batchId);
+      if (!batch) {
+        throw new Error(`Pending batch ${batchId} not found.`);
+      }
+      if (batch.status === "executed") {
+        throw new Error(`Batch ${batchId} has already been executed.`);
+      }
+      const result = await executeBatchInternal(strapi, batch.payload, currentUser, batch.id);
+      batch.status = "executed";
+      batch.executionResult = result;
+      return {
+        success: true,
+        batchId,
+        status: "executed",
+        message: "Batch executed immediately.",
+        batch,
+        result
+      };
+    },
+    invalidateCache(uid) {
+      if (uid) {
+        invalidateCollectionCache(uid);
+      } else {
+        queryCache.clear();
+        modelsCache.clear();
+        staticSchemaCache = null;
+      }
+    }
+  };
+};
+const DEFAULT_FREE_STATUS = {
+  isPro: false,
+  tier: "free",
+  licenseKey: null,
+  licensedTo: null,
+  activatedAt: null,
+  features: [
+    "Basic attribute batch updates",
+    "Schema compatibility checks",
+    "Interactive target selection"
+  ]
+};
+const PRO_FEATURES = [
+  "Basic attribute batch updates",
+  "Schema compatibility checks",
+  "Interactive target selection",
+  "Regex find & replace within attributes",
+  "Cross-relation and dynamic zone updates",
+  "Audit log export (CSV / JSON)",
+  "Unlimited collection batch operations",
+  "Priority enterprise support"
+];
+const ENTERPRISE_FEATURES = [
+  ...PRO_FEATURES,
+  "Maker-Checker Approval Workflow (4-Eyes Principle)",
+  "Server-Enforced Off-Peak Maintenance Window",
+  "Scheduled batch queuing during business hours"
+];
+const licenseService = ({ strapi }) => ({
+  async getStore() {
+    return strapi.store({
+      type: "plugin",
+      name: "bulk-updater",
+      key: "license"
+    });
+  },
+  async getLicenseStatus() {
+    const isConfigEnterprise = strapi.config.get("plugin::bulk-updater.makerChecker.enabled");
+    const store = await this.getStore();
+    const stored = await store.get({});
+    if (!stored || !stored.licenseKey) {
+      if (isConfigEnterprise) {
+        return {
+          isPro: true,
+          tier: "enterprise",
+          licenseKey: "CONFIG-OVERRIDE",
+          licensedTo: "Enterprise Developer Config",
+          activatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          features: ENTERPRISE_FEATURES
+        };
+      }
+      return DEFAULT_FREE_STATUS;
+    }
+    if (isConfigEnterprise) {
+      return {
+        ...stored,
+        isPro: true,
+        tier: "enterprise",
+        features: Array.from(/* @__PURE__ */ new Set([...stored.features || [], ...ENTERPRISE_FEATURES]))
+      };
+    }
+    return stored;
+  },
+  async verifyAndActivateLicense(licenseKey) {
+    if (!licenseKey || typeof licenseKey !== "string") {
+      return { success: false, error: "A valid license key is required." };
+    }
+    const trimmed = licenseKey.trim();
+    const isEnterprise = trimmed.toUpperCase().startsWith("ENT-") || trimmed.toUpperCase().startsWith("ENTERPRISE-");
+    const isPro = trimmed.toUpperCase().startsWith("PRO-") || isEnterprise;
+    if (!isPro) {
+      return {
+        success: false,
+        error: "Invalid license key. License keys must start with PRO- or ENTERPRISE-."
+      };
+    }
+    const tier = isEnterprise ? "enterprise" : "pro";
+    const status = {
+      isPro: true,
+      tier,
+      licenseKey: trimmed,
+      licensedTo: `Licensed Customer (${tier.toUpperCase()})`,
+      activatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      features: isEnterprise ? ENTERPRISE_FEATURES : PRO_FEATURES
+    };
+    const store = await this.getStore();
+    await store.set({ value: status });
+    return {
+      success: true,
+      license: status
+    };
+  },
+  async deactivateLicense() {
+    const store = await this.getStore();
+    await store.set({ value: DEFAULT_FREE_STATUS });
+    return DEFAULT_FREE_STATUS;
+  }
+});
+const DEFAULT_FIELDS = {
+  batchId: "batchId",
+  attribute: "attribute",
+  value: "value",
+  userEmail: "userEmail",
+  userName: "userName",
+  updatedCount: "updatedCount",
+  skippedCount: "skippedCount",
+  totalTargets: "totalTargets",
+  diffs: "diffs",
+  isRolledBack: "isRolledBack",
+  rolledBackAt: "rolledBackAt",
+  rolledBackBy: "rolledBackBy",
+  executedAt: "executedAt"
+};
+const DEFAULT_CANDIDATE_TYPES = [
+  "api::audit-log.audit-log",
+  "api::audit.audit",
+  "api::bulk-audit-log.bulk-audit-log"
+];
+const auditService = ({ strapi }) => ({
+  /**
+   * Detects whether Strapi Enterprise Native Audit Log service is available.
+   */
+  getEnterpriseAuditService() {
+    try {
+      const svc = strapi.service?.("admin::audit-logs") || strapi.admin?.services?.["audit-logs"];
+      return svc || null;
+    } catch {
+      return null;
+    }
+  },
+  /**
+   * Resolves the audit configuration:
+   * 1. Explicit consumer custom schema (full declarative control)
+   * 2. Zero-config convention auto-detection (api::audit-log.audit-log)
+   * 3. Strapi Enterprise native audit log bridge
+   */
+  getAuditConfig() {
+    const rawConfig = strapi.config.get("plugin::bulk-updater.audit");
+    const eeService = this.getEnterpriseAuditService();
+    const isEnterpriseNativeAvailable = Boolean(
+      eeService && typeof eeService.save === "function"
+    );
+    if (rawConfig && rawConfig.enabled === false) {
+      return {
+        enabled: false,
+        mode: "disabled",
+        isEnterpriseNativeAvailable
+      };
+    }
+    if (rawConfig?.contentType) {
+      const { contentType, fields } = rawConfig;
+      const schema = strapi.contentTypes[contentType];
+      if (!schema) {
+        return {
+          enabled: false,
+          mode: "disabled",
+          isEnterpriseNativeAvailable,
+          error: `Declared audit contentType "${contentType}" does not exist in Strapi schema registry.`
+        };
+      }
+      const resolvedFields = { ...DEFAULT_FIELDS, ...fields || {} };
+      return {
+        enabled: true,
+        mode: "custom",
+        contentType,
+        fields: resolvedFields,
+        isEnterpriseNativeAvailable
+      };
+    }
+    for (const candidate of DEFAULT_CANDIDATE_TYPES) {
+      if (strapi.contentTypes[candidate]) {
+        return {
+          enabled: true,
+          mode: "default",
+          contentType: candidate,
+          fields: DEFAULT_FIELDS,
+          isEnterpriseNativeAvailable
+        };
+      }
+    }
+    if (isEnterpriseNativeAvailable) {
+      return {
+        enabled: true,
+        mode: "enterprise_native",
+        isEnterpriseNativeAvailable: true
+      };
+    }
+    return {
+      enabled: false,
+      mode: "disabled",
+      isEnterpriseNativeAvailable: false,
+      error: "No audit collection configured or detected. To enable rollback, provide a collection or use Strapi Enterprise."
+    };
+  },
+  /**
+   * Optionally writes an audit event directly to Strapi Enterprise's native Audit Logs table.
+   */
+  async recordToEnterpriseNative(action, payload, user) {
+    try {
+      const eeService = this.getEnterpriseAuditService();
+      if (eeService && typeof eeService.save === "function") {
+        await eeService.save({
+          action,
+          date: /* @__PURE__ */ new Date(),
+          userId: user?.id,
+          payload
+        });
+        strapi.log.info(
+          `[bulk-updater] Successfully dispatched event to Strapi Enterprise Audit Log: ${action}`
+        );
+      }
+    } catch (err) {
+      strapi.log.warn(
+        `[bulk-updater] Note: Could not dispatch to Strapi Enterprise native audit log: ${err.message}`
+      );
+    }
+  },
+  /**
+   * Records a batch execution:
+   * - Dispatches to Strapi Enterprise native audit log if available
+   * - Records to consumer or auto-detected collection type for one-click rollback
+   */
+  async recordBatch(batchSummary, results, user) {
+    const config = this.getAuditConfig();
+    await this.recordToEnterpriseNative(
+      "bulk-updater.batch-update",
+      {
+        batchId: batchSummary.batchId,
+        attribute: batchSummary.attribute,
+        value: batchSummary.value,
+        updatedCount: batchSummary.updatedCount,
+        skippedCount: batchSummary.skippedCount,
+        totalTargets: batchSummary.totalTargets
+      },
+      user
+    );
+    if (!config.enabled || !config.contentType || !config.fields) {
+      return null;
+    }
+    const f = config.fields;
+    const mappedData = {};
+    if (f.batchId) mappedData[f.batchId] = batchSummary.batchId;
+    if (f.attribute) mappedData[f.attribute] = batchSummary.attribute;
+    if (f.value) mappedData[f.value] = batchSummary.value;
+    if (f.userEmail) mappedData[f.userEmail] = user?.email || "admin@strapi.io";
+    if (f.userName) {
+      mappedData[f.userName] = user?.firstname ? `${user.firstname} ${user.lastname || ""}`.trim() : user?.email || "Admin";
+    }
+    if (f.updatedCount) mappedData[f.updatedCount] = batchSummary.updatedCount;
+    if (f.skippedCount) mappedData[f.skippedCount] = batchSummary.skippedCount;
+    if (f.totalTargets) mappedData[f.totalTargets] = batchSummary.totalTargets;
+    if (f.diffs) mappedData[f.diffs] = results;
+    if (f.isRolledBack) mappedData[f.isRolledBack] = false;
+    if (f.executedAt) mappedData[f.executedAt] = (/* @__PURE__ */ new Date()).toISOString();
+    try {
+      const created = await strapi.documents(config.contentType).create({
+        data: mappedData
+      });
+      return created;
+    } catch (err) {
+      strapi.log.error(`[bulk-updater] Failed to record audit log: ${err.message}`);
+      return null;
+    }
+  },
+  /**
+   * Fetches audit history for the UI
+   */
+  async getHistory() {
+    const config = this.getAuditConfig();
+    if (config.mode === "enterprise_native" && !config.contentType) {
+      return {
+        enabled: true,
+        mode: "enterprise_native",
+        message: "Strapi Enterprise Native Audit Logs active. Batch events are recorded directly to Strapi Settings > Audit Logs. (To enable one-click document rollback, declare or add an audit-log collection).",
+        history: []
+      };
+    }
+    if (!config.enabled || !config.contentType || !config.fields) {
+      return {
+        enabled: false,
+        message: config.error || "Audit trail is disabled. To enable audit logs & rollback, declare an audit schema in config/plugins.ts or create api::audit-log.audit-log.",
+        history: []
+      };
+    }
+    try {
+      const records = await strapi.documents(config.contentType).findMany({
+        sort: { createdAt: "desc" }
+      });
+      const f = config.fields;
+      const normalized = (records || []).map((r) => ({
+        id: r.id,
+        documentId: r.documentId,
+        batchId: r[f.batchId] || r.documentId,
+        attribute: r[f.attribute],
+        value: r[f.value],
+        userEmail: r[f.userEmail] || "admin@strapi.io",
+        userName: r[f.userName] || "Admin",
+        updatedCount: r[f.updatedCount] || 0,
+        skippedCount: r[f.skippedCount] || 0,
+        totalTargets: r[f.totalTargets] || 0,
+        diffs: typeof r[f.diffs] === "string" ? JSON.parse(r[f.diffs]) : r[f.diffs] || [],
+        isRolledBack: Boolean(r[f.isRolledBack]),
+        rolledBackAt: r[f.rolledBackAt] || null,
+        rolledBackBy: r[f.rolledBackBy] || null,
+        executedAt: r[f.executedAt] || r.createdAt
+      }));
+      return {
+        enabled: true,
+        mode: config.mode,
+        contentType: config.contentType,
+        isEnterpriseNativeAvailable: config.isEnterpriseNativeAvailable,
+        history: normalized
+      };
+    } catch (err) {
+      return {
+        enabled: false,
+        message: `Failed to read audit history: ${err.message}`,
+        history: []
+      };
+    }
+  },
+  /**
+   * Performs deterministic rollback of a batch
+   */
+  async rollbackBatch(batchId, currentUser) {
+    const config = this.getAuditConfig();
+    if (!config.enabled || !config.contentType || !config.fields) {
+      throw new Error("Audit trail is not configured or disabled.");
+    }
+    const f = config.fields;
+    const records = await strapi.documents(config.contentType).findMany({
+      filters: {
+        [f.batchId]: { $eq: batchId }
+      }
+    });
+    const record = records?.[0];
+    if (!record) {
+      throw new Error(`Batch record with ID "${batchId}" was not found in audit trail.`);
+    }
+    if (record[f.isRolledBack]) {
+      throw new Error(`Batch "${batchId}" has already been rolled back.`);
+    }
+    const diffs = typeof record[f.diffs] === "string" ? JSON.parse(record[f.diffs]) : record[f.diffs] || [];
+    let revertedCount = 0;
+    const rollbackDetails = [];
+    for (const item of diffs) {
+      if (item.status === "updated" && item.uid && item.documentId && item.attribute) {
+        try {
+          const isRel = item.oldValue && typeof item.oldValue === "object" && item.oldValue.isRelation;
+          let rollbackPayload;
+          if (isRel) {
+            const oldDocIds = Array.isArray(item.oldValue.documentIds) ? item.oldValue.documentIds : [];
+            rollbackPayload = { set: oldDocIds };
+          } else {
+            rollbackPayload = item.oldValue;
+          }
+          await strapi.documents(item.uid).update({
+            documentId: item.documentId,
+            data: {
+              [item.attribute]: rollbackPayload
+            }
+          });
+          const ct = strapi.contentTypes[item.uid];
+          if (ct?.options?.draftAndPublish) {
+            try {
+              await strapi.documents(item.uid).publish({
+                documentId: item.documentId
+              });
+            } catch {
+            }
+          }
+          try {
+            strapi.plugin("bulk-updater").service("bulkUpdater").invalidateCollectionCache(item.uid);
+          } catch {
+          }
+          revertedCount++;
+          rollbackDetails.push({
+            uid: item.uid,
+            documentId: item.documentId,
+            label: item.label,
+            attribute: item.attribute,
+            revertedTo: item.oldValue,
+            status: "reverted"
+          });
+        } catch (err) {
+          rollbackDetails.push({
+            uid: item.uid,
+            documentId: item.documentId,
+            label: item.label,
+            status: "error",
+            message: err.message
+          });
+        }
+      }
+    }
+    const updateData = {};
+    if (f.isRolledBack) updateData[f.isRolledBack] = true;
+    if (f.rolledBackAt) updateData[f.rolledBackAt] = (/* @__PURE__ */ new Date()).toISOString();
+    if (f.rolledBackBy) {
+      updateData[f.rolledBackBy] = currentUser?.email || "Admin";
+    }
+    await strapi.documents(config.contentType).update({
+      documentId: record.documentId,
+      data: updateData
+    });
+    try {
+      const affectedUids = new Set(rollbackDetails.map((d) => d.uid));
+      const bulkService = strapi.plugin("bulk-updater").service("bulkUpdater");
+      affectedUids.forEach((uid) => {
+        if (uid && bulkService?.invalidateCache) {
+          bulkService.invalidateCache(uid);
+        }
+      });
+    } catch {
+    }
+    await this.recordToEnterpriseNative(
+      "bulk-updater.rollback",
+      {
+        batchId,
+        revertedCount
+      },
+      currentUser
+    );
+    return {
+      success: true,
+      batchId,
+      revertedCount,
+      details: rollbackDetails
+    };
+  }
+});
+const index = {
+  register({ strapi }) {
+  },
+  bootstrap({ strapi }) {
+  },
+  routes,
+  controllers: {
+    bulkUpdater: bulkUpdaterController,
+    license: licenseController,
+    audit: auditController
+  },
+  services: {
+    bulkUpdater: bulkUpdaterService,
+    license: licenseService,
+    audit: auditService
+  }
+};
+export {
+  index as default
+};
+//# sourceMappingURL=index.mjs.map