@medusajs/notification 0.1.2

package/README.md

@@ -0,0 +1 @@
+# Notification Module

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+import { moduleDefinition } from "./module-definition";
+export * from "./types";
+export * from "./models";
+export * from "./services";
+export default moduleDefinition;

package/dist/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const module_definition_1 = require("./module-definition");
+__exportStar(require("./types"), exports);
+__exportStar(require("./models"), exports);
+__exportStar(require("./services"), exports);
+exports.default = module_definition_1.moduleDefinition;

package/dist/joiner-config.d.ts

@@ -0,0 +1,5 @@
+import { ModuleJoinerConfig } from "@medusajs/types";
+import { MapToConfig } from "@medusajs/utils";
+export declare const LinkableKeys: Record<string, string>;
+export declare const entityNameToLinkableKeysMap: MapToConfig;
+export declare const joinerConfig: ModuleJoinerConfig;

package/dist/joiner-config.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.joinerConfig = exports.entityNameToLinkableKeysMap = exports.LinkableKeys = void 0;
+const modules_sdk_1 = require("@medusajs/modules-sdk");
+const _models_1 = require("./models");
+exports.LinkableKeys = {
+    notification_id: _models_1.NotificationModel.name,
+};
+const entityLinkableKeysMap = {};
+Object.entries(exports.LinkableKeys).forEach(([key, value]) => {
+    entityLinkableKeysMap[value] ??= [];
+    entityLinkableKeysMap[value].push({
+        mapTo: key,
+        valueFrom: key.split("_").pop(),
+    });
+});
+exports.entityNameToLinkableKeysMap = entityLinkableKeysMap;
+exports.joinerConfig = {
+    serviceName: modules_sdk_1.Modules.NOTIFICATION,
+    primaryKeys: ["id"],
+    linkableKeys: exports.LinkableKeys,
+    alias: [
+        {
+            name: ["notification", "notifications"],
+            args: {
+                entity: _models_1.NotificationModel.name,
+            },
+        },
+    ],
+};

package/dist/loaders/providers.d.ts

@@ -0,0 +1,5 @@
+import { LoaderOptions, ModuleProvider, ModulesSdkTypes } from "@medusajs/types";
+declare const _default: ({ container, options, }: LoaderOptions<(ModulesSdkTypes.ModuleServiceInitializeOptions | ModulesSdkTypes.ModuleServiceInitializeCustomDataLayerOptions) & {
+    providers: ModuleProvider[];
+}>) => Promise<void>;
+export default _default;

package/dist/loaders/providers.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const modules_sdk_1 = require("@medusajs/modules-sdk");
+const utils_1 = require("@medusajs/utils");
+const _services_1 = require("../services");
+const _types_1 = require("../types");
+const awilix_1 = require("awilix");
+const registrationFn = async (klass, container, pluginOptions) => {
+    Object.entries(pluginOptions.config || []).map(([name, config]) => {
+        container.register({
+            [_types_1.NotificationProviderRegistrationPrefix + name]: (0, awilix_1.asFunction)((cradle) => new klass(cradle, config), {
+                lifetime: klass.LIFE_TIME || awilix_1.Lifetime.SINGLETON,
+            }),
+        });
+        container.registerAdd(_types_1.NotificationIdentifiersRegistrationName, (0, awilix_1.asValue)(name));
+    });
+};
+exports.default = async ({ container, options, }) => {
+    await (0, modules_sdk_1.moduleProviderLoader)({
+        container,
+        providers: options?.providers || [],
+        registerServiceFn: registrationFn,
+    });
+    await syncDatabaseProviders({
+        container,
+        providers: options?.providers || [],
+    });
+};
+async function syncDatabaseProviders({ container, providers, }) {
+    const providerServiceRegistrationKey = (0, utils_1.lowerCaseFirst)(_services_1.NotificationProviderService.name);
+    const providerService = container.resolve(providerServiceRegistrationKey);
+    const logger = container.resolve(utils_1.ContainerRegistrationKeys.LOGGER) ?? console;
+    const normalizedProviders = providers.map((provider) => {
+        const [name, config] = Object.entries(provider.options?.config)?.[0];
+        if (!name) {
+            throw new Error("An entry in the provider config is required to initialize notification providers");
+        }
+        const id = name;
+        return {
+            id,
+            handle: name,
+            name: config?.name ?? name,
+            is_enabled: true,
+            channels: config?.channels ?? [],
+        };
+    });
+    validateProviders(normalizedProviders);
+    try {
+        const providersInDb = await providerService.list({});
+        const providersToDisable = providersInDb.filter((dbProvider) => !normalizedProviders.some((normalizedProvider) => normalizedProvider.id === dbProvider.id));
+        const promises = [];
+        if (normalizedProviders.length) {
+            promises.push(providerService.upsert(normalizedProviders));
+        }
+        if (providersToDisable.length) {
+            promises.push(providerService.update(providersToDisable.map((p) => ({ id: p.id, is_enabled: false }))));
+        }
+        await (0, utils_1.promiseAll)(promises);
+    }
+    catch (error) {
+        logger.error(`Error syncing the notification providers: ${error.message}`);
+    }
+}
+function validateProviders(providers) {
+    const hasForChannel = {};
+    providers.forEach((provider) => {
+        provider.channels.forEach((channel) => {
+            if (hasForChannel[channel]) {
+                throw new Error(`Multiple providers are configured for the same channel: ${channel}`);
+            }
+            hasForChannel[channel] = true;
+        });
+    });
+}

package/dist/migrations/Migration20240509083918_InitialSetupMigration.d.ts

@@ -0,0 +1,4 @@
+import { Migration } from "@mikro-orm/migrations";
+export declare class Migration20240509083918_InitialSetupMigration extends Migration {
+    up(): Promise<void>;
+}

package/dist/migrations/Migration20240509083918_InitialSetupMigration.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Migration20240509083918_InitialSetupMigration = void 0;
+const migrations_1 = require("@mikro-orm/migrations");
+class Migration20240509083918_InitialSetupMigration extends migrations_1.Migration {
+    async up() {
+        this.addSql("drop table if exists notification");
+        this.addSql("drop table if exists notification_provider");
+        this.addSql('create table if not exists "notification_provider" ("id" text not null, "handle" text not null, "name" text not null, "is_enabled" boolean not null default true, "channels" text[] not null, constraint "notification_provider_pkey" primary key ("id"));');
+        this.addSql('create table if not exists "notification" ("id" text not null, "to" text not null, "channel" text not null, "template" text not null, "data" jsonb null, "trigger_type" text null, "resource_id" text null, "resource_type" text null, "receiver_id" text null, "original_notification_id" text null, "idempotency_key" text null, "external_id" text null, "provider_id" text null, "created_at" timestamptz not null default now(), constraint "notification_pkey" primary key ("id"));');
+        this.addSql('CREATE INDEX IF NOT EXISTS "IDX_notification_provider_id" ON "notification" (provider_id);');
+        this.addSql('CREATE INDEX IF NOT EXISTS "IDX_notification_idempotency_key" ON "notification" (idempotency_key);');
+        this.addSql('CREATE INDEX IF NOT EXISTS "IDX_notification_receiver_id" ON "notification" (receiver_id);');
+        this.addSql('alter table if exists "notification" add constraint "notification_provider_id_foreign" foreign key ("provider_id") references "notification_provider" ("id") on update cascade on delete set null;');
+    }
+}
+exports.Migration20240509083918_InitialSetupMigration = Migration20240509083918_InitialSetupMigration;

package/dist/models/index.d.ts

@@ -0,0 +1,2 @@
+export { default as NotificationModel } from "./notification";
+export { default as NotificationProvider } from "./notification-provider";

package/dist/models/index.js

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotificationProvider = exports.NotificationModel = void 0;
+var notification_1 = require("./notification");
+Object.defineProperty(exports, "NotificationModel", { enumerable: true, get: function () { return __importDefault(notification_1).default; } });
+var notification_provider_1 = require("./notification-provider");
+Object.defineProperty(exports, "NotificationProvider", { enumerable: true, get: function () { return __importDefault(notification_provider_1).default; } });

package/dist/models/notification-provider.d.ts

@@ -0,0 +1,12 @@
+import { Collection } from "@mikro-orm/core";
+import NotificationModel from "./notification";
+export default class NotificationProvider {
+    id: string;
+    handle: string;
+    name: string;
+    is_enabled: boolean;
+    channels: string[];
+    notifications: Collection<NotificationModel, object>;
+    onCreate(): void;
+    onInit(): void;
+}

package/dist/models/notification-provider.js

@@ -0,0 +1,72 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@medusajs/utils");
+const core_1 = require("@mikro-orm/core");
+const notification_1 = __importDefault(require("./notification"));
+let NotificationProvider = class NotificationProvider {
+    constructor() {
+        this.is_enabled = true;
+        this.notifications = new core_1.Collection(this);
+    }
+    onCreate() {
+        this.id = (0, utils_1.generateEntityId)(this.id, "notpro");
+    }
+    onInit() {
+        this.id = (0, utils_1.generateEntityId)(this.id, "notpro");
+    }
+};
+__decorate([
+    (0, core_1.PrimaryKey)({ columnType: "text" }),
+    __metadata("design:type", String)
+], NotificationProvider.prototype, "id", void 0);
+__decorate([
+    (0, core_1.Property)({ columnType: "text" }),
+    __metadata("design:type", String)
+], NotificationProvider.prototype, "handle", void 0);
+__decorate([
+    (0, core_1.Property)({ columnType: "text" }),
+    __metadata("design:type", String)
+], NotificationProvider.prototype, "name", void 0);
+__decorate([
+    (0, core_1.Property)({ columnType: "boolean", defaultRaw: "true" }),
+    __metadata("design:type", Boolean)
+], NotificationProvider.prototype, "is_enabled", void 0);
+__decorate([
+    (0, core_1.Property)({ type: core_1.ArrayType }),
+    __metadata("design:type", Array)
+], NotificationProvider.prototype, "channels", void 0);
+__decorate([
+    (0, core_1.OneToMany)({
+        entity: () => notification_1.default,
+        mappedBy: (notification) => notification.provider_id,
+    }),
+    __metadata("design:type", Object)
+], NotificationProvider.prototype, "notifications", void 0);
+__decorate([
+    (0, core_1.BeforeCreate)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], NotificationProvider.prototype, "onCreate", null);
+__decorate([
+    (0, core_1.OnInit)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], NotificationProvider.prototype, "onInit", null);
+NotificationProvider = __decorate([
+    (0, core_1.Entity)()
+], NotificationProvider);
+exports.default = NotificationProvider;

package/dist/models/notification.d.ts

@@ -0,0 +1,19 @@
+import NotificationProvider from "./notification-provider";
+export default class NotificationModel {
+    id: string;
+    to: string;
+    channel: string;
+    template: string;
+    data: Record<string, unknown> | null;
+    trigger_type?: string | null;
+    resource_id?: string | null;
+    resource_type?: string | null;
+    receiver_id?: string | null;
+    original_notification_id?: string | null;
+    idempotency_key?: string | null;
+    external_id?: string | null;
+    provider_id: string;
+    provider: NotificationProvider;
+    created_at: Date;
+    onCreate(): void;
+}

package/dist/models/notification.js

@@ -0,0 +1,122 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@medusajs/utils");
+const core_1 = require("@mikro-orm/core");
+const notification_provider_1 = __importDefault(require("./notification-provider"));
+const NotificationProviderIdIndex = (0, utils_1.createPsqlIndexStatementHelper)({
+    tableName: "notification",
+    columns: "provider_id",
+});
+const NotificationIdempotencyKeyIndex = (0, utils_1.createPsqlIndexStatementHelper)({
+    tableName: "notification",
+    columns: "idempotency_key",
+});
+const NotificationReceiverIdIndex = (0, utils_1.createPsqlIndexStatementHelper)({
+    tableName: "notification",
+    columns: "receiver_id",
+});
+// We don't need to support soft deletes here as this information is mainly used for auditing purposes.
+// Instead, we probably want to have a TTL for each entry, so we don't bloat the DB (and also for GDPR reasons if TTL < 30 days).
+let NotificationModel = class NotificationModel {
+    onCreate() {
+        this.id = (0, utils_1.generateEntityId)(this.id, "noti");
+        this.provider_id ??= this.provider_id ?? this.provider?.id;
+    }
+};
+__decorate([
+    (0, core_1.PrimaryKey)({ columnType: "text" }),
+    __metadata("design:type", String)
+], NotificationModel.prototype, "id", void 0);
+__decorate([
+    (0, core_1.Property)({ columnType: "text" }),
+    __metadata("design:type", String)
+], NotificationModel.prototype, "to", void 0);
+__decorate([
+    (0, core_1.Property)({ columnType: "text" }),
+    __metadata("design:type", String)
+], NotificationModel.prototype, "channel", void 0);
+__decorate([
+    (0, core_1.Property)({ columnType: "text" }),
+    __metadata("design:type", String)
+], NotificationModel.prototype, "template", void 0);
+__decorate([
+    (0, core_1.Property)({ columnType: "jsonb", nullable: true }),
+    __metadata("design:type", Object)
+], NotificationModel.prototype, "data", void 0);
+__decorate([
+    (0, core_1.Property)({ columnType: "text", nullable: true }),
+    __metadata("design:type", Object)
+], NotificationModel.prototype, "trigger_type", void 0);
+__decorate([
+    (0, core_1.Property)({ columnType: "text", nullable: true }),
+    __metadata("design:type", Object)
+], NotificationModel.prototype, "resource_id", void 0);
+__decorate([
+    (0, core_1.Property)({ columnType: "text", nullable: true }),
+    __metadata("design:type", Object)
+], NotificationModel.prototype, "resource_type", void 0);
+__decorate([
+    (0, core_1.Property)({ columnType: "text", nullable: true }),
+    __metadata("design:type", Object)
+], NotificationModel.prototype, "receiver_id", void 0);
+__decorate([
+    (0, core_1.Property)({ columnType: "text", nullable: true }),
+    __metadata("design:type", Object)
+], NotificationModel.prototype, "original_notification_id", void 0);
+__decorate([
+    (0, core_1.Property)({ columnType: "text", nullable: true }),
+    __metadata("design:type", Object)
+], NotificationModel.prototype, "idempotency_key", void 0);
+__decorate([
+    (0, core_1.Property)({ columnType: "text", nullable: true }),
+    __metadata("design:type", Object)
+], NotificationModel.prototype, "external_id", void 0);
+__decorate([
+    (0, core_1.ManyToOne)(() => notification_provider_1.default, {
+        columnType: "text",
+        fieldName: "provider_id",
+        mapToPk: true,
+        nullable: true,
+        onDelete: "set null",
+    }),
+    __metadata("design:type", String)
+], NotificationModel.prototype, "provider_id", void 0);
+__decorate([
+    (0, core_1.ManyToOne)(() => notification_provider_1.default, { persist: false }),
+    __metadata("design:type", notification_provider_1.default)
+], NotificationModel.prototype, "provider", void 0);
+__decorate([
+    (0, core_1.Property)({
+        onCreate: () => new Date(),
+        columnType: "timestamptz",
+        defaultRaw: "now()",
+    }),
+    __metadata("design:type", Date)
+], NotificationModel.prototype, "created_at", void 0);
+__decorate([
+    (0, core_1.BeforeCreate)(),
+    (0, core_1.OnInit)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], NotificationModel.prototype, "onCreate", null);
+NotificationModel = __decorate([
+    NotificationProviderIdIndex.MikroORMIndex(),
+    NotificationIdempotencyKeyIndex.MikroORMIndex(),
+    NotificationReceiverIdIndex.MikroORMIndex(),
+    (0, core_1.Entity)({ tableName: "notification" })
+    // Since there is a native `Notification` type, we have to call this something else here and in a couple of other places.
+], NotificationModel);
+exports.default = NotificationModel;

package/dist/module-definition.d.ts

@@ -0,0 +1,2 @@
+import { ModuleExports } from "@medusajs/types";
+export declare const moduleDefinition: ModuleExports;

package/dist/module-definition.js

@@ -0,0 +1,14 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.moduleDefinition = void 0;
+const _services_1 = require("./services");
+const providers_1 = __importDefault(require("./loaders/providers"));
+const service = _services_1.NotificationModuleService;
+const loaders = [providers_1.default];
+exports.moduleDefinition = {
+    service,
+    loaders,
+};

package/dist/services/index.d.ts

@@ -0,0 +1,2 @@
+export { default as NotificationModuleService } from "./notification-module-service";
+export { default as NotificationProviderService } from "./notification-provider";

package/dist/services/index.js

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotificationProviderService = exports.NotificationModuleService = void 0;
+var notification_module_service_1 = require("./notification-module-service");
+Object.defineProperty(exports, "NotificationModuleService", { enumerable: true, get: function () { return __importDefault(notification_module_service_1).default; } });
+var notification_provider_1 = require("./notification-provider");
+Object.defineProperty(exports, "NotificationProviderService", { enumerable: true, get: function () { return __importDefault(notification_provider_1).default; } });

package/dist/services/notification-module-service.d.ts

@@ -0,0 +1,26 @@
+import { Context, DAL, NotificationTypes, INotificationModuleService, InternalModuleDeclaration, ModuleJoinerConfig, ModulesSdkTypes } from "@medusajs/types";
+import { ModulesSdkUtils } from "@medusajs/utils";
+import NotificationProviderService from "./notification-provider";
+import { NotificationModel } from "../models";
+type InjectedDependencies = {
+    baseRepository: DAL.RepositoryService;
+    notificationModelService: ModulesSdkTypes.InternalModuleService<any>;
+    notificationProviderService: NotificationProviderService;
+};
+declare const NotificationModuleService_base: new (container: InjectedDependencies) => ModulesSdkUtils.AbstractModuleService<InjectedDependencies, NotificationTypes.NotificationDTO, {
+    NotificationProvider: {
+        dto: NotificationTypes.NotificationProviderDTO;
+    };
+}>;
+export default class NotificationModuleService<TEntity extends NotificationModel = NotificationModel> extends NotificationModuleService_base implements INotificationModuleService {
+    protected readonly moduleDeclaration: InternalModuleDeclaration;
+    protected baseRepository_: DAL.RepositoryService;
+    protected readonly notificationService_: ModulesSdkTypes.InternalModuleService<TEntity>;
+    protected readonly notificationProviderService_: NotificationProviderService;
+    constructor({ baseRepository, notificationModelService, notificationProviderService, }: InjectedDependencies, moduleDeclaration: InternalModuleDeclaration);
+    __joinerConfig(): ModuleJoinerConfig;
+    create(data: NotificationTypes.CreateNotificationDTO[], sharedContext?: Context): Promise<NotificationTypes.NotificationDTO[]>;
+    create(data: NotificationTypes.CreateNotificationDTO, sharedContext?: Context): Promise<NotificationTypes.NotificationDTO>;
+    protected create_(data: NotificationTypes.CreateNotificationDTO[], sharedContext?: Context): Promise<TEntity[]>;
+}
+export {};

package/dist/services/notification-module-service.js

@@ -0,0 +1,79 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@medusajs/utils");
+const joiner_config_1 = require("../joiner-config");
+const _models_1 = require("../models");
+const generateMethodForModels = [_models_1.NotificationProvider];
+class NotificationModuleService extends utils_1.ModulesSdkUtils.abstractModuleServiceFactory(_models_1.NotificationModel, generateMethodForModels, joiner_config_1.entityNameToLinkableKeysMap) {
+    constructor({ baseRepository, notificationModelService, notificationProviderService, }, moduleDeclaration) {
+        // @ts-ignore
+        super(...arguments);
+        this.moduleDeclaration = moduleDeclaration;
+        this.baseRepository_ = baseRepository;
+        this.notificationService_ = notificationModelService;
+        this.notificationProviderService_ = notificationProviderService;
+    }
+    __joinerConfig() {
+        return joiner_config_1.joinerConfig;
+    }
+    async create(data, sharedContext = {}) {
+        const normalized = Array.isArray(data) ? data : [data];
+        const createdNotifications = await this.create_(normalized, sharedContext);
+        const serialized = await this.baseRepository_.serialize(createdNotifications);
+        return Array.isArray(data) ? serialized : serialized[0];
+    }
+    async create_(data, sharedContext = {}) {
+        if (!data.length) {
+            return [];
+        }
+        // TODO: At this point we should probably take a lock with the idempotency keys so we don't have race conditions.
+        // Also, we should probably rely on Redis for this instead of the database.
+        const idempotencyKeys = data
+            .map((entry) => entry.idempotency_key)
+            .filter(Boolean);
+        const alreadySentNotifications = await this.notificationService_.list({
+            idempotency_key: idempotencyKeys,
+        }, { take: null }, sharedContext);
+        const existsMap = new Map(alreadySentNotifications.map((n) => [n.idempotency_key, true]));
+        const notificationsToProcess = data.filter((entry) => !existsMap.has(entry.idempotency_key));
+        const notificationsToCreate = await (0, utils_1.promiseAll)(notificationsToProcess.map(async (entry) => {
+            const provider = await this.notificationProviderService_.getProviderForChannel(entry.channel);
+            if (!provider) {
+                throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_FOUND, `Could not find a notification provider for channel: ${entry.channel}`);
+            }
+            const res = await this.notificationProviderService_.send(provider, entry);
+            return { ...entry, provider_id: provider.id, external_id: res.id };
+        }));
+        // Currently we store notifications after they are sent, which might result in a notification being sent that is not registered in the database.
+        // If necessary, we can switch to a two-step process where we first create the notification, send it, and update it after it being sent.
+        const createdNotifications = await this.notificationService_.create(notificationsToCreate, sharedContext);
+        return createdNotifications;
+    }
+}
+exports.default = NotificationModuleService;
+__decorate([
+    (0, utils_1.InjectManager)("baseRepository_"),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], NotificationModuleService.prototype, "create", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)("baseRepository_"),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array, Object]),
+    __metadata("design:returntype", Promise)
+], NotificationModuleService.prototype, "create_", null);

package/dist/services/notification-provider.d.ts

@@ -0,0 +1,17 @@
+import { DAL, NotificationTypes } from "@medusajs/types";
+import { NotificationProvider } from "../models";
+import { NotificationProviderRegistrationPrefix } from "../types";
+type InjectedDependencies = {
+    notificationProviderRepository: DAL.RepositoryService;
+    [key: `${typeof NotificationProviderRegistrationPrefix}${string}`]: NotificationTypes.INotificationProvider;
+};
+declare const NotificationProviderService_base: new <TEntity extends object = any>(container: InjectedDependencies) => import("@medusajs/types").InternalModuleService<TEntity, InjectedDependencies>;
+export default class NotificationProviderService extends NotificationProviderService_base {
+    protected readonly notificationProviderRepository_: DAL.RepositoryService<NotificationProvider>;
+    protected providersCache: Map<string, NotificationProvider>;
+    constructor(container: InjectedDependencies);
+    protected retrieveProviderRegistration(providerId: string): NotificationTypes.INotificationProvider;
+    getProviderForChannel(channel: string): Promise<NotificationProvider | undefined>;
+    send(provider: NotificationProvider, notification: NotificationTypes.ProviderSendNotificationDTO): Promise<NotificationTypes.ProviderSendNotificationResultsDTO>;
+}
+export {};

package/dist/services/notification-provider.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@medusajs/utils");
+const medusa_core_utils_1 = require("medusa-core-utils");
+const _models_1 = require("../models");
+const _types_1 = require("../types");
+class NotificationProviderService extends utils_1.ModulesSdkUtils.internalModuleServiceFactory(_models_1.NotificationProvider) {
+    constructor(container) {
+        super(container);
+        this.notificationProviderRepository_ =
+            container.notificationProviderRepository;
+    }
+    retrieveProviderRegistration(providerId) {
+        try {
+            return this.__container__[`${_types_1.NotificationProviderRegistrationPrefix}${providerId}`];
+        }
+        catch (err) {
+            throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.NOT_FOUND, `Could not find a notification provider with id: ${providerId}`);
+        }
+    }
+    async getProviderForChannel(channel) {
+        if (!this.providersCache) {
+            const providers = await this.notificationProviderRepository_.find();
+            this.providersCache = new Map(providers.flatMap((provider) => provider.channels.map((c) => [c, provider])));
+        }
+        return this.providersCache.get(channel);
+    }
+    async send(provider, notification) {
+        const providerHandler = this.retrieveProviderRegistration(provider.id);
+        return await providerHandler.send(notification);
+    }
+}
+exports.default = NotificationProviderService;

package/dist/types/index.d.ts

@@ -0,0 +1,23 @@
+import { Logger, ModuleProviderExports, ModuleServiceInitializeOptions } from "@medusajs/types";
+export type InitializeModuleInjectableDependencies = {
+    logger?: Logger;
+};
+export declare const NotificationIdentifiersRegistrationName = "notification_providers_identifier";
+export declare const NotificationProviderRegistrationPrefix = "np_";
+export type NotificationModuleOptions = Partial<ModuleServiceInitializeOptions> & {
+    /**
+     * Providers to be registered
+     */
+    providers?: {
+        /**
+         * The module provider to be registered
+         */
+        resolve: string | ModuleProviderExports;
+        options: {
+            /**
+             * key value pair of the provider name and the configuration to be passed to the provider constructor
+             */
+            config: Record<string, unknown>;
+        };
+    }[];
+};

package/dist/types/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotificationProviderRegistrationPrefix = exports.NotificationIdentifiersRegistrationName = void 0;
+exports.NotificationIdentifiersRegistrationName = "notification_providers_identifier";
+exports.NotificationProviderRegistrationPrefix = "np_";

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@medusajs/notification",
+  "version": "0.1.2",
+  "description": "Medusa Notification module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=16"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/medusajs/medusa",
+    "directory": "packages/modules/notification"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "author": "Medusa",
+  "license": "MIT",
+  "scripts": {
+    "watch": "tsc --build --watch",
+    "watch:test": "tsc --build tsconfig.spec.json --watch",
+    "prepublishOnly": "cross-env NODE_ENV=production tsc --build && tsc-alias -p tsconfig.json",
+    "build": "rimraf dist && tsc --build && tsc-alias -p tsconfig.json",
+    "test": "jest --runInBand --bail --forceExit --passWithNoTests -- src",
+    "test:integration": "jest --forceExit -- integration-tests/**/__tests__/**/*.spec.ts",
+    "migration:generate": " MIKRO_ORM_CLI=./mikro-orm.config.dev.ts mikro-orm migration:generate",
+    "migration:initial": " MIKRO_ORM_CLI=./mikro-orm.config.dev.ts mikro-orm migration:create --initial -n InitialSetupMigration",
+    "migration:create": " MIKRO_ORM_CLI=./mikro-orm.config.dev.ts mikro-orm migration:create",
+    "migration:up": " MIKRO_ORM_CLI=./mikro-orm.config.dev.ts mikro-orm migration:up",
+    "orm:cache:clear": " MIKRO_ORM_CLI=./mikro-orm.config.dev.ts mikro-orm cache:clear"
+  },
+  "devDependencies": {
+    "@mikro-orm/cli": "5.9.7",
+    "cross-env": "^5.2.1",
+    "jest": "^29.6.3",
+    "medusa-test-utils": "^1.1.44",
+    "rimraf": "^3.0.2",
+    "ts-jest": "^29.1.1",
+    "ts-node": "^10.9.1",
+    "tsc-alias": "^1.8.6",
+    "typescript": "^5.1.6"
+  },
+  "dependencies": {
+    "@medusajs/modules-sdk": "^1.12.11",
+    "@medusajs/types": "^1.11.16",
+    "@medusajs/utils": "^1.11.9",
+    "@mikro-orm/core": "5.9.7",
+    "@mikro-orm/migrations": "5.9.7",
+    "@mikro-orm/postgresql": "5.9.7",
+    "awilix": "^8.0.0",
+    "dotenv": "^16.4.5",
+    "knex": "2.4.2"
+  }
+}