@medusajs/user 0.0.1 → 0.0.2-next-20240319121007

package/dist/joiner-config.d.ts

@@ -2,6 +2,7 @@ import { MapToConfig } from "@medusajs/utils";
 import { ModuleJoinerConfig } from "@medusajs/types";
 export declare const LinkableKeys: {
     user_id: string;
+    invite_id: string;
 };
 export declare const entityNameToLinkableKeysMap: MapToConfig;
 export declare const joinerConfig: ModuleJoinerConfig;

package/dist/joiner-config.js

@@ -5,6 +5,7 @@ const _models_1 = require("./models");
 const modules_sdk_1 = require("@medusajs/modules-sdk");
 exports.LinkableKeys = {
     user_id: _models_1.User.name,
+    invite_id: _models_1.Invite.name,
 };
 const entityLinkableKeysMap = {};
 Object.entries(exports.LinkableKeys).forEach(([key, value]) => {
@@ -19,10 +20,19 @@ exports.joinerConfig = {
     serviceName: modules_sdk_1.Modules.USER,
     primaryKeys: ["id"],
     linkableKeys: exports.LinkableKeys,
-    alias: {
-        name: ["user", "users"],
-        args: {
-            entity: _models_1.User.name,
+    alias: [
+        {
+            name: ["user", "users"],
+            args: {
+                entity: _models_1.User.name,
+            },
         },
-    },
+        {
+            name: ["invite", "invites"],
+            args: {
+                entity: _models_1.Invite.name,
+                methodSuffix: "Invites",
+            },
+        },
+    ],
 };

package/dist/migrations/Migration20240214033943.d.ts

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

package/dist/migrations/Migration20240214033943.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Migration20240214033943 = void 0;
+const utils_1 = require("@medusajs/utils");
+const migrations_1 = require("@mikro-orm/migrations");
+class Migration20240214033943 extends migrations_1.Migration {
+    async up() {
+        this.addSql('create table if not exists "invite" ("id" text not null, "email" text not null, "accepted" boolean not null default false, "token" text not null, "expires_at" timestamptz not null, "metadata" jsonb null, "created_at" timestamptz not null default now(), "updated_at" timestamptz not null default now(), "deleted_at" timestamptz null, constraint "invite_pkey" primary key ("id"));');
+        this.addSql('alter table "invite" add column if not exists "email" text not null;');
+        this.addSql((0, utils_1.generatePostgresAlterColummnIfExistStatement)("invite", ["user_email"], "DROP NOT NULL"));
+        this.addSql('CREATE UNIQUE INDEX IF NOT EXISTS "IDX_invite_email" ON "invite" (email) WHERE deleted_at IS NULL;');
+        this.addSql('CREATE INDEX IF NOT EXISTS "IDX_invite_token" ON "invite" (token) WHERE deleted_at IS NULL;');
+        this.addSql('CREATE INDEX IF NOT EXISTS "IDX_invite_deleted_at" ON "invite" (deleted_at) WHERE deleted_at IS NOT NULL;');
+        this.addSql('create table if not exists "user" ("id" text not null, "first_name" text null, "last_name" text null, "email" text not null, "avatar_url" text null, "metadata" jsonb null, "created_at" timestamptz not null default now(), "updated_at" timestamptz not null default now(), "deleted_at" timestamptz null, constraint "user_pkey" primary key ("id"));');
+        this.addSql('alter table "user" add column if not exists "avatar_url" text null;');
+        this.addSql('CREATE INDEX IF NOT EXISTS "IDX_user_email" ON "user" (email) WHERE deleted_at IS NULL;');
+        this.addSql('CREATE INDEX IF NOT EXISTS "IDX_user_deleted_at" ON "user" (deleted_at) WHERE deleted_at IS NOT NULL;');
+    }
+    async down() {
+        this.addSql('drop table if exists "invite" cascade;');
+        this.addSql('drop table if exists "user" cascade;');
+    }
+}
+exports.Migration20240214033943 = Migration20240214033943;

package/dist/models/index.d.ts

@@ -1 +1,2 @@
 export { default as User } from "./user";
+export { default as Invite } from "./invite";

package/dist/models/index.js

@@ -3,6 +3,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.User = void 0;
+exports.Invite = exports.User = void 0;
 var user_1 = require("./user");
 Object.defineProperty(exports, "User", { enumerable: true, get: function () { return __importDefault(user_1).default; } });
+var invite_1 = require("./invite");
+Object.defineProperty(exports, "Invite", { enumerable: true, get: function () { return __importDefault(invite_1).default; } });

package/dist/models/invite.d.ts

@@ -0,0 +1,18 @@
+import { OptionalProps } from "@mikro-orm/core";
+import { DAL } from "@medusajs/types";
+type OptionalFields = "metadata" | "accepted" | DAL.SoftDeletableEntityDateColumns;
+export default class Invite {
+    [OptionalProps]: OptionalFields;
+    id: string;
+    email: string;
+    accepted: boolean;
+    token: string;
+    expires_at: Date;
+    metadata: Record<string, unknown> | null;
+    created_at: Date;
+    updated_at: Date;
+    deleted_at: Date | null;
+    onInit(): void;
+    beforeCreate(): void;
+}
+export {};

package/dist/models/invite.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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@mikro-orm/core");
+const utils_1 = require("@medusajs/utils");
+const inviteEmailIndexName = "IDX_invite_email";
+const inviteEmailIndexStatement = (0, utils_1.createPsqlIndexStatementHelper)({
+    name: inviteEmailIndexName,
+    tableName: "invite",
+    columns: "email",
+    where: "deleted_at IS NULL",
+    unique: true,
+}).expression;
+const inviteTokenIndexName = "IDX_invite_token";
+const inviteTokenIndexStatement = (0, utils_1.createPsqlIndexStatementHelper)({
+    name: inviteTokenIndexName,
+    tableName: "invite",
+    columns: "token",
+    where: "deleted_at IS NULL",
+}).expression;
+const inviteDeletedAtIndexName = "IDX_invite_deleted_at";
+const inviteDeletedAtIndexStatement = (0, utils_1.createPsqlIndexStatementHelper)({
+    name: inviteDeletedAtIndexName,
+    tableName: "invite",
+    columns: "deleted_at",
+    where: "deleted_at IS NOT NULL",
+}).expression;
+let Invite = class Invite {
+    constructor() {
+        this.accepted = false;
+        this.metadata = null;
+        this.deleted_at = null;
+    }
+    onInit() {
+        this.id = (0, utils_1.generateEntityId)(this.id, "invite");
+    }
+    beforeCreate() {
+        this.id = (0, utils_1.generateEntityId)(this.id, "invite");
+    }
+};
+__decorate([
+    (0, core_1.PrimaryKey)({ columnType: "text" }),
+    __metadata("design:type", String)
+], Invite.prototype, "id", void 0);
+__decorate([
+    (0, core_1.Index)({
+        name: inviteEmailIndexName,
+        expression: inviteEmailIndexStatement,
+    }),
+    (0, core_1.Property)({ columnType: "text" }),
+    __metadata("design:type", String)
+], Invite.prototype, "email", void 0);
+__decorate([
+    (0, core_1.Property)({ columnType: "boolean" }),
+    __metadata("design:type", Boolean)
+], Invite.prototype, "accepted", void 0);
+__decorate([
+    (0, core_1.Index)({
+        name: inviteTokenIndexName,
+        expression: inviteTokenIndexStatement,
+    }),
+    (0, core_1.Property)({ columnType: "text" }),
+    __metadata("design:type", String)
+], Invite.prototype, "token", void 0);
+__decorate([
+    (0, core_1.Property)({ columnType: "timestamptz" }),
+    __metadata("design:type", Date)
+], Invite.prototype, "expires_at", void 0);
+__decorate([
+    (0, core_1.Property)({ columnType: "jsonb", nullable: true }),
+    __metadata("design:type", Object)
+], Invite.prototype, "metadata", void 0);
+__decorate([
+    (0, core_1.Property)({
+        onCreate: () => new Date(),
+        columnType: "timestamptz",
+        defaultRaw: "now()",
+    }),
+    __metadata("design:type", Date)
+], Invite.prototype, "created_at", void 0);
+__decorate([
+    (0, core_1.Property)({
+        onCreate: () => new Date(),
+        onUpdate: () => new Date(),
+        columnType: "timestamptz",
+        defaultRaw: "now()",
+    }),
+    __metadata("design:type", Date)
+], Invite.prototype, "updated_at", void 0);
+__decorate([
+    (0, core_1.Index)({
+        name: inviteDeletedAtIndexName,
+        expression: inviteDeletedAtIndexStatement,
+    }),
+    (0, core_1.Property)({ columnType: "timestamptz", nullable: true }),
+    __metadata("design:type", Object)
+], Invite.prototype, "deleted_at", void 0);
+__decorate([
+    (0, core_1.OnInit)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], Invite.prototype, "onInit", null);
+__decorate([
+    (0, core_1.BeforeCreate)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], Invite.prototype, "beforeCreate", null);
+Invite = __decorate([
+    (0, core_1.Entity)({ tableName: "invite" }),
+    (0, core_1.Filter)(utils_1.DALUtils.mikroOrmSoftDeletableFilterOptions)
+], Invite);
+exports.default = Invite;

package/dist/models/user.d.ts

@@ -1,5 +1,18 @@
+import { OptionalProps } from "@mikro-orm/core";
+import { DAL } from "@medusajs/types";
+type OptionalFields = "first_name" | "last_name" | "metadata" | "avatar_url" | DAL.SoftDeletableEntityDateColumns;
 export default class User {
+    [OptionalProps]?: OptionalFields;
     id: string;
+    first_name: string | null;
+    last_name: string | null;
+    email: string;
+    avatar_url: string | null;
+    metadata: Record<string, unknown> | null;
+    created_at: Date;
+    updated_at: Date;
+    deleted_at?: Date | null;
     onCreate(): void;
     onInit(): void;
 }
+export {};

package/dist/models/user.js

@@ -11,7 +11,28 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const core_1 = require("@mikro-orm/core");
 const utils_1 = require("@medusajs/utils");
+const userEmailIndexName = "IDX_user_email";
+const userEmailIndexStatement = (0, utils_1.createPsqlIndexStatementHelper)({
+    name: userEmailIndexName,
+    tableName: "user",
+    columns: "email",
+    where: "deleted_at IS NULL",
+}).expression;
+const userDeletedAtIndexName = "IDX_user_deleted_at";
+const userDeletedAtIndexStatement = (0, utils_1.createPsqlIndexStatementHelper)({
+    name: userDeletedAtIndexName,
+    tableName: "user",
+    columns: "deleted_at",
+    where: "deleted_at IS NOT NULL",
+}).expression;
 let User = class User {
+    constructor() {
+        this.first_name = null;
+        this.last_name = null;
+        this.avatar_url = null;
+        this.metadata = null;
+        this.deleted_at = null;
+    }
     onCreate() {
         this.id = (0, utils_1.generateEntityId)(this.id, "user");
     }
@@ -23,6 +44,55 @@ __decorate([
     (0, core_1.PrimaryKey)({ columnType: "text" }),
     __metadata("design:type", String)
 ], User.prototype, "id", void 0);
+__decorate([
+    (0, core_1.Property)({ columnType: "text", nullable: true }),
+    __metadata("design:type", Object)
+], User.prototype, "first_name", void 0);
+__decorate([
+    (0, core_1.Property)({ columnType: "text", nullable: true }),
+    __metadata("design:type", Object)
+], User.prototype, "last_name", void 0);
+__decorate([
+    (0, core_1.Property)({ columnType: "text" }),
+    (0, core_1.Index)({
+        name: userEmailIndexName,
+        expression: userEmailIndexStatement,
+    }),
+    __metadata("design:type", String)
+], User.prototype, "email", void 0);
+__decorate([
+    (0, core_1.Property)({ columnType: "text", nullable: true }),
+    __metadata("design:type", Object)
+], User.prototype, "avatar_url", void 0);
+__decorate([
+    (0, core_1.Property)({ columnType: "jsonb", nullable: true }),
+    __metadata("design:type", Object)
+], User.prototype, "metadata", void 0);
+__decorate([
+    (0, core_1.Property)({
+        onCreate: () => new Date(),
+        columnType: "timestamptz",
+        defaultRaw: "now()",
+    }),
+    __metadata("design:type", Date)
+], User.prototype, "created_at", void 0);
+__decorate([
+    (0, core_1.Property)({
+        onCreate: () => new Date(),
+        onUpdate: () => new Date(),
+        columnType: "timestamptz",
+        defaultRaw: "now()",
+    }),
+    __metadata("design:type", Date)
+], User.prototype, "updated_at", void 0);
+__decorate([
+    (0, core_1.Index)({
+        name: userDeletedAtIndexName,
+        expression: userDeletedAtIndexStatement,
+    }),
+    (0, core_1.Property)({ columnType: "timestamptz", nullable: true }),
+    __metadata("design:type", Object)
+], User.prototype, "deleted_at", void 0);
 __decorate([
     (0, core_1.BeforeCreate)(),
     __metadata("design:type", Function),
@@ -36,6 +106,7 @@ __decorate([
     __metadata("design:returntype", void 0)
 ], User.prototype, "onInit", null);
 User = __decorate([
-    (0, core_1.Entity)()
+    (0, core_1.Entity)(),
+    (0, core_1.Filter)(utils_1.DALUtils.mikroOrmSoftDeletableFilterOptions)
 ], User);
 exports.default = User;

package/dist/services/index.d.ts

@@ -1 +1,2 @@
 export { default as UserModuleService } from "./user-module";
+export { default as InviteService } from "./invite";

package/dist/services/index.js

@@ -3,6 +3,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.UserModuleService = void 0;
+exports.InviteService = exports.UserModuleService = void 0;
 var user_module_1 = require("./user-module");
 Object.defineProperty(exports, "UserModuleService", { enumerable: true, get: function () { return __importDefault(user_module_1).default; } });
+var invite_1 = require("./invite");
+Object.defineProperty(exports, "InviteService", { enumerable: true, get: function () { return __importDefault(invite_1).default; } });

package/dist/services/invite.d.ts

@@ -0,0 +1,24 @@
+import { Context, DAL } from "@medusajs/types";
+import { Invite } from "../models";
+import { InviteServiceTypes } from "../types";
+type InjectedDependencies = {
+    inviteRepository: DAL.RepositoryService;
+};
+declare const InviteService_base: new <TEntity_1 extends object = any>(container: InjectedDependencies) => import("@medusajs/types").InternalModuleService<TEntity_1, InjectedDependencies>;
+export default class InviteService<TEntity extends Invite = Invite> extends InviteService_base<TEntity> {
+    protected readonly inviteRepository_: DAL.RepositoryService<TEntity>;
+    protected options_: {
+        jwt_secret: string;
+        valid_duration: number;
+    } | undefined;
+    constructor(container: InjectedDependencies);
+    withModuleOptions(options: any): InviteService<TEntity>;
+    private getOption;
+    create(data: InviteServiceTypes.CreateInviteDTO, context?: Context): Promise<TEntity>;
+    create(data: InviteServiceTypes.CreateInviteDTO[], context?: Context): Promise<TEntity[]>;
+    refreshInviteTokens(inviteIds: string[], context?: Context): Promise<TEntity[]>;
+    validateInviteToken(token: string, context?: Context): Promise<TEntity>;
+    private generateToken;
+    private validateToken;
+}
+export {};

package/dist/services/invite.js

@@ -0,0 +1,139 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+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 __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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 crypto = __importStar(require("crypto"));
+const utils_1 = require("@medusajs/utils");
+const jsonwebtoken_1 = __importDefault(require("jsonwebtoken"));
+const _models_1 = require("../models");
+// 1 day
+const DEFAULT_VALID_INVITE_DURATION = 60 * 60 * 24;
+class InviteService extends utils_1.ModulesSdkUtils.internalModuleServiceFactory(_models_1.Invite) {
+    constructor(container) {
+        super(container);
+        this.inviteRepository_ = container.inviteRepository;
+    }
+    withModuleOptions(options) {
+        const service = new InviteService(this.__container__);
+        service.options_ = options;
+        return service;
+    }
+    getOption(key) {
+        if (!this.options_) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.UNEXPECTED_STATE, `Options are not configured for InviteService, call "withModuleOptions" and provide options`);
+        }
+        return this.options_[key];
+    }
+    async create(data, context = {}) {
+        const data_ = Array.isArray(data) ? data : [data];
+        const invites = await super.create(data_, context);
+        const expiresIn = parseInt(this.getOption("valid_duration")) ||
+            DEFAULT_VALID_INVITE_DURATION;
+        const updates = invites.map((invite) => {
+            return {
+                id: invite.id,
+                expires_at: new Date().setMilliseconds(new Date().getMilliseconds() + expiresIn),
+                token: this.generateToken({ id: invite.id }),
+            };
+        });
+        return await super.update(updates, context);
+    }
+    async refreshInviteTokens(inviteIds, context = {}) {
+        const [invites, count] = await super.listAndCount({ id: inviteIds }, {}, context);
+        if (count !== inviteIds.length) {
+            const missing = (0, utils_1.arrayDifference)(inviteIds, invites.map((invite) => invite.id));
+            if (missing.length > 0) {
+                throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `The following invites do not exist: ${missing.join(", ")}`);
+            }
+        }
+        const expiresIn = parseInt(this.getOption("valid_duration")) ||
+            DEFAULT_VALID_INVITE_DURATION;
+        const updates = invites.map((invite) => {
+            return {
+                id: invite.id,
+                expires_at: new Date().setMilliseconds(new Date().getMilliseconds() + expiresIn),
+                token: this.generateToken({ id: invite.id }),
+            };
+        });
+        return await super.update(updates, context);
+    }
+    async validateInviteToken(token, context) {
+        const decoded = this.validateToken(token);
+        const invite = await super.retrieve(decoded.payload.id, {}, context);
+        if (invite.expires_at < new Date()) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "The invite has expired");
+        }
+        return invite;
+    }
+    generateToken(data) {
+        const jwtSecret = this.getOption("jwt_secret");
+        const expiresIn = parseInt(this.getOption("valid_duration")) ||
+            DEFAULT_VALID_INVITE_DURATION;
+        if (!jwtSecret) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "No jwt_secret was provided in the UserModule's options. Please add one.");
+        }
+        return jsonwebtoken_1.default.sign(data, jwtSecret, {
+            expiresIn,
+            jwtid: crypto.randomUUID(),
+        });
+    }
+    validateToken(data) {
+        const jwtSecret = this.getOption("jwt_secret");
+        if (!jwtSecret) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "No jwt_secret was provided in the UserModule's options. Please add one.");
+        }
+        return jsonwebtoken_1.default.verify(data, jwtSecret, { complete: true });
+    }
+}
+exports.default = InviteService;
+__decorate([
+    (0, utils_1.InjectTransactionManager)("inviteRepository_"),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], InviteService.prototype, "create", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)("inviteRepository_"),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array, Object]),
+    __metadata("design:returntype", Promise)
+], InviteService.prototype, "refreshInviteTokens", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)("inviteRepository_"),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object]),
+    __metadata("design:returntype", Promise)
+], InviteService.prototype, "validateInviteToken", null);

package/dist/services/user-module.d.ts

@@ -1,22 +1,36 @@
-import { Context, DAL, InternalModuleDeclaration, ModuleJoinerConfig, UserTypes, CreateUserDTO, UpdateUserDTO, UserDTO, ModulesSdkTypes } from "@medusajs/types";
+import { Context, DAL, InternalModuleDeclaration, ModuleJoinerConfig, UserTypes, ModulesSdkTypes, IEventBusModuleService } from "@medusajs/types";
 import { ModulesSdkUtils } from "@medusajs/utils";
-import { User } from "../models";
+import { Invite, User } from "../models";
+import InviteService from "./invite";
 type InjectedDependencies = {
     baseRepository: DAL.RepositoryService;
     userService: ModulesSdkTypes.InternalModuleService<any>;
+    inviteService: InviteService<any>;
+    eventBusModuleService: IEventBusModuleService;
 };
-declare const UserModuleService_base: new (container: InjectedDependencies) => ModulesSdkUtils.AbstractModuleService<InjectedDependencies, UserTypes.UserDTO, {}>;
-export default class UserModuleService<TUser extends User = User> extends UserModuleService_base implements UserTypes.IUserModuleService {
+declare const UserModuleService_base: new (container: InjectedDependencies) => ModulesSdkUtils.AbstractModuleService<InjectedDependencies, UserTypes.UserDTO, {
+    Invite: {
+        dto: UserTypes.InviteDTO;
+    };
+}>;
+export default class UserModuleService<TUser extends User = User, TInvite extends Invite = Invite> extends UserModuleService_base implements UserTypes.IUserModuleService {
     protected readonly moduleDeclaration: InternalModuleDeclaration;
     __joinerConfig(): ModuleJoinerConfig;
     protected baseRepository_: DAL.RepositoryService;
     protected readonly userService_: ModulesSdkTypes.InternalModuleService<TUser>;
-    constructor({ userService, baseRepository }: InjectedDependencies, moduleDeclaration: InternalModuleDeclaration);
-    create(data: CreateUserDTO[], sharedContext?: Context): Promise<UserDTO[]>;
-    create(data: CreateUserDTO, sharedContext?: Context): Promise<UserDTO>;
-    protected create_(data: CreateUserDTO[], sharedContext: Context): Promise<TUser[]>;
-    update(data: UpdateUserDTO[], sharedContext?: Context): Promise<UserDTO[]>;
-    update(data: UpdateUserDTO, sharedContext?: Context): Promise<UserDTO>;
-    protected update_(data: UpdateUserDTO[], sharedContext: Context): Promise<TUser[]>;
+    protected readonly inviteService_: InviteService<TInvite>;
+    constructor({ userService, inviteService, baseRepository }: InjectedDependencies, moduleDeclaration: InternalModuleDeclaration);
+    validateInviteToken(token: string, sharedContext?: Context): Promise<UserTypes.InviteDTO>;
+    refreshInviteTokens(inviteIds: string[], sharedContext?: Context): Promise<UserTypes.InviteDTO[]>;
+    refreshInviteTokens_(inviteIds: string[], sharedContext?: Context): Promise<TInvite[]>;
+    create(data: UserTypes.CreateUserDTO[], sharedContext?: Context): Promise<UserTypes.UserDTO[]>;
+    create(data: UserTypes.CreateUserDTO, sharedContext?: Context): Promise<UserTypes.UserDTO>;
+    update(data: UserTypes.UpdateUserDTO[], sharedContext?: Context): Promise<UserTypes.UserDTO[]>;
+    update(data: UserTypes.UpdateUserDTO, sharedContext?: Context): Promise<UserTypes.UserDTO>;
+    createInvites(data: UserTypes.CreateInviteDTO[], sharedContext?: Context): Promise<UserTypes.InviteDTO[]>;
+    createInvites(data: UserTypes.CreateInviteDTO, sharedContext?: Context): Promise<UserTypes.InviteDTO>;
+    private createInvites_;
+    updateInvites(data: UserTypes.UpdateInviteDTO[], sharedContext?: Context): Promise<UserTypes.InviteDTO[]>;
+    updateInvites(data: UserTypes.UpdateInviteDTO, sharedContext?: Context): Promise<UserTypes.InviteDTO>;
 }
 export {};

package/dist/services/user-module.js

@@ -15,67 +15,190 @@ 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 = [];
+const generateMethodForModels = [_models_1.Invite];
 class UserModuleService extends utils_1.ModulesSdkUtils.abstractModuleServiceFactory(_models_1.User, generateMethodForModels, joiner_config_1.entityNameToLinkableKeysMap) {
     __joinerConfig() {
         return joiner_config_1.joinerConfig;
     }
-    constructor({ userService, baseRepository }, moduleDeclaration) {
+    constructor({ userService, inviteService, baseRepository }, moduleDeclaration) {
         // @ts-ignore
         super(...arguments);
         this.moduleDeclaration = moduleDeclaration;
         this.baseRepository_ = baseRepository;
         this.userService_ = userService;
+        this.inviteService_ = inviteService.withModuleOptions(this.moduleDeclaration);
+    }
+    async validateInviteToken(token, sharedContext = {}) {
+        const invite = await this.inviteService_.validateInviteToken(token, sharedContext);
+        return await this.baseRepository_.serialize(invite, {
+            populate: true,
+        });
+    }
+    async refreshInviteTokens(inviteIds, sharedContext = {}) {
+        const invites = await this.refreshInviteTokens_(inviteIds, sharedContext);
+        sharedContext.messageAggregator?.saveRawMessageData(invites.map((invite) => ({
+            eventName: utils_1.UserEvents.invite_token_generated,
+            metadata: {
+                service: this.constructor.name,
+                action: "token_generated",
+                object: "invite",
+            },
+            data: { id: invite.id },
+        })));
+        return await this.baseRepository_.serialize(invites, {
+            populate: true,
+        });
+    }
+    async refreshInviteTokens_(inviteIds, sharedContext = {}) {
+        return await this.inviteService_.refreshInviteTokens(inviteIds, sharedContext);
     }
     async create(data, sharedContext = {}) {
         const input = Array.isArray(data) ? data : [data];
-        const users = await this.create_(input, sharedContext);
+        const users = await this.userService_.create(input, sharedContext);
         const serializedUsers = await this.baseRepository_.serialize(users, {
             populate: true,
         });
+        sharedContext.messageAggregator?.saveRawMessageData(users.map((user) => ({
+            eventName: utils_1.UserEvents.created,
+            metadata: {
+                service: this.constructor.name,
+                action: utils_1.CommonEvents.CREATED,
+                object: "user",
+            },
+            data: { id: user.id },
+        })));
         return Array.isArray(data) ? serializedUsers : serializedUsers[0];
     }
-    async create_(data, sharedContext) {
-        return await this.userService_.create(data, sharedContext);
-    }
     async update(data, sharedContext = {}) {
         const input = Array.isArray(data) ? data : [data];
-        const updatedUsers = await this.update_(input, sharedContext);
+        const updatedUsers = await this.userService_.update(input, sharedContext);
         const serializedUsers = await this.baseRepository_.serialize(updatedUsers, {
             populate: true,
         });
+        sharedContext.messageAggregator?.saveRawMessageData(updatedUsers.map((user) => ({
+            eventName: utils_1.UserEvents.updated,
+            metadata: {
+                service: this.constructor.name,
+                action: utils_1.CommonEvents.UPDATED,
+                object: "user",
+            },
+            data: { id: user.id },
+        })));
         return Array.isArray(data) ? serializedUsers : serializedUsers[0];
     }
-    async update_(data, sharedContext) {
-        return await this.userService_.update(data, sharedContext);
+    async createInvites(data, sharedContext = {}) {
+        const input = Array.isArray(data) ? data : [data];
+        const invites = await this.createInvites_(input, sharedContext);
+        const serializedInvites = await this.baseRepository_.serialize(invites, {
+            populate: true,
+        });
+        sharedContext.messageAggregator?.saveRawMessageData(invites.map((invite) => ({
+            eventName: utils_1.UserEvents.invite_created,
+            metadata: {
+                service: this.constructor.name,
+                action: utils_1.CommonEvents.CREATED,
+                object: "invite",
+            },
+            data: { id: invite.id },
+        })));
+        sharedContext.messageAggregator?.saveRawMessageData(invites.map((invite) => ({
+            eventName: utils_1.UserEvents.invite_token_generated,
+            metadata: {
+                service: this.constructor.name,
+                action: "token_generated",
+                object: "invite",
+            },
+            data: { id: invite.id },
+        })));
+        return Array.isArray(data) ? serializedInvites : serializedInvites[0];
+    }
+    async createInvites_(data, sharedContext = {}) {
+        const toCreate = data.map((invite) => {
+            return {
+                ...invite,
+                expires_at: new Date(),
+                token: "placeholder",
+            };
+        });
+        return await this.inviteService_.create(toCreate, sharedContext);
+    }
+    async updateInvites(data, sharedContext = {}) {
+        const input = Array.isArray(data) ? data : [data];
+        const updatedInvites = await this.inviteService_.update(input, sharedContext);
+        const serializedInvites = await this.baseRepository_.serialize(updatedInvites, {
+            populate: true,
+        });
+        sharedContext.messageAggregator?.saveRawMessageData(serializedInvites.map((invite) => ({
+            eventName: utils_1.UserEvents.invite_updated,
+            metadata: {
+                service: this.constructor.name,
+                action: utils_1.CommonEvents.UPDATED,
+                object: "invite",
+            },
+            data: { id: invite.id },
+        })));
+        return Array.isArray(data) ? serializedInvites : serializedInvites[0];
     }
 }
 exports.default = UserModuleService;
+__decorate([
+    (0, utils_1.InjectTransactionManager)("baseRepository_"),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object]),
+    __metadata("design:returntype", Promise)
+], UserModuleService.prototype, "validateInviteToken", null);
 __decorate([
     (0, utils_1.InjectManager)("baseRepository_"),
+    (0, utils_1.EmitEvents)(),
     __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:paramtypes", [Array, Object]),
     __metadata("design:returntype", Promise)
-], UserModuleService.prototype, "create", null);
+], UserModuleService.prototype, "refreshInviteTokens", 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)
-], UserModuleService.prototype, "create_", null);
+], UserModuleService.prototype, "refreshInviteTokens_", null);
 __decorate([
     (0, utils_1.InjectManager)("baseRepository_"),
+    (0, utils_1.EmitEvents)(),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], UserModuleService.prototype, "create", null);
+__decorate([
+    (0, utils_1.InjectManager)("baseRepository_"),
+    (0, utils_1.EmitEvents)(),
     __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object]),
     __metadata("design:returntype", Promise)
 ], UserModuleService.prototype, "update", null);
+__decorate([
+    (0, utils_1.InjectManager)("baseRepository_"),
+    (0, utils_1.EmitEvents)(),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], UserModuleService.prototype, "createInvites", 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)
-], UserModuleService.prototype, "update_", null);
+], UserModuleService.prototype, "createInvites_", null);
+__decorate([
+    (0, utils_1.InjectManager)("baseRepository_"),
+    (0, utils_1.EmitEvents)(),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], UserModuleService.prototype, "updateInvites", null);

package/dist/types/index.d.ts

@@ -2,4 +2,4 @@ import { Logger } from "@medusajs/types";
 export type InitializeModuleInjectableDependencies = {
     logger?: Logger;
 };
-export * as ServiceTypes from "./services";
+export * from "./services";

package/dist/types/index.js

@@ -10,18 +10,8 @@ var __createBinding = (this && this.__createBinding) || (Object.create ? (functi
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
 }));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
+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 });
-exports.ServiceTypes = void 0;
-exports.ServiceTypes = __importStar(require("./services"));
+__exportStar(require("./services"), exports);

package/dist/types/services/index.d.ts

@@ -1 +1 @@
-export * from "./user";
+export * as InviteServiceTypes from "./invite";

package/dist/types/services/index.js

@@ -10,8 +10,18 @@ var __createBinding = (this && this.__createBinding) || (Object.create ? (functi
     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);
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./user"), exports);
+exports.InviteServiceTypes = void 0;
+exports.InviteServiceTypes = __importStar(require("./invite"));

package/dist/types/services/invite.d.ts

@@ -0,0 +1,5 @@
+export interface CreateInviteDTO {
+    email: string;
+    accepted?: boolean;
+    metadata?: Record<string, unknown> | null;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@medusajs/user",
-  "version": "0.0.1",
+  "version": "0.0.2-next-20240319121007",
   "description": "Medusa Users module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -29,7 +29,7 @@
     "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 -- src/**/__tests__/**/*.ts",
-    "test:integration": "jest --runInBand --forceExit -- integration-tests/**/__tests__/**/*.ts",
+    "test:integration": "jest --forceExit -- integration-tests/**/__tests__/**/*.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",
     "migration:create": " MIKRO_ORM_CLI=./mikro-orm.config.dev.ts mikro-orm migration:create",
@@ -40,7 +40,7 @@
     "@mikro-orm/cli": "5.9.7",
     "cross-env": "^5.2.1",
     "jest": "^29.6.3",
-    "medusa-test-utils": "^1.1.40",
+    "medusa-test-utils": "1.1.42-next-20240319121007",
     "rimraf": "^3.0.2",
     "ts-jest": "^29.1.1",
     "ts-node": "^10.9.1",
@@ -48,14 +48,15 @@
     "typescript": "^5.1.6"
   },
   "dependencies": {
-    "@medusajs/modules-sdk": "^1.12.7",
-    "@medusajs/types": "^1.11.11",
-    "@medusajs/utils": "^1.11.4",
+    "@medusajs/modules-sdk": "1.12.9-next-20240319121007",
+    "@medusajs/types": "1.11.14-next-20240319121007",
+    "@medusajs/utils": "1.11.7-next-20240319121007",
     "@mikro-orm/core": "5.9.7",
     "@mikro-orm/migrations": "5.9.7",
     "@mikro-orm/postgresql": "5.9.7",
     "awilix": "^8.0.0",
-    "dotenv": "16.3.1",
+    "dotenv": "^16.4.5",
+    "jsonwebtoken": "^9.0.2",
     "knex": "2.4.2"
   }
 }

package/dist/migrations/Migration20240201081925.d.ts

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

package/dist/migrations/Migration20240201081925.js

@@ -1,13 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Migration20240201081925 = void 0;
-const migrations_1 = require("@mikro-orm/migrations");
-class Migration20240201081925 extends migrations_1.Migration {
-    async up() {
-        this.addSql('create table "user" ("id" text not null, constraint "user_pkey" primary key ("id"));');
-    }
-    async down() {
-        this.addSql('drop table if exists "user" cascade;');
-    }
-}
-exports.Migration20240201081925 = Migration20240201081925;

package/dist/types/services/user.d.ts

@@ -1,10 +0,0 @@
-export type UserDTO = {
-    id: string;
-};
-export type CreateUserDTO = {
-    id?: string;
-};
-export type UpdateUserDTO = {
-    id: string;
-};
-export type FilterableUserProps = {};