strapi-plugin-recycle-bin 0.0.0-stage → 1.0.0

package/dist/server/index.js

@@ -0,0 +1,258 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const registerDeletionMiddleware = (strapi) => {
+  strapi.documents.use(async (context, next) => {
+    if (context.action === "delete") {
+      const uid = context.uid;
+      const documentId = context.params?.documentId;
+      const auth = strapi.requestContext?.get()?.state?.user;
+      if (uid && documentId) {
+        try {
+          await strapi.plugin("recycle-bin").service("archive").capture(uid, documentId, auth);
+        } catch (err) {
+          strapi.log.error(`[recycle-bin] Archiving failed for ${uid} (${documentId}):`, err);
+        }
+      }
+    }
+    return next();
+  });
+};
+const bootstrap = ({ strapi }) => {
+  registerDeletionMiddleware(strapi);
+  strapi.cron.add({
+    recycleBinRetentionJob: {
+      task: async () => {
+        const config2 = strapi.config.get("plugin::recycle-bin");
+        const days = config2.retentionDays || 30;
+        const cutoff = new Date(Date.now() - days * 24 * 60 * 60 * 1e3);
+        const deleted = await strapi.db.query("plugin::recycle-bin.recycle-bin-item").deleteMany({
+          where: {
+            deletedAt: { $lt: cutoff }
+          }
+        });
+        strapi.log.info(`[recycle-bin] Auto-purged ${deleted.count} expired item(s).`);
+      },
+      options: {
+        rule: "0 0 * * *"
+        // Midnight
+      }
+    }
+  });
+};
+const destroy = ({ strapi }) => {
+};
+const register = ({ strapi }) => {
+};
+const config = {
+  default: {
+    retentionDays: 30,
+    excludedUids: [
+      "admin::user",
+      "admin::permission",
+      "admin::role",
+      "admin::api-token",
+      "admin::transfer-token",
+      "plugin::recycle-bin.recycle-bin-item",
+      "plugin::upload.file"
+    ]
+  },
+  validator() {
+  }
+};
+const kind = "collectionType";
+const collectionName = "recycle_bin_items";
+const info = { "singularName": "recycle-bin-item", "pluralName": "recycle-bin-items", "displayName": "Recycle Bin Item" };
+const options = { "draftAndPublish": false };
+const pluginOptions = { "content-manager": { "visible": false }, "content-type-builder": { "visible": false } };
+const attributes = { "entityUid": { "type": "string", "required": true }, "recordDocumentId": { "type": "string", "required": true, "index": true }, "title": { "type": "string" }, "payload": { "type": "json", "required": true }, "deletedBy": { "type": "relation", "relation": "oneToOne", "target": "admin::user" }, "deletedAt": { "type": "datetime", "required": true, "index": true } };
+const schema = {
+  kind,
+  collectionName,
+  info,
+  options,
+  pluginOptions,
+  attributes
+};
+const contentTypes = {
+  "recycle-bin-item": { schema }
+};
+const recycleBin = ({ strapi }) => ({
+  async find(ctx) {
+    const { page = 1, pageSize = 10, search, entityUid } = ctx.query;
+    const pageNum = Math.max(1, parseInt(page, 10) || 1);
+    const pageSizeNum = Math.max(1, Math.min(100, parseInt(pageSize, 10) || 10));
+    const where = {};
+    if (typeof entityUid === "string" && entityUid.trim()) {
+      where.entityUid = entityUid.trim();
+    }
+    if (typeof search === "string" && search.trim()) {
+      where.title = { $containsi: search.trim() };
+    }
+    const [items, total] = await Promise.all([
+      strapi.db.query("plugin::recycle-bin.recycle-bin-item").findMany({
+        where,
+        populate: ["deletedBy"],
+        orderBy: { deletedAt: "desc" },
+        offset: (pageNum - 1) * pageSizeNum,
+        limit: pageSizeNum
+      }),
+      strapi.db.query("plugin::recycle-bin.recycle-bin-item").count({ where })
+    ]);
+    ctx.body = {
+      data: items,
+      meta: {
+        pagination: {
+          page: pageNum,
+          pageSize: pageSizeNum,
+          pageCount: Math.ceil(total / pageSizeNum) || 1,
+          total
+        }
+      }
+    };
+  },
+  async restore(ctx) {
+    const { id } = ctx.params;
+    const numericId = parseInt(id, 10);
+    if (isNaN(numericId) || numericId <= 0) {
+      return ctx.badRequest("Invalid or missing item ID");
+    }
+    try {
+      await strapi.plugin("recycle-bin").service("restore").restoreItem(numericId);
+      ctx.body = { data: { restored: true } };
+    } catch (err) {
+      if (err.message?.includes("not found")) {
+        return ctx.notFound(err.message);
+      }
+      return ctx.badRequest(err.message || "Failed to restore item");
+    }
+  },
+  async purge(ctx) {
+    const { id } = ctx.params;
+    const numericId = parseInt(id, 10);
+    if (isNaN(numericId) || numericId <= 0) {
+      return ctx.badRequest("Invalid or missing item ID");
+    }
+    try {
+      await strapi.plugin("recycle-bin").service("restore").purgeItem(numericId);
+      ctx.body = { data: { purged: true } };
+    } catch (err) {
+      return ctx.badRequest(err.message || "Failed to purge item");
+    }
+  }
+});
+const controllers = {
+  recycleBin
+};
+const middlewares = {};
+const policies = {};
+const admin = {
+  type: "admin",
+  routes: [
+    {
+      method: "GET",
+      path: "/items",
+      handler: "recycleBin.find",
+      config: { policies: ["admin::isAuthenticatedAdmin"] }
+    },
+    {
+      method: "POST",
+      path: "/items/:id/restore",
+      handler: "recycleBin.restore",
+      config: { policies: ["admin::isAuthenticatedAdmin"] }
+    },
+    {
+      method: "DELETE",
+      path: "/items/:id",
+      handler: "recycleBin.purge",
+      config: { policies: ["admin::isAuthenticatedAdmin"] }
+    }
+  ]
+};
+const routes = {
+  admin
+};
+const archive = ({ strapi }) => ({
+  async capture(uid, documentId, userContext) {
+    const config2 = strapi.config.get("plugin::recycle-bin");
+    if (config2?.excludedUids?.includes(uid)) return;
+    let entries = await strapi.documents(uid).findMany({
+      filters: { documentId },
+      populate: "*",
+      status: "draft"
+    });
+    if (!entries || entries.length === 0) {
+      entries = await strapi.documents(uid).findMany({
+        filters: { documentId },
+        populate: "*"
+      });
+    }
+    if (!entries || entries.length === 0) return;
+    const mainEntry = entries[0];
+    const title = mainEntry.title || mainEntry.name || mainEntry.subject || mainEntry.documentId || "Untitled Record";
+    await strapi.db.query("plugin::recycle-bin.recycle-bin-item").create({
+      data: {
+        entityUid: uid,
+        recordDocumentId: documentId,
+        title,
+        payload: entries,
+        deletedBy: userContext?.id || null,
+        deletedAt: /* @__PURE__ */ new Date()
+      }
+    });
+  }
+});
+const restore = ({ strapi }) => ({
+  async restoreItem(id) {
+    const item = await strapi.db.query("plugin::recycle-bin.recycle-bin-item").findOne({
+      where: { id }
+    });
+    if (!item) {
+      throw new Error("Item not found in recycle bin");
+    }
+    const { entityUid, payload } = item;
+    const model = strapi.contentType(entityUid);
+    if (!model) {
+      throw new Error(`Target content type ${entityUid} no longer exists.`);
+    }
+    const records = Array.isArray(payload) ? payload : [payload];
+    for (const record of records) {
+      const sanitizedData = { ...record };
+      delete sanitizedData.id;
+      delete sanitizedData.documentId;
+      delete sanitizedData.createdAt;
+      delete sanitizedData.updatedAt;
+      delete sanitizedData.publishedAt;
+      const createParams = { data: sanitizedData };
+      if (model.options?.draftAndPublish) {
+        createParams.status = record.publishedAt ? "published" : "draft";
+      }
+      await strapi.documents(entityUid).create(createParams);
+    }
+    await strapi.db.query("plugin::recycle-bin.recycle-bin-item").delete({
+      where: { id }
+    });
+    return { success: true };
+  },
+  async purgeItem(id) {
+    return strapi.db.query("plugin::recycle-bin.recycle-bin-item").delete({
+      where: { id }
+    });
+  }
+});
+const services = {
+  archive,
+  restore
+};
+const index = {
+  register,
+  bootstrap,
+  destroy,
+  config,
+  controllers,
+  routes,
+  services,
+  contentTypes,
+  policies,
+  middlewares
+};
+exports.default = index;

package/dist/server/index.mjs

@@ -0,0 +1,258 @@
+const registerDeletionMiddleware = (strapi) => {
+  strapi.documents.use(async (context, next) => {
+    if (context.action === "delete") {
+      const uid = context.uid;
+      const documentId = context.params?.documentId;
+      const auth = strapi.requestContext?.get()?.state?.user;
+      if (uid && documentId) {
+        try {
+          await strapi.plugin("recycle-bin").service("archive").capture(uid, documentId, auth);
+        } catch (err) {
+          strapi.log.error(`[recycle-bin] Archiving failed for ${uid} (${documentId}):`, err);
+        }
+      }
+    }
+    return next();
+  });
+};
+const bootstrap = ({ strapi }) => {
+  registerDeletionMiddleware(strapi);
+  strapi.cron.add({
+    recycleBinRetentionJob: {
+      task: async () => {
+        const config2 = strapi.config.get("plugin::recycle-bin");
+        const days = config2.retentionDays || 30;
+        const cutoff = new Date(Date.now() - days * 24 * 60 * 60 * 1e3);
+        const deleted = await strapi.db.query("plugin::recycle-bin.recycle-bin-item").deleteMany({
+          where: {
+            deletedAt: { $lt: cutoff }
+          }
+        });
+        strapi.log.info(`[recycle-bin] Auto-purged ${deleted.count} expired item(s).`);
+      },
+      options: {
+        rule: "0 0 * * *"
+        // Midnight
+      }
+    }
+  });
+};
+const destroy = ({ strapi }) => {
+};
+const register = ({ strapi }) => {
+};
+const config = {
+  default: {
+    retentionDays: 30,
+    excludedUids: [
+      "admin::user",
+      "admin::permission",
+      "admin::role",
+      "admin::api-token",
+      "admin::transfer-token",
+      "plugin::recycle-bin.recycle-bin-item",
+      "plugin::upload.file"
+    ]
+  },
+  validator() {
+  }
+};
+const kind = "collectionType";
+const collectionName = "recycle_bin_items";
+const info = { "singularName": "recycle-bin-item", "pluralName": "recycle-bin-items", "displayName": "Recycle Bin Item" };
+const options = { "draftAndPublish": false };
+const pluginOptions = { "content-manager": { "visible": false }, "content-type-builder": { "visible": false } };
+const attributes = { "entityUid": { "type": "string", "required": true }, "recordDocumentId": { "type": "string", "required": true, "index": true }, "title": { "type": "string" }, "payload": { "type": "json", "required": true }, "deletedBy": { "type": "relation", "relation": "oneToOne", "target": "admin::user" }, "deletedAt": { "type": "datetime", "required": true, "index": true } };
+const schema = {
+  kind,
+  collectionName,
+  info,
+  options,
+  pluginOptions,
+  attributes
+};
+const contentTypes = {
+  "recycle-bin-item": { schema }
+};
+const recycleBin = ({ strapi }) => ({
+  async find(ctx) {
+    const { page = 1, pageSize = 10, search, entityUid } = ctx.query;
+    const pageNum = Math.max(1, parseInt(page, 10) || 1);
+    const pageSizeNum = Math.max(1, Math.min(100, parseInt(pageSize, 10) || 10));
+    const where = {};
+    if (typeof entityUid === "string" && entityUid.trim()) {
+      where.entityUid = entityUid.trim();
+    }
+    if (typeof search === "string" && search.trim()) {
+      where.title = { $containsi: search.trim() };
+    }
+    const [items, total] = await Promise.all([
+      strapi.db.query("plugin::recycle-bin.recycle-bin-item").findMany({
+        where,
+        populate: ["deletedBy"],
+        orderBy: { deletedAt: "desc" },
+        offset: (pageNum - 1) * pageSizeNum,
+        limit: pageSizeNum
+      }),
+      strapi.db.query("plugin::recycle-bin.recycle-bin-item").count({ where })
+    ]);
+    ctx.body = {
+      data: items,
+      meta: {
+        pagination: {
+          page: pageNum,
+          pageSize: pageSizeNum,
+          pageCount: Math.ceil(total / pageSizeNum) || 1,
+          total
+        }
+      }
+    };
+  },
+  async restore(ctx) {
+    const { id } = ctx.params;
+    const numericId = parseInt(id, 10);
+    if (isNaN(numericId) || numericId <= 0) {
+      return ctx.badRequest("Invalid or missing item ID");
+    }
+    try {
+      await strapi.plugin("recycle-bin").service("restore").restoreItem(numericId);
+      ctx.body = { data: { restored: true } };
+    } catch (err) {
+      if (err.message?.includes("not found")) {
+        return ctx.notFound(err.message);
+      }
+      return ctx.badRequest(err.message || "Failed to restore item");
+    }
+  },
+  async purge(ctx) {
+    const { id } = ctx.params;
+    const numericId = parseInt(id, 10);
+    if (isNaN(numericId) || numericId <= 0) {
+      return ctx.badRequest("Invalid or missing item ID");
+    }
+    try {
+      await strapi.plugin("recycle-bin").service("restore").purgeItem(numericId);
+      ctx.body = { data: { purged: true } };
+    } catch (err) {
+      return ctx.badRequest(err.message || "Failed to purge item");
+    }
+  }
+});
+const controllers = {
+  recycleBin
+};
+const middlewares = {};
+const policies = {};
+const admin = {
+  type: "admin",
+  routes: [
+    {
+      method: "GET",
+      path: "/items",
+      handler: "recycleBin.find",
+      config: { policies: ["admin::isAuthenticatedAdmin"] }
+    },
+    {
+      method: "POST",
+      path: "/items/:id/restore",
+      handler: "recycleBin.restore",
+      config: { policies: ["admin::isAuthenticatedAdmin"] }
+    },
+    {
+      method: "DELETE",
+      path: "/items/:id",
+      handler: "recycleBin.purge",
+      config: { policies: ["admin::isAuthenticatedAdmin"] }
+    }
+  ]
+};
+const routes = {
+  admin
+};
+const archive = ({ strapi }) => ({
+  async capture(uid, documentId, userContext) {
+    const config2 = strapi.config.get("plugin::recycle-bin");
+    if (config2?.excludedUids?.includes(uid)) return;
+    let entries = await strapi.documents(uid).findMany({
+      filters: { documentId },
+      populate: "*",
+      status: "draft"
+    });
+    if (!entries || entries.length === 0) {
+      entries = await strapi.documents(uid).findMany({
+        filters: { documentId },
+        populate: "*"
+      });
+    }
+    if (!entries || entries.length === 0) return;
+    const mainEntry = entries[0];
+    const title = mainEntry.title || mainEntry.name || mainEntry.subject || mainEntry.documentId || "Untitled Record";
+    await strapi.db.query("plugin::recycle-bin.recycle-bin-item").create({
+      data: {
+        entityUid: uid,
+        recordDocumentId: documentId,
+        title,
+        payload: entries,
+        deletedBy: userContext?.id || null,
+        deletedAt: /* @__PURE__ */ new Date()
+      }
+    });
+  }
+});
+const restore = ({ strapi }) => ({
+  async restoreItem(id) {
+    const item = await strapi.db.query("plugin::recycle-bin.recycle-bin-item").findOne({
+      where: { id }
+    });
+    if (!item) {
+      throw new Error("Item not found in recycle bin");
+    }
+    const { entityUid, payload } = item;
+    const model = strapi.contentType(entityUid);
+    if (!model) {
+      throw new Error(`Target content type ${entityUid} no longer exists.`);
+    }
+    const records = Array.isArray(payload) ? payload : [payload];
+    for (const record of records) {
+      const sanitizedData = { ...record };
+      delete sanitizedData.id;
+      delete sanitizedData.documentId;
+      delete sanitizedData.createdAt;
+      delete sanitizedData.updatedAt;
+      delete sanitizedData.publishedAt;
+      const createParams = { data: sanitizedData };
+      if (model.options?.draftAndPublish) {
+        createParams.status = record.publishedAt ? "published" : "draft";
+      }
+      await strapi.documents(entityUid).create(createParams);
+    }
+    await strapi.db.query("plugin::recycle-bin.recycle-bin-item").delete({
+      where: { id }
+    });
+    return { success: true };
+  },
+  async purgeItem(id) {
+    return strapi.db.query("plugin::recycle-bin.recycle-bin-item").delete({
+      where: { id }
+    });
+  }
+});
+const services = {
+  archive,
+  restore
+};
+const index = {
+  register,
+  bootstrap,
+  destroy,
+  config,
+  controllers,
+  routes,
+  services,
+  contentTypes,
+  policies,
+  middlewares
+};
+export {
+  index as default
+};

package/dist/server/src/bootstrap.d.ts

@@ -0,0 +1,5 @@
+import { Core } from '@strapi/strapi';
+declare const bootstrap: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => void;
+export default bootstrap;

package/dist/server/src/config/index.d.ts

@@ -0,0 +1,8 @@
+declare const _default: {
+    default: {
+        retentionDays: number;
+        excludedUids: string[];
+    };
+    validator(): void;
+};
+export default _default;

package/dist/server/src/content-types/index.d.ts

@@ -0,0 +1,53 @@
+declare const _default: {
+    'recycle-bin-item': {
+        schema: {
+            kind: string;
+            collectionName: string;
+            info: {
+                singularName: string;
+                pluralName: string;
+                displayName: string;
+            };
+            options: {
+                draftAndPublish: boolean;
+            };
+            pluginOptions: {
+                "content-manager": {
+                    visible: boolean;
+                };
+                "content-type-builder": {
+                    visible: boolean;
+                };
+            };
+            attributes: {
+                entityUid: {
+                    type: string;
+                    required: boolean;
+                };
+                recordDocumentId: {
+                    type: string;
+                    required: boolean;
+                    index: boolean;
+                };
+                title: {
+                    type: string;
+                };
+                payload: {
+                    type: string;
+                    required: boolean;
+                };
+                deletedBy: {
+                    type: string;
+                    relation: string;
+                    target: string;
+                };
+                deletedAt: {
+                    type: string;
+                    required: boolean;
+                    index: boolean;
+                };
+            };
+        };
+    };
+};
+export default _default;

package/dist/server/src/content-types/recycle-bin-item/schema.json.d.ts

@@ -0,0 +1,51 @@
+declare const _default: {
+  "kind": "collectionType",
+  "collectionName": "recycle_bin_items",
+  "info": {
+    "singularName": "recycle-bin-item",
+    "pluralName": "recycle-bin-items",
+    "displayName": "Recycle Bin Item"
+  },
+  "options": {
+    "draftAndPublish": false
+  },
+  "pluginOptions": {
+    "content-manager": {
+      "visible": false
+    },
+    "content-type-builder": {
+      "visible": false
+    }
+  },
+  "attributes": {
+    "entityUid": {
+      "type": "string",
+      "required": true
+    },
+    "recordDocumentId": {
+      "type": "string",
+      "required": true,
+      "index": true
+    },
+    "title": {
+      "type": "string"
+    },
+    "payload": {
+      "type": "json",
+      "required": true
+    },
+    "deletedBy": {
+      "type": "relation",
+      "relation": "oneToOne",
+      "target": "admin::user"
+    },
+    "deletedAt": {
+      "type": "datetime",
+      "required": true,
+      "index": true
+    }
+  }
+}
+;
+
+export default _default;

package/dist/server/src/controllers/index.d.ts

@@ -0,0 +1,10 @@
+declare const _default: {
+    recycleBin: ({ strapi }: {
+        strapi: import('@strapi/types/dist/core').Strapi;
+    }) => {
+        find(ctx: any): Promise<void>;
+        restore(ctx: any): Promise<any>;
+        purge(ctx: any): Promise<any>;
+    };
+};
+export default _default;

package/dist/server/src/controllers/recycle-bin.d.ts

@@ -0,0 +1,9 @@
+import { Core } from '@strapi/strapi';
+declare const _default: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => {
+    find(ctx: any): Promise<void>;
+    restore(ctx: any): Promise<any>;
+    purge(ctx: any): Promise<any>;
+};
+export default _default;

package/dist/server/src/destroy.d.ts

@@ -0,0 +1,5 @@
+import { Core } from '@strapi/strapi';
+declare const destroy: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => void;
+export default destroy;