@primershop/strapi-plugin-status-manager 0.0.15 → 0.0.16

package/dist/server/index.js

@@ -1,20 +1,752 @@
 'use strict';
 
-var bootstrap = require('./bootstrap.js');
-var index$3 = require('./content-types/index.js');
-var index$4 = require('./controllers/index.js');
-var register = require('./register.js');
-var index$2 = require('./routes/index.js');
-var index$1 = require('./services/index.js');
+var utils = require('@strapi/utils');
+
+var permissions = [
+    {
+        section: "plugins",
+        displayName: "Access Status Manager",
+        uid: "main",
+        pluginName: "primershop-status-manager"
+    },
+    {
+        section: "plugins",
+        displayName: "Create",
+        uid: "status.create",
+        subCategory: "status",
+        pluginName: "primershop-status-manager"
+    },
+    {
+        section: "plugins",
+        displayName: "Read",
+        uid: "status.read",
+        subCategory: "status",
+        pluginName: "primershop-status-manager",
+        aliases: [
+            {
+                actionId: "plugin::content-manager.explorer.read",
+                subjects: [
+                    "plugin::primershop-status-manager.status"
+                ]
+            }
+        ]
+    },
+    {
+        section: "plugins",
+        displayName: "Update",
+        uid: "status.update",
+        subCategory: "status",
+        pluginName: "primershop-status-manager"
+    },
+    {
+        section: "plugins",
+        displayName: "Delete",
+        uid: "status.delete",
+        subCategory: "status",
+        pluginName: "primershop-status-manager"
+    }
+];
+
+const bootstrap = async ({ strapi })=>{
+    try {
+        strapi.admin.services.permission.actionProvider.registerMany(permissions);
+        strapi.log.info(`[primershop-status-manager] Registered ${permissions.length} permission actions`);
+    } catch (error) {
+        strapi.log.error("[primershop-status-manager] Failed to register permissions:", error);
+        throw error;
+    }
+    // Register lifecycle hooks for status filtering
+    strapi.db?.lifecycles?.subscribe?.({
+        // catch all models
+        models: [
+            "*"
+        ],
+        async afterDelete (event) {
+            const modelUid = event?.model?.uid;
+            const deleted = event?.result;
+            const documentId = deleted?.documentId;
+            if (!modelUid || !documentId) return;
+            await strapi.db.query("plugin::primershop-status-manager.status-link").deleteMany({
+                where: {
+                    targetUid: modelUid,
+                    targetDocumentId: documentId
+                }
+            });
+        }
+    });
+};
+
+var status$1 = {
+    kind: "collectionType",
+    collectionName: "status",
+    info: {
+        singularName: "status",
+        pluralName: "statuses",
+        displayName: "Status",
+        description: "Status for products"
+    },
+    options: {
+        draftAndPublish: false
+    },
+    pluginOptions: {
+        "content-manager": {
+            visible: false
+        },
+        "content-type-builder": {
+            visible: false
+        }
+    },
+    attributes: {
+        name: {
+            type: "string",
+            minLength: 1,
+            maxLength: 50,
+            required: true,
+            configurable: false
+        },
+        published: {
+            type: "boolean",
+            default: false
+        },
+        order: {
+            type: "integer",
+            default: 0
+        },
+        links: {
+            type: "relation",
+            relation: "oneToMany",
+            target: "plugin::primershop-status-manager.status-link",
+            mappedBy: "status",
+            configurable: false
+        }
+    }
+};
+
+var statusLink = {
+    kind: "collectionType",
+    collectionName: "status_links",
+    info: {
+        singularName: "status-link",
+        pluralName: "status-links",
+        displayName: "Status Link",
+        description: "Association between any content type document and a single status"
+    },
+    options: {
+        draftAndPublish: false
+    },
+    pluginOptions: {
+        "content-manager": {
+            visible: false
+        },
+        "content-type-builder": {
+            visible: false
+        }
+    },
+    attributes: {
+        targetUid: {
+            type: "string",
+            required: true
+        },
+        targetDocumentId: {
+            type: "string",
+            required: true
+        },
+        status: {
+            type: "relation",
+            relation: "manyToOne",
+            target: "plugin::primershop-status-manager.status",
+            required: false,
+            configurable: false
+        }
+    }
+};
+
+var contentTypes = {
+    status: {
+        schema: status$1
+    },
+    "status-link": {
+        schema: statusLink
+    }
+};
+
+const content = ({ strapi })=>({
+        async getStatusForTarget (ctx) {
+            const requestParams = ctx.request.URL.searchParams;
+            const contentTypeUid = requestParams.get("contentTypeUid");
+            if (!strapi.getModel(contentTypeUid)) return ctx.notFound("Unknown contentTypeUid");
+            const contentDocumentId = requestParams.get("contentDocumentId");
+            const exists = await strapi.documents(contentTypeUid).findOne({
+                documentId: contentDocumentId
+            });
+            if (!exists) return ctx.notFound("Target document not found");
+            const link = await strapi.plugin("primershop-status-manager").service("statusLink").getForTarget(contentTypeUid, contentDocumentId);
+            return ctx.send({
+                status: link?.status ?? null
+            });
+        },
+        async setStatusForTarget (ctx) {
+            const { contentTypeUid, contentDocumentId, statusId } = ctx.request.body;
+            if (!strapi.getModel(contentTypeUid)) return ctx.notFound("Unknown contentTypeUid");
+            const exists = await strapi.documents(contentTypeUid).findOne({
+                documentId: contentDocumentId
+            });
+            if (!exists) return ctx.notFound("Target document not found");
+            const link = await strapi.plugin("primershop-status-manager").service("statusLink").setForTarget(contentTypeUid, contentDocumentId, statusId);
+            return ctx.send({
+                status: link.status
+            });
+        }
+    });
+
+const status = ({ strapi })=>({
+        async listStatuses (ctx) {
+            try {
+                const statuses = await strapi.documents("plugin::primershop-status-manager.status").findMany({
+                    sort: {
+                        order: "asc"
+                    }
+                });
+                return ctx.send(statuses);
+            } catch (err) {
+                console.error("❌ Status controller: find error:", err);
+                ctx.throw(500, err);
+            }
+        },
+        async create (ctx) {
+            try {
+                const { name, published = false } = ctx.request.body;
+                // Validate name (only Latin characters)
+                if (!/^[a-zA-Z\s]+$/.test(name)) {
+                    return ctx.badRequest("Status name must contain only Latin characters.");
+                }
+                // Get the highest order value
+                const existingStatuses = await strapi.documents("plugin::primershop-status-manager.status").findMany({
+                    orderBy: {
+                        order: "desc"
+                    },
+                    limit: 1
+                });
+                const newOrder = existingStatuses.length > 0 ? existingStatuses[0].order + 1 : 0;
+                // Create status
+                const newStatus = await strapi.documents("plugin::primershop-status-manager.status").create({
+                    data: {
+                        name,
+                        published,
+                        order: newOrder
+                    }
+                });
+                return ctx.send(newStatus);
+            } catch (error) {
+                console.error("Status controller: create error:", error);
+                ctx.internalServerError(`Error adding status: ${error}`);
+            }
+        },
+        async reorder (ctx) {
+            try {
+                const { statuses } = ctx.request.body;
+                if (!Array.isArray(statuses)) {
+                    return ctx.badRequest("Invalid data format");
+                }
+                // Update each status with new order
+                await Promise.all(statuses.map(({ documentId, order })=>strapi.documents("plugin::primershop-status-manager.status").update({
+                        documentId,
+                        data: {
+                            order
+                        }
+                    })));
+                ctx.send({
+                    message: "Order updated successfully"
+                });
+            } catch (error) {
+                console.error("Status controller: reorder error:", error);
+                ctx.internalServerError(`Error updating order: ${error}`);
+            }
+        },
+        async publish (ctx) {
+            try {
+                const { id } = ctx.params;
+                const { published } = ctx.request.body;
+                await strapi.documents("plugin::primershop-status-manager.status").update({
+                    documentId: id,
+                    data: {
+                        published
+                    }
+                });
+                ctx.send({
+                    message: "Status updated successfully"
+                });
+            } catch (error) {
+                console.error("Status controller: publish error:", error);
+                ctx.internalServerError(`Error updating status: ${error}`);
+            }
+        },
+        async delete (ctx) {
+            try {
+                const { statusId } = ctx.request.body;
+                if (!statusId) {
+                    return ctx.badRequest("Status ID is required.");
+                }
+                // Delete the status
+                await strapi.documents("plugin::primershop-status-manager.status").delete({
+                    documentId: statusId
+                });
+                return ctx.send({
+                    message: "Status deleted successfully"
+                });
+            } catch (error) {
+                console.error("Status controller: delete error:", error);
+                ctx.internalServerError(`Error deleting status: ${error}`);
+            }
+        }
+    });
+
+var controllers = {
+    status_controller: status,
+    content_controller: content
+};
+
+const PLUGIN_ID = "primershop-status-manager";
+
+var addStatusField = (async (context, next)=>{
+    const uid = context.uid;
+    if (!uid.includes("api::")) {
+        return next();
+    }
+    const result = await next();
+    let documentIds = [];
+    if (Array.isArray(result)) {
+        documentIds = result.map((doc)=>doc.documentId).filter(Boolean);
+    } else if (result && typeof result === "object" && "documentId" in result) {
+        documentIds = [
+            result.documentId
+        ].filter(Boolean);
+    }
+    if (documentIds.length === 0) {
+        return result;
+    }
+    try {
+        const statusLinks = await strapi.db.query("plugin::primershop-status-manager.status-link").findMany({
+            populate: {
+                status: true
+            },
+            where: {
+                targetUid: uid,
+                targetDocumentId: {
+                    $in: documentIds
+                }
+            }
+        });
+        if (Array.isArray(result)) {
+            result.forEach((doc)=>{
+                doc.statusField = statusLinks.find((link)=>link.targetDocumentId === doc.documentId)?.status || undefined;
+            });
+        }
+        if (result && typeof result === "object") {
+            result.statusField = statusLinks.find((link)=>link.targetDocumentId === result.documentId)?.status || undefined;
+        }
+    } catch (error) {
+        // If status enrichment fails, just return original result
+        console.error("primershop-status-manager: status enrichment error", error);
+    }
+    return result;
+});
+
+var filterByStatus = (async (context, next)=>{
+    const uid = context.uid;
+    if (!uid.includes("api::")) {
+        return next();
+    }
+    const paramKeys = Object.keys(context.params || {});
+    if (!paramKeys.includes("statusName")) {
+        return next();
+    }
+    const desiredStatus = context.params["statusName"];
+    if (!desiredStatus || desiredStatus === "all") return next();
+    const isValid = await strapi.plugin("primershop-status-manager").service("status").isValidStatus(desiredStatus);
+    if (!isValid) throw new utils.errors.ValidationError(`Invalid status: ${desiredStatus}`);
+    const status = await strapi.plugin("primershop-status-manager").service("status").getStatusByName(desiredStatus);
+    if (!status) {
+        throw new utils.errors.ValidationError(`Status not found: ${desiredStatus}`);
+    }
+    const statusLinks = await strapi.db.query("plugin::primershop-status-manager.status-link").findMany({
+        where: {
+            targetUid: uid,
+            status: status.id
+        },
+        select: [
+            "targetDocumentId"
+        ]
+    });
+    const allowedDocumentIds = statusLinks.map((link)=>link.targetDocumentId);
+    context.params["filters"] = {
+        ...context.params["filters"],
+        documentId: {
+            $in: allowedDocumentIds
+        }
+    };
+    return next();
+});
+
+var filterPublished = (async (context, next)=>{
+    const uid = context.uid;
+    if (!uid.includes("api::")) {
+        return next();
+    }
+    const params = context.params;
+    if (!params && !params["status"] || params["statusName"]) return next();
+    const unpublishedStatusLinks = await strapi.db.query("plugin::primershop-status-manager.status-link").findMany({
+        populate: {
+            status: true
+        },
+        where: {
+            targetUid: uid,
+            status: {
+                published: false
+            }
+        },
+        select: [
+            "targetDocumentId"
+        ]
+    });
+    const unpublishedDocumentIds = unpublishedStatusLinks.map((link)=>link.targetDocumentId);
+    context.params["filters"] = {
+        ...context.params["filters"],
+        documentId: {
+            $notIn: unpublishedDocumentIds
+        }
+    };
+    return next();
+});
+
+const register = ({ strapi })=>{
+    strapi.customFields.register({
+        name: "statusName",
+        plugin: PLUGIN_ID,
+        type: "string"
+    });
+    strapi.documents.use(filterByStatus);
+    strapi.documents.use(addStatusField);
+    strapi.documents.use(filterPublished);
+};
+
+var statusManagement = [
+    {
+        method: "GET",
+        path: "/statuses",
+        handler: "status_controller.listStatuses",
+        config: {
+            policies: [
+                {
+                    name: "admin::hasPermissions",
+                    config: {
+                        actions: [
+                            "plugin::primershop-status-manager.status.read"
+                        ]
+                    }
+                }
+            ]
+        },
+        description: "Get all statuses",
+        tag: {
+            plugin: "primershop-status-manager",
+            name: "statuses",
+            actionType: "findMany"
+        }
+    },
+    {
+        method: "POST",
+        path: "/status",
+        handler: "status_controller.create",
+        config: {
+            policies: [
+                {
+                    name: "admin::hasPermissions",
+                    config: {
+                        actions: [
+                            "plugin::primershop-status-manager.status.create"
+                        ]
+                    }
+                }
+            ]
+        },
+        description: "Create a new status",
+        tag: {
+            plugin: "primershop-status-manager",
+            name: "Status",
+            actionType: "create"
+        }
+    },
+    {
+        method: "PUT",
+        path: "/statuses/reorder",
+        handler: "status_controller.reorder",
+        config: {
+            policies: [
+                {
+                    name: "admin::hasPermissions",
+                    config: {
+                        actions: [
+                            "plugin::primershop-status-manager.status.update"
+                        ]
+                    }
+                }
+            ],
+            description: "Reorder statuses",
+            tag: {
+                plugin: "primershop-status-manager",
+                name: "Status",
+                actionType: "update"
+            }
+        }
+    },
+    {
+        method: "PUT",
+        path: "/statuses/delete",
+        handler: "status_controller.delete",
+        config: {
+            policies: [
+                {
+                    name: "admin::hasPermissions",
+                    config: {
+                        actions: [
+                            "plugin::primershop-status-manager.status.delete"
+                        ]
+                    }
+                }
+            ],
+            description: "Delete a status",
+            tag: {
+                plugin: "primershop-status-manager",
+                name: "Status",
+                actionType: "delete"
+            }
+        }
+    },
+    {
+        method: "PUT",
+        path: "/statuses/:id",
+        handler: "status_controller.publish",
+        config: {
+            policies: [
+                {
+                    name: "admin::hasPermissions",
+                    config: {
+                        actions: [
+                            "plugin::primershop-status-manager.status.update"
+                        ]
+                    }
+                }
+            ],
+            description: "Update status publish state",
+            tag: {
+                plugin: "primershop-status-manager",
+                name: "Status",
+                actionType: "update"
+            }
+        }
+    }
+];
+
+var contentManagement = [
+    {
+        method: "GET",
+        path: "/content-status",
+        handler: "content_controller.getStatusForTarget",
+        config: {
+            policies: [
+                {
+                    name: "admin::hasPermissions",
+                    config: {
+                        actions: [
+                            "plugin::primershop-status-manager.status.read"
+                        ]
+                    }
+                }
+            ]
+        }
+    },
+    {
+        method: "PUT",
+        path: "/content-status",
+        handler: "content_controller.setStatusForTarget",
+        config: {
+            policies: [
+                {
+                    name: "admin::hasPermissions",
+                    config: {
+                        actions: [
+                            "plugin::primershop-status-manager.status.update"
+                        ]
+                    }
+                }
+            ]
+        }
+    }
+];
+
+var routes = {
+    admin: {
+        type: "admin",
+        routes: [
+            ...statusManagement,
+            ...contentManagement
+        ]
+    }
+};
+
+const statusService = ({ strapi })=>({
+        async isValidStatus (code) {
+            try {
+                const row = await strapi.db.query("plugin::primershop-status-manager.status").findOne({
+                    where: {
+                        name: code
+                    },
+                    select: [
+                        "id"
+                    ]
+                });
+                return !!row;
+            } catch  {
+                return false;
+            }
+        },
+        async getStatusByName (name) {
+            return strapi.db.query("plugin::primershop-status-manager.status").findOne({
+                where: {
+                    name
+                }
+            });
+        },
+        isStatusEnabledFor (uid) {
+            return !!strapi.getModel(uid);
+        },
+        async find () {
+            const result = await strapi.db.query("plugin::primershop-status-manager.status").findMany({
+                orderBy: {
+                    order: "asc"
+                }
+            });
+            return result;
+        },
+        async findOne (id) {
+            const result = await strapi.db.query("plugin::primershop-status-manager.status").findOne({
+                where: {
+                    id
+                }
+            });
+            return result;
+        },
+        async createStatus (data) {
+            const result = await strapi.db.query("plugin::primershop-status-manager.status").create({
+                data: {
+                    name: data.name,
+                    published: data.published ?? false,
+                    order: data.order ?? 0
+                }
+            });
+            return result;
+        },
+        async findProductsByStatus (statusId) {
+            return strapi.db.query("api::product.product").findMany({
+                where: {
+                    status: statusId
+                }
+            });
+        },
+        async updateProductStatus (productId, statusId) {
+            return strapi.db.query("api::product.product").update({
+                where: {
+                    id: productId
+                },
+                data: {
+                    status: statusId
+                }
+            });
+        },
+        async delete (id) {
+            return strapi.db.query("plugin::primershop-status-manager.status").delete({
+                where: {
+                    id
+                }
+            });
+        },
+        async deleteStatus (statusId, replacementId) {
+            // Find status by documentId
+            const status = await strapi.db.query("plugin::primershop-status-manager.status").findOne({
+                where: {
+                    documentId: statusId
+                }
+            });
+            if (!status) {
+                throw new Error("Status not found");
+            }
+            if (replacementId) {
+                const replacementStatus = await strapi.db.query("plugin::primershop-status-manager.status").findOne({
+                    where: {
+                        documentId: replacementId
+                    }
+                });
+                if (!replacementStatus) {
+                    throw new Error("Replacement status not found");
+                }
+            }
+            // Delete the status
+            await strapi.db.query("plugin::primershop-status-manager.status").delete({
+                where: {
+                    documentId: statusId
+                }
+            });
+            return true;
+        }
+    });
+
+const statusLinkService = ({ strapi })=>({
+        async getForTarget (targetUid, targetDocumentId) {
+            const link = await strapi.db.query("plugin::primershop-status-manager.status-link").findOne({
+                where: {
+                    targetUid,
+                    targetDocumentId
+                },
+                populate: {
+                    status: true
+                }
+            });
+            return link ?? null;
+        },
+        async setForTarget (targetUid, targetDocumentId, statusDocumentId) {
+            // Create status link
+            await strapi.db.query("plugin::primershop-status-manager.status-link").deleteMany({
+                where: {
+                    targetUid,
+                    targetDocumentId
+                }
+            });
+            const created = await strapi.documents("plugin::primershop-status-manager.status-link").create({
+                data: {
+                    targetUid,
+                    targetDocumentId,
+                    status: {
+                        set: statusDocumentId
+                    }
+                }
+            });
+            return created;
+        }
+    });
+
+var services = {
+    status: statusService,
+    statusLink: statusLinkService
+};
 
 var index = {
     register,
-    controllers: index$4.controllers,
-    contentTypes: index$3,
-    routes: index$2.routes,
-    services: index$1.services,
+    controllers,
+    contentTypes,
+    routes,
+    services,
     bootstrap
 };
 
 module.exports = index;
-//# sourceMappingURL=index.js.map