@codee-sh/medusa-plugin-notification-emails 0.2.1 → 1.0.1

package/.medusa/server/src/modules/mpn-builder/service.js

@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@medusajs/framework/utils");
+const models_1 = require("./models");
+const email_template_service_1 = require("./services-local/email-template-service");
+const slack_template_service_1 = require("./services-local/slack-template-service");
+const constants_1 = require("./types/constants");
+class MpnBuilderService extends (0, utils_1.MedusaService)({
+    MpnBuilderTemplate: models_1.MpnBuilderTemplate,
+    MpnBuilderTemplateBlock: models_1.MpnBuilderTemplateBlock,
+}) {
+    constructor({ logger }, options) {
+        super(...arguments);
+        this.templateServices_ = new Map();
+        this.logger_ = logger;
+        this.options_ = options || {};
+        // Initialize default templates
+        this.initializeTemplateServices();
+        // Initialize extended services (custom handlers and templates)
+        // Note: templates with import paths will be loaded asynchronously
+        this.initializeExtendedServices().catch((error) => {
+            this.logger_.error(`Failed to initialize extended services: ${error?.message || "Unknown error"}`);
+        });
+    }
+    /**
+     * Initialize template services from defaults and options
+     *
+     * @returns void
+     */
+    initializeTemplateServices() {
+        const defaultTemplateServices = [
+            new email_template_service_1.EmailTemplateService(),
+            new slack_template_service_1.SlackTemplateService(),
+        ];
+        defaultTemplateServices.forEach((templateService) => {
+            this.templateServices_.set(templateService.id, {
+                templateService: templateService,
+                enabled: true,
+            });
+            this.logger_.info(`Template service for ${templateService.id} registered`);
+        });
+    }
+    /**
+     * Initialize extended actions (custom handlers and templates)
+     * Handles both custom handler registration and template loading
+     *
+     * @returns Promise<void>
+     */
+    async initializeExtendedServices() {
+        const extendedServices = this.options_.extend?.services || [];
+        await Promise.all(extendedServices.map(async (serviceConfig) => {
+            // 2. Register templates (for existing or newly registered handler)
+            if (serviceConfig.templates) {
+                const handlerData = this.getTemplateService(serviceConfig.id);
+                if (!handlerData) {
+                    this.logger_.warn(`Cannot register templates for "${serviceConfig.id}" - handler not found`);
+                    return;
+                }
+                const { templateService } = handlerData;
+                if (!templateService.registerTemplate) {
+                    this.logger_.warn(`Handler "${serviceConfig.id}" does not support template registration`);
+                    return;
+                }
+                await Promise.all(serviceConfig.templates.map(async (template) => {
+                    const templateName = template.name;
+                    const templateValue = template.path;
+                    let renderer = templateValue;
+                    try {
+                        const templateModule = await import(templateValue);
+                        const template = templateModule.default;
+                        // renderer = template?.default || template
+                        renderer = template?.default || templateModule;
+                        if (!renderer) {
+                            this.logger_.warn(`Template module from "${templateValue}" does not export a default function or expected named export`);
+                            return;
+                        }
+                    }
+                    catch (error) {
+                        this.logger_.warn(`Failed to load template from "${templateValue}": ${error?.message || "Unknown error"}`);
+                        return;
+                    }
+                    if (templateName) {
+                        templateService.registerTemplate(templateName, renderer, "external");
+                        this.logger_.info(`Custom template "${templateName}" registered for handler "${serviceConfig.id}"`);
+                    }
+                }));
+            }
+        }));
+    }
+    /**
+     * Get template types
+     *
+     * @returns Array of template types with key, value, and name
+     */
+    getTemplateTypes() {
+        return [
+            {
+                id: constants_1.TEMPLATE_TYPES.DB_TEMPLATE,
+                name: constants_1.TEMPLATE_TYPES_NAMES.DB_TEMPLATE,
+            },
+            {
+                id: constants_1.TEMPLATE_TYPES.SYSTEM_TEMPLATE,
+                name: constants_1.TEMPLATE_TYPES_NAMES.SYSTEM_TEMPLATE,
+            },
+            {
+                id: constants_1.TEMPLATE_TYPES.EXTERNAL_TEMPLATE,
+                name: constants_1.TEMPLATE_TYPES_NAMES.EXTERNAL_TEMPLATE,
+            },
+        ];
+    }
+    /**
+     * Get template services map
+     *
+     * @returns Map of template services
+     */
+    getTemplateServices() {
+        return this.templateServices_;
+    }
+    /**
+     * Get template service by ID for the admin panel form
+     *
+     * @param templateServiceId - Template service ID
+     * @returns Template service
+     */
+    getTemplateService(templateServiceId) {
+        const templateServices = this.getTemplateServices();
+        return templateServices.get(templateServiceId);
+    }
+    /**
+     * List all registered template services (e.g., email, slack)
+     *
+     * @param type - Optional type to filter by service ID
+     * @returns Array of template service configurations
+     */
+    listTemplateServices(type) {
+        let templates = this.getTemplateServices();
+        if (type) {
+            const templateService = templates.get(type);
+            const template = templateService?.templateService;
+            const enabled = templateService?.enabled ?? true;
+            const templateBlocks = template?.blocks || [];
+            return [
+                {
+                    id: template?.id,
+                    label: template?.label,
+                    description: template?.description,
+                    configComponentKey: template?.configComponentKey,
+                    blocks: templateBlocks,
+                    enabled: enabled,
+                }
+            ];
+        }
+        return Array.from(templates.values()).map((template) => {
+            let blocks = template.templateService.blocks || [];
+            return {
+                id: template.templateService.id,
+                label: template.templateService.label,
+                description: template.templateService.description,
+                configComponentKey: template.templateService.configComponentKey,
+                blocks: blocks,
+                enabled: template.enabled,
+            };
+        });
+    }
+}
+exports.default = MpnBuilderService;
+//# sourceMappingURL=data:application/json;base64,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

package/.medusa/server/src/modules/mpn-builder/services-local/base-template-service.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseTemplateService = void 0;
+const constants_1 = require("../types/constants");
+const utils_1 = require("../../../utils");
+/**
+ * Base action service class
+ *
+ * @param id - Action ID (default: "base")
+ * @param label - Template label (default: "Base")
+ * @param description - Template description (default: "")
+ * @param configComponentKey - Template config component key (default: "BaseConfigComponent")
+ * @param blocks - Template blocks (default: [])
+ */
+class BaseTemplateService {
+    constructor() {
+        this.id = "base";
+        this.label = "Base";
+        this.description = "";
+        this.configComponentKey = "BaseConfigComponent";
+        // Fields for the Template configuration rendered in the admin panel then saved in the metadata config
+        this.blocks = [];
+        // Template registry - each service manages its own templates
+        this.templates_ = new Map();
+    }
+    /**
+     * Register a template for this service
+     * @param name - Template name
+     * @param renderer - Template renderer function
+     * @param type - Template type (default: "system")
+     */
+    registerTemplate(name, renderer, type = constants_1.TEMPLATE_TYPES.SYSTEM_TEMPLATE) {
+        this.templates_.set(name, { renderer, type: type });
+    }
+    /**
+     * Get template by name
+     *
+     * @param name - Template name
+     * @returns Template renderer
+     * @throws Error if template not found
+     */
+    getTemplate(name) {
+        const template = this.templates_.get(name);
+        if (!template) {
+            throw new Error(`Template "${name}" not found. Available templates: ${Array.from(this.templates_.keys()).join(", ")}`);
+        }
+        return template.renderer;
+    }
+    /**
+     * Get templates by type
+     * @param type - Template type (TEMPLATE_TYPES.SYSTEM_TEMPLATE or TEMPLATE_TYPES.EXTERNAL_TEMPLATE)
+     * @returns Array of templates matching the specified type
+     */
+    getTemplatesByType(type) {
+        return Array.from(this.templates_.entries())
+            .filter(([_, renderer]) => renderer.type === type)
+            .map(([name, renderer]) => ({
+            id: name,
+            name,
+            label: name,
+            description: null,
+            channel: this.id,
+            is_system: type === constants_1.TEMPLATE_TYPES.SYSTEM_TEMPLATE,
+            is_active: true,
+            type: renderer.type,
+            blocks: renderer.renderer?.getConfig?.()?.blocks || [],
+        }));
+    }
+    /**
+     * Get system templates (type: "system")
+     * @returns Array of system templates
+     */
+    getSystemTemplates() {
+        return this.getTemplatesByType(constants_1.TEMPLATE_TYPES.SYSTEM_TEMPLATE);
+    }
+    /**
+     * Get external templates (type: "external")
+     * @returns Array of external templates
+     */
+    getExternalTemplates() {
+        return this.getTemplatesByType(constants_1.TEMPLATE_TYPES.EXTERNAL_TEMPLATE);
+    }
+    /**
+     * Prepare template data.
+     *
+     * This method prepares the data for the template renderer.
+     * Merge translations from template config and options (if provided),
+     * then interpolate blocks using the interpolate function.
+     *
+     * @param params - Parameters object
+     * @returns Prepared template data
+     */
+    prepareData(params) {
+        // Get locale from options or default to "en"
+        const locale = params.options?.locale || "en";
+        // Get registered template
+        const template = this.getTemplate(params.templateName);
+        const config = (template)?.getConfig?.() || {};
+        const configTranslations = config?.translations || {};
+        const configBlocks = config?.blocks || [];
+        const optionsBlocks = params.options?.blocks || []; // blocks from data in mpn builder
+        const optionsTranslations = params.options?.translations;
+        // If blocks are not provided in options, use basic blocks from config
+        const blocks = optionsBlocks.length > 0
+            ? optionsBlocks
+            : configBlocks;
+        // Merge translations
+        const mergedTranslations = (0, utils_1.mergeTranslations)(configTranslations, optionsTranslations);
+        // Create translator function
+        const translator = (0, utils_1.createTranslator)(locale, mergedTranslations);
+        // Interpolate blocks using the interpolate function
+        const interpolatedBlocks = blocks.length > 0
+            ? this.interpolateFunction(blocks, params.data, translator)
+            : blocks;
+        return {
+            template,
+            translator,
+            blocks: interpolatedBlocks,
+        };
+    }
+}
+exports.BaseTemplateService = BaseTemplateService;
+//# sourceMappingURL=data:application/json;base64,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