@medusajs/auth 0.0.2

package/dist/providers/google.js

@@ -0,0 +1,158 @@
+"use strict";
+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 jsonwebtoken_1 = __importDefault(require("jsonwebtoken"));
+const simple_oauth2_1 = require("simple-oauth2");
+const url_1 = __importDefault(require("url"));
+class GoogleProvider extends utils_1.AbstractAuthModuleProvider {
+    constructor({ authUserService, authProviderService }) {
+        super(arguments[0]);
+        this.authUserSerivce_ = authUserService;
+        this.authProviderService_ = authProviderService;
+    }
+    async authenticate(req) {
+        if (req.query?.error) {
+            return {
+                success: false,
+                error: `${req.query.error_description}, read more at: ${req.query.error_uri}`,
+            };
+        }
+        let config;
+        try {
+            config = await this.getProviderConfig(req);
+        }
+        catch (error) {
+            return { success: false, error: error.message };
+        }
+        return this.getRedirect(config);
+    }
+    async validateCallback(req) {
+        if (req.query && req.query.error) {
+            return {
+                success: false,
+                error: `${req.query.error_description}, read more at: ${req.query.error_uri}`,
+            };
+        }
+        let config;
+        try {
+            config = await this.getProviderConfig(req);
+        }
+        catch (error) {
+            return { success: false, error: error.message };
+        }
+        const code = req.query?.code ?? req.body?.code;
+        return await this.validateCallbackToken(code, req.scope, config);
+    }
+    // abstractable
+    async verify_(refreshToken, scope) {
+        const jwtData = (await jsonwebtoken_1.default.decode(refreshToken, {
+            complete: true,
+        }));
+        const entity_id = jwtData.payload.email;
+        let authUser;
+        try {
+            authUser = await this.authUserSerivce_.retrieveByProviderAndEntityId(entity_id, GoogleProvider.PROVIDER);
+        }
+        catch (error) {
+            if (error.type === utils_1.MedusaError.Types.NOT_FOUND) {
+                authUser = await this.authUserSerivce_.create([
+                    {
+                        entity_id,
+                        provider_id: GoogleProvider.PROVIDER,
+                        user_metadata: jwtData.payload,
+                        app_metadata: { scope },
+                    },
+                ]);
+            }
+            else {
+                return { success: false, error: error.message };
+            }
+        }
+        return { success: true, authUser };
+    }
+    // abstractable
+    async validateCallbackToken(code, scope, { clientID, callbackURL, clientSecret }) {
+        const client = this.getAuthorizationCodeHandler({ clientID, clientSecret });
+        const tokenParams = {
+            code,
+            redirect_uri: callbackURL,
+        };
+        try {
+            const accessToken = await client.getToken(tokenParams);
+            return await this.verify_(accessToken.token.id_token, scope);
+        }
+        catch (error) {
+            return { success: false, error: error.message };
+        }
+    }
+    getConfigFromScope(config) {
+        const providerConfig = {};
+        if (config.clientId) {
+            providerConfig.clientID = config.clientId;
+        }
+        else {
+            throw new Error("Google clientID is required");
+        }
+        if (config.clientSecret) {
+            providerConfig.clientSecret = config.clientSecret;
+        }
+        else {
+            throw new Error("Google clientSecret is required");
+        }
+        if (config.callbackURL) {
+            providerConfig.callbackURL = config.callbackUrl;
+        }
+        else {
+            throw new Error("Google callbackUrl is required");
+        }
+        return providerConfig;
+    }
+    originalURL(req) {
+        const tls = req.connection.encrypted;
+        const host = req.headers.host;
+        const protocol = tls ? "https" : "http";
+        const path = req.url || "";
+        return protocol + "://" + host + path;
+    }
+    async getProviderConfig(req) {
+        await this.authProviderService_.retrieve(GoogleProvider.PROVIDER);
+        const scopeConfig = this.scopes_[req.scope];
+        const config = this.getConfigFromScope(scopeConfig);
+        const { callbackURL } = config;
+        const parsedCallbackUrl = !url_1.default.parse(callbackURL).protocol
+            ? url_1.default.resolve(this.originalURL(req), callbackURL)
+            : callbackURL;
+        return { ...config, callbackURL: parsedCallbackUrl };
+    }
+    // Abstractable
+    getRedirect({ clientID, callbackURL, clientSecret }) {
+        const client = this.getAuthorizationCodeHandler({ clientID, clientSecret });
+        const location = client.authorizeURL({
+            redirect_uri: callbackURL,
+            scope: "email profile",
+        });
+        return { success: true, location };
+    }
+    getAuthorizationCodeHandler({ clientID, clientSecret, }) {
+        const config = {
+            client: {
+                id: clientID,
+                secret: clientSecret,
+            },
+            auth: {
+                // TODO: abstract to not be google specific
+                authorizeHost: "https://accounts.google.com",
+                authorizePath: "/o/oauth2/v2/auth",
+                tokenHost: "https://www.googleapis.com",
+                tokenPath: "/oauth2/v4/token",
+            },
+        };
+        return new simple_oauth2_1.AuthorizationCode(config);
+    }
+}
+GoogleProvider.PROVIDER = "google";
+GoogleProvider.DISPLAY_NAME = "Google Authentication";
+exports.default = GoogleProvider;

package/dist/providers/index.d.ts

@@ -0,0 +1,2 @@
+export { default as EmailPasswordProvider } from "./email-password";
+export { default as GoogleProvider } from "./google";

package/dist/providers/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.GoogleProvider = exports.EmailPasswordProvider = void 0;
+var email_password_1 = require("./email-password");
+Object.defineProperty(exports, "EmailPasswordProvider", { enumerable: true, get: function () { return __importDefault(email_password_1).default; } });
+var google_1 = require("./google");
+Object.defineProperty(exports, "GoogleProvider", { enumerable: true, get: function () { return __importDefault(google_1).default; } });

package/dist/repositories/index.d.ts

@@ -0,0 +1 @@
+export { MikroOrmBaseRepository as BaseRepository } from "@medusajs/utils";

package/dist/repositories/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseRepository = void 0;
+var utils_1 = require("@medusajs/utils");
+Object.defineProperty(exports, "BaseRepository", { enumerable: true, get: function () { return utils_1.MikroOrmBaseRepository; } });

package/dist/scripts/bin/run-seed.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+declare const _default: Promise<void>;
+export default _default;

package/dist/scripts/bin/run-seed.js

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+"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 __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 });
+const os_1 = require("os");
+const seed_1 = require("../seed");
+const args = process.argv;
+const path = args.pop();
+exports.default = (async () => {
+    const { config } = await Promise.resolve().then(() => __importStar(require("dotenv")));
+    config();
+    if (!path) {
+        throw new Error(`filePath is required.${os_1.EOL}Example: medusa-auth-seed <filePath>`);
+    }
+    await (0, seed_1.run)({ path });
+})();

package/dist/scripts/seed.d.ts

@@ -0,0 +1,4 @@
+import { LoaderOptions, ModulesSdkTypes } from "@medusajs/types";
+export declare function run({ options, logger, path, }: Partial<Pick<LoaderOptions<ModulesSdkTypes.ModuleServiceInitializeOptions>, "options" | "logger">> & {
+    path: string;
+}): Promise<void>;

package/dist/scripts/seed.js

@@ -0,0 +1,54 @@
+"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 __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 });
+exports.run = void 0;
+const AuthModels = __importStar(require("../models"));
+const utils_1 = require("@medusajs/utils");
+const os_1 = require("os");
+const modules_sdk_1 = require("@medusajs/modules-sdk");
+const path_1 = require("path");
+async function run({ options, logger, path, }) {
+    logger ?? (logger = console);
+    logger.info(`Loading seed data from ${path}...`);
+    const { authenticationData } = await Promise.resolve(`${(0, path_1.resolve)(process.cwd(), path)}`).then(s => __importStar(require(s))).catch((e) => {
+        logger?.error(`Failed to load seed data from ${path}. Please, provide a relative path and check that you export the following: authenticationData.${os_1.EOL}${e}`);
+        throw e;
+    });
+    const dbData = utils_1.ModulesSdkUtils.loadDatabaseConfig(modules_sdk_1.Modules.AUTH, options);
+    const entities = Object.values(AuthModels);
+    const pathToMigrations = __dirname + "/../migrations";
+    const orm = await utils_1.DALUtils.mikroOrmCreateConnection(dbData, entities, pathToMigrations);
+    const manager = orm.em.fork();
+    try {
+        logger.info("Seeding authentication data..");
+        // TODO: implement authentication seed data
+        // await createAuthUsers(manager, authUsersData)
+    }
+    catch (e) {
+        logger.error(`Failed to insert the seed data in the PostgreSQL database ${dbData.clientUrl}.${os_1.EOL}${e}`);
+    }
+    await orm.close(true);
+}
+exports.run = run;

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

@@ -0,0 +1,46 @@
+import { AuthenticationInput, AuthenticationResponse, AuthProviderDTO, AuthTypes, AuthUserDTO, Context, CreateAuthProviderDTO, CreateAuthUserDTO, DAL, FilterableAuthProviderProps, FilterableAuthUserProps, FindConfig, InternalModuleDeclaration, MedusaContainer, ModuleJoinerConfig, UpdateAuthUserDTO } from "@medusajs/types";
+import { AbstractAuthModuleProvider } from "@medusajs/utils";
+import { AuthProvider, AuthUser } from "../models";
+import { AuthProviderService, AuthUserService } from ".";
+type InjectedDependencies = {
+    baseRepository: DAL.RepositoryService;
+    authUserService: AuthUserService<any>;
+    authProviderService: AuthProviderService<any>;
+};
+export default class AuthModuleService<TAuthUser extends AuthUser = AuthUser, TAuthProvider extends AuthProvider = AuthProvider> implements AuthTypes.IAuthModuleService {
+    protected readonly moduleDeclaration: InternalModuleDeclaration;
+    __joinerConfig(): ModuleJoinerConfig;
+    __hooks: {
+        onApplicationStart: () => Promise<void>;
+    };
+    protected __container__: MedusaContainer;
+    protected baseRepository_: DAL.RepositoryService;
+    protected authUserService_: AuthUserService<TAuthUser>;
+    protected authProviderService_: AuthProviderService<TAuthProvider>;
+    constructor({ authUserService, authProviderService, baseRepository, }: InjectedDependencies, moduleDeclaration: InternalModuleDeclaration);
+    retrieveAuthProvider(provider: string, config?: FindConfig<AuthProviderDTO>, sharedContext?: Context): Promise<AuthProviderDTO>;
+    listAuthProviders(filters?: FilterableAuthProviderProps, config?: FindConfig<AuthProviderDTO>, sharedContext?: Context): Promise<AuthProviderDTO[]>;
+    listAndCountAuthProviders(filters: AuthTypes.FilterableAuthProviderProps | undefined, config: FindConfig<AuthProviderDTO>, sharedContext?: Context): Promise<[AuthTypes.AuthProviderDTO[], number]>;
+    createAuthProvider(data: CreateAuthProviderDTO[], sharedContext?: Context): Promise<AuthProviderDTO[]>;
+    createAuthProvider(data: CreateAuthProviderDTO, sharedContext?: Context): Promise<AuthProviderDTO>;
+    protected createAuthProviders_(data: any[], sharedContext: Context): Promise<TAuthProvider[]>;
+    updateAuthProvider(data: AuthTypes.UpdateAuthProviderDTO[], sharedContext?: Context): Promise<AuthProviderDTO[]>;
+    updateAuthProvider(data: AuthTypes.UpdateAuthProviderDTO, sharedContext?: Context): Promise<AuthProviderDTO>;
+    updateAuthProvider_(data: AuthTypes.UpdateAuthProviderDTO[], sharedContext?: Context): Promise<TAuthProvider[]>;
+    deleteAuthProvider(ids: string[], sharedContext?: Context): Promise<void>;
+    retrieveAuthUser(id: string, config?: FindConfig<AuthUserDTO>, sharedContext?: Context): Promise<AuthUserDTO>;
+    listAuthUsers(filters?: FilterableAuthUserProps, config?: FindConfig<AuthUserDTO>, sharedContext?: Context): Promise<AuthUserDTO[]>;
+    listAndCountAuthUsers(filters?: FilterableAuthUserProps, config?: FindConfig<AuthUserDTO>, sharedContext?: Context): Promise<[AuthUserDTO[], number]>;
+    createAuthUser(data: CreateAuthUserDTO[], sharedContext?: Context): Promise<AuthUserDTO[]>;
+    createAuthUser(data: CreateAuthUserDTO, sharedContext?: Context): Promise<AuthUserDTO>;
+    protected createAuthUsers_(data: CreateAuthUserDTO[], sharedContext: Context): Promise<TAuthUser[]>;
+    updateAuthUser(data: UpdateAuthUserDTO[], sharedContext?: Context): Promise<AuthUserDTO[]>;
+    updateAuthUser(data: UpdateAuthUserDTO, sharedContext?: Context): Promise<AuthUserDTO>;
+    protected updateAuthUsers_(data: UpdateAuthUserDTO[], sharedContext: Context): Promise<TAuthUser[]>;
+    deleteAuthUser(ids: string[], sharedContext?: Context): Promise<void>;
+    protected getRegisteredAuthenticationProvider(provider: string, { scope }: AuthenticationInput): AbstractAuthModuleProvider;
+    authenticate(provider: string, authenticationData: AuthenticationInput): Promise<AuthenticationResponse>;
+    validateCallback(provider: string, authenticationData: AuthenticationInput): Promise<AuthenticationResponse>;
+    private createProvidersOnLoad;
+}
+export {};

package/dist/services/auth-module.js

@@ -0,0 +1,276 @@
+"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");
+class AuthModuleService {
+    __joinerConfig() {
+        return joiner_config_1.joinerConfig;
+    }
+    constructor({ authUserService, authProviderService, baseRepository, }, moduleDeclaration) {
+        this.moduleDeclaration = moduleDeclaration;
+        this.__hooks = {
+            onApplicationStart: async () => await this.createProvidersOnLoad(),
+        };
+        this.__container__ = arguments[0];
+        this.baseRepository_ = baseRepository;
+        this.authUserService_ = authUserService;
+        this.authProviderService_ = authProviderService;
+    }
+    async retrieveAuthProvider(provider, config = {}, sharedContext = {}) {
+        const authProvider = await this.authProviderService_.retrieve(provider, config, sharedContext);
+        return await this.baseRepository_.serialize(authProvider, { populate: true });
+    }
+    async listAuthProviders(filters = {}, config = {}, sharedContext = {}) {
+        const authProviders = await this.authProviderService_.list(filters, config, sharedContext);
+        return await this.baseRepository_.serialize(authProviders, { populate: true });
+    }
+    async listAndCountAuthProviders(filters = {}, config, sharedContext = {}) {
+        const [authProviders, count] = await this.authProviderService_.listAndCount(filters, config, sharedContext);
+        return [
+            await this.baseRepository_.serialize(authProviders, { populate: true }),
+            count,
+        ];
+    }
+    async createAuthProvider(data, sharedContext = {}) {
+        const input = Array.isArray(data) ? data : [data];
+        const providers = await this.createAuthProviders_(input, sharedContext);
+        const serializedProviders = await this.baseRepository_.serialize(providers, {
+            populate: true,
+        });
+        return Array.isArray(data) ? serializedProviders : serializedProviders[0];
+    }
+    async createAuthProviders_(data, sharedContext) {
+        return await this.authProviderService_.create(data, sharedContext);
+    }
+    async updateAuthProvider(data, sharedContext = {}) {
+        const input = Array.isArray(data) ? data : [data];
+        const providers = await this.updateAuthProvider_(input, sharedContext);
+        const serializedProviders = await this.baseRepository_.serialize(providers, {
+            populate: true,
+        });
+        return Array.isArray(data) ? serializedProviders : serializedProviders[0];
+    }
+    async updateAuthProvider_(data, sharedContext = {}) {
+        return await this.authProviderService_.update(data, sharedContext);
+    }
+    async deleteAuthProvider(ids, sharedContext = {}) {
+        await this.authProviderService_.delete(ids, sharedContext);
+    }
+    async retrieveAuthUser(id, config = {}, sharedContext = {}) {
+        const authUser = await this.authUserService_.retrieve(id, config, sharedContext);
+        return await this.baseRepository_.serialize(authUser, {
+            exclude: ["password_hash"],
+        });
+    }
+    async listAuthUsers(filters = {}, config = {}, sharedContext = {}) {
+        const authUsers = await this.authUserService_.list(filters, config, sharedContext);
+        return await this.baseRepository_.serialize(authUsers, {
+            populate: true,
+        });
+    }
+    async listAndCountAuthUsers(filters = {}, config = {}, sharedContext = {}) {
+        const [authUsers, count] = await this.authUserService_.listAndCount(filters, config, sharedContext);
+        return [
+            await this.baseRepository_.serialize(authUsers, {
+                populate: true,
+            }),
+            count,
+        ];
+    }
+    async createAuthUser(data, sharedContext = {}) {
+        const input = Array.isArray(data) ? data : [data];
+        const authUsers = await this.createAuthUsers_(input, sharedContext);
+        const serializedUsers = await this.baseRepository_.serialize(authUsers, {
+            populate: true,
+        });
+        return Array.isArray(data) ? serializedUsers : serializedUsers[0];
+    }
+    async createAuthUsers_(data, sharedContext) {
+        return await this.authUserService_.create(data, sharedContext);
+    }
+    async updateAuthUser(data, sharedContext = {}) {
+        const input = Array.isArray(data) ? data : [data];
+        const updatedUsers = await this.updateAuthUsers_(input, sharedContext);
+        const serializedUsers = await this.baseRepository_.serialize(updatedUsers, {
+            populate: true,
+        });
+        return Array.isArray(data) ? serializedUsers : serializedUsers[0];
+    }
+    async updateAuthUsers_(data, sharedContext) {
+        return await this.authUserService_.update(data, sharedContext);
+    }
+    async deleteAuthUser(ids, sharedContext = {}) {
+        await this.authUserService_.delete(ids, sharedContext);
+    }
+    getRegisteredAuthenticationProvider(provider, { scope }) {
+        let containerProvider;
+        try {
+            containerProvider = this.__container__[`auth_provider_${provider}`];
+        }
+        catch (error) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_FOUND, `AuthenticationProvider with for provider: ${provider} wasn't registered in the module. Have you configured your options correctly?`);
+        }
+        containerProvider.validateScope(scope);
+        return containerProvider;
+    }
+    async authenticate(provider, authenticationData) {
+        try {
+            await this.retrieveAuthProvider(provider, {});
+            const registeredProvider = this.getRegisteredAuthenticationProvider(provider, authenticationData);
+            return await registeredProvider.authenticate(authenticationData);
+        }
+        catch (error) {
+            return { success: false, error: error.message };
+        }
+    }
+    async validateCallback(provider, authenticationData) {
+        try {
+            await this.retrieveAuthProvider(provider, {});
+            const registeredProvider = this.getRegisteredAuthenticationProvider(provider, authenticationData);
+            return await registeredProvider.validateCallback(authenticationData);
+        }
+        catch (error) {
+            return { success: false, error: error.message };
+        }
+    }
+    async createProvidersOnLoad() {
+        const providersToLoad = this.__container__["auth_providers"];
+        const providers = await this.authProviderService_.list({
+            provider: providersToLoad.map((p) => p.provider),
+        });
+        const loadedProvidersMap = new Map(providers.map((p) => [p.provider, p]));
+        const providersToCreate = [];
+        for (const provider of providersToLoad) {
+            if (loadedProvidersMap.has(provider.provider)) {
+                continue;
+            }
+            providersToCreate.push({
+                provider: provider.provider,
+                name: provider.displayName,
+            });
+        }
+        await this.authProviderService_.create(providersToCreate);
+    }
+}
+exports.default = AuthModuleService;
+__decorate([
+    __param(2, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object, Object]),
+    __metadata("design:returntype", Promise)
+], AuthModuleService.prototype, "retrieveAuthProvider", null);
+__decorate([
+    __param(2, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", Promise)
+], AuthModuleService.prototype, "listAuthProviders", null);
+__decorate([
+    (0, utils_1.InjectManager)("baseRepository_"),
+    __param(2, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", Promise)
+], AuthModuleService.prototype, "listAndCountAuthProviders", null);
+__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)
+], AuthModuleService.prototype, "createAuthProvider", 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)
+], AuthModuleService.prototype, "createAuthProviders_", null);
+__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)
+], AuthModuleService.prototype, "updateAuthProvider", null);
+__decorate([
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array, Object]),
+    __metadata("design:returntype", Promise)
+], AuthModuleService.prototype, "updateAuthProvider_", 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)
+], AuthModuleService.prototype, "deleteAuthProvider", null);
+__decorate([
+    (0, utils_1.InjectManager)("baseRepository_"),
+    __param(2, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object, Object]),
+    __metadata("design:returntype", Promise)
+], AuthModuleService.prototype, "retrieveAuthUser", null);
+__decorate([
+    (0, utils_1.InjectManager)("baseRepository_"),
+    __param(2, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", Promise)
+], AuthModuleService.prototype, "listAuthUsers", null);
+__decorate([
+    (0, utils_1.InjectManager)("baseRepository_"),
+    __param(2, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", Promise)
+], AuthModuleService.prototype, "listAndCountAuthUsers", null);
+__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)
+], AuthModuleService.prototype, "createAuthUser", 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)
+], AuthModuleService.prototype, "createAuthUsers_", null);
+__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)
+], AuthModuleService.prototype, "updateAuthUser", 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)
+], AuthModuleService.prototype, "updateAuthUsers_", 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)
+], AuthModuleService.prototype, "deleteAuthUser", null);

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

@@ -0,0 +1,18 @@
+import { DAL } from "@medusajs/types";
+import { ModulesSdkUtils } from "@medusajs/utils";
+import { AuthProvider } from "../models";
+import { ServiceTypes } from "../types";
+type InjectedDependencies = {
+    authProviderRepository: DAL.RepositoryService;
+};
+declare const AuthProviderService_base: new <TEntity_1 extends object = any>(container: InjectedDependencies) => ModulesSdkUtils.AbstractService<TEntity_1, InjectedDependencies, {
+    create: ServiceTypes.CreateAuthProviderDTO;
+    update: ServiceTypes.UpdateAuthProviderDTO;
+}, {
+    list?: any;
+    listAndCount?: any;
+}>;
+export default class AuthProviderService<TEntity extends AuthProvider = AuthProvider> extends AuthProviderService_base<TEntity> {
+    constructor(container: InjectedDependencies);
+}
+export {};

package/dist/services/auth-provider.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@medusajs/utils");
+const _models_1 = require("../models");
+class AuthProviderService extends utils_1.ModulesSdkUtils.abstractServiceFactory(_models_1.AuthProvider) {
+    constructor(container) {
+        // @ts-ignore
+        super(...arguments);
+    }
+}
+exports.default = AuthProviderService;

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

@@ -0,0 +1,19 @@
+import { AuthTypes, Context, DAL, FindConfig } from "@medusajs/types";
+import { ModulesSdkUtils } from "@medusajs/utils";
+import { AuthUser } from "../models";
+import { ServiceTypes, RepositoryTypes } from "../types";
+type InjectedDependencies = {
+    authUserRepository: DAL.RepositoryService;
+};
+declare const AuthUserService_base: new <TEntity_1 extends object = any>(container: InjectedDependencies) => ModulesSdkUtils.AbstractService<TEntity_1, InjectedDependencies, {
+    create: ServiceTypes.CreateAuthUserDTO;
+}, {
+    list?: any;
+    listAndCount?: any;
+}>;
+export default class AuthUserService<TEntity extends AuthUser = AuthUser> extends AuthUserService_base<TEntity> {
+    protected readonly authUserRepository_: RepositoryTypes.IAuthUserRepository<TEntity>;
+    constructor(container: InjectedDependencies);
+    retrieveByProviderAndEntityId<TEntityMethod = AuthTypes.AuthUserDTO>(entityId: string, provider: string, config?: FindConfig<TEntityMethod>, sharedContext?: Context): Promise<TEntity>;
+}
+export {};