@medusajs/auth 0.0.2 → 0.0.3-next-20240319121007

package/dist/migrations/Migration20240205025924.d.ts

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

package/dist/migrations/Migration20240205025924.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Migration20240205025924 = void 0;
+const migrations_1 = require("@mikro-orm/migrations");
+class Migration20240205025924 extends migrations_1.Migration {
+    async up() {
+        this.addSql('create table if not exists "auth_user" ("id" text not null, "entity_id" text not null, "provider" text not null, "scope" text not null, "user_metadata" jsonb null, "app_metadata" jsonb not null, "provider_metadata" jsonb null, constraint "auth_user_pkey" primary key ("id"));');
+        this.addSql('alter table "auth_user" add constraint "IDX_auth_user_provider_scope_entity_id" unique ("provider", "scope", "entity_id");');
+    }
+    async down() {
+        this.addSql('drop table if exists "auth_user" cascade;');
+    }
+}
+exports.Migration20240205025924 = Migration20240205025924;

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

@@ -1,13 +1,13 @@
 import { OptionalProps } from "@mikro-orm/core";
-import AuthProvider from "./auth-provider";
 type OptionalFields = "provider_metadata" | "app_metadata" | "user_metadata";
 export default class AuthUser {
     [OptionalProps]: OptionalFields;
     id: string;
     entity_id: string;
-    provider: AuthProvider;
+    provider: string;
+    scope: string;
     user_metadata: Record<string, unknown> | null;
-    app_metadata: Record<string, unknown> | null;
+    app_metadata: Record<string, unknown>;
     provider_metadata: Record<string, unknown> | null;
     onCreate(): void;
     onInit(): void;

package/dist/models/auth-user.js

@@ -8,14 +8,14 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 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 core_1 = require("@mikro-orm/core");
-const auth_provider_1 = __importDefault(require("./auth-provider"));
 const utils_1 = require("@medusajs/utils");
 let AuthUser = class AuthUser {
+    constructor() {
+        this.app_metadata = {};
+        this.provider_metadata = null;
+    }
     onCreate() {
         this.id = (0, utils_1.generateEntityId)(this.id, "authusr");
     }
@@ -32,19 +32,19 @@ __decorate([
     __metadata("design:type", String)
 ], AuthUser.prototype, "entity_id", void 0);
 __decorate([
-    (0, core_1.ManyToOne)(() => auth_provider_1.default, {
-        joinColumn: "provider",
-        fieldName: "provider_id",
-        cascade: [core_1.Cascade.REMOVE],
-    }),
-    __metadata("design:type", auth_provider_1.default)
+    (0, core_1.Property)({ columnType: "text" }),
+    __metadata("design:type", String)
 ], AuthUser.prototype, "provider", void 0);
+__decorate([
+    (0, core_1.Property)({ columnType: "text" }),
+    __metadata("design:type", String)
+], AuthUser.prototype, "scope", void 0);
 __decorate([
     (0, core_1.Property)({ columnType: "jsonb", nullable: true }),
     __metadata("design:type", Object)
 ], AuthUser.prototype, "user_metadata", void 0);
 __decorate([
-    (0, core_1.Property)({ columnType: "jsonb", nullable: true }),
+    (0, core_1.Property)({ columnType: "jsonb" }),
     __metadata("design:type", Object)
 ], AuthUser.prototype, "app_metadata", void 0);
 __decorate([
@@ -65,6 +65,9 @@ __decorate([
 ], AuthUser.prototype, "onInit", null);
 AuthUser = __decorate([
     (0, core_1.Entity)(),
-    (0, core_1.Unique)({ properties: ["provider", "entity_id"], name: "IDX_auth_user_provider_entity_id" })
+    (0, core_1.Unique)({
+        properties: ["provider", "scope", "entity_id"],
+        name: "IDX_auth_user_provider_scope_entity_id",
+    })
 ], AuthUser);
 exports.default = AuthUser;

package/dist/models/index.d.ts

@@ -1,2 +1 @@
 export { default as AuthUser } from "./auth-user";
-export { default as AuthProvider } from "./auth-provider";

package/dist/models/index.js

@@ -3,8 +3,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AuthProvider = exports.AuthUser = void 0;
+exports.AuthUser = void 0;
 var auth_user_1 = require("./auth-user");
 Object.defineProperty(exports, "AuthUser", { enumerable: true, get: function () { return __importDefault(auth_user_1).default; } });
-var auth_provider_1 = require("./auth-provider");
-Object.defineProperty(exports, "AuthProvider", { enumerable: true, get: function () { return __importDefault(auth_provider_1).default; } });

package/dist/providers/email-password.d.ts

@@ -8,6 +8,7 @@ declare class EmailPasswordProvider extends AbstractAuthModuleProvider {
     constructor({ authUserService }: {
         authUserService: AuthUserService;
     });
+    private getHashConfig;
     authenticate(userData: AuthenticationInput): Promise<AuthenticationResponse>;
 }
 export default EmailPasswordProvider;

package/dist/providers/email-password.js

@@ -7,9 +7,18 @@ const utils_1 = require("@medusajs/utils");
 const scrypt_kdf_1 = __importDefault(require("scrypt-kdf"));
 class EmailPasswordProvider extends utils_1.AbstractAuthModuleProvider {
     constructor({ authUserService }) {
-        super(arguments[0]);
+        super(arguments[0], {
+            provider: EmailPasswordProvider.PROVIDER,
+            displayName: EmailPasswordProvider.DISPLAY_NAME,
+        });
         this.authUserSerivce_ = authUserService;
     }
+    getHashConfig() {
+        const scopeConfig = this.scopeConfig_.hashConfig;
+        const defaultHashConfig = { logN: 15, r: 8, p: 1 };
+        // Return custom defined hash config or default hash parameters
+        return scopeConfig ?? defaultHashConfig;
+    }
     async authenticate(userData) {
         const { email, password } = userData.body;
         if (!password || !(0, utils_1.isString)(password)) {
@@ -24,7 +33,30 @@ class EmailPasswordProvider extends utils_1.AbstractAuthModuleProvider {
                 error: "Email should be a string",
             };
         }
-        const authUser = await this.authUserSerivce_.retrieveByProviderAndEntityId(email, EmailPasswordProvider.PROVIDER);
+        let authUser;
+        try {
+            authUser = await this.authUserSerivce_.retrieveByProviderAndEntityId(email, EmailPasswordProvider.PROVIDER);
+        }
+        catch (error) {
+            if (error.type === utils_1.MedusaError.Types.NOT_FOUND) {
+                const password_hash = await scrypt_kdf_1.default.kdf(password, this.getHashConfig());
+                const [createdAuthUser] = await this.authUserSerivce_.create([
+                    {
+                        entity_id: email,
+                        provider: EmailPasswordProvider.PROVIDER,
+                        scope: this.scope_,
+                        provider_metadata: {
+                            password: password_hash.toString("base64"),
+                        },
+                    },
+                ]);
+                return {
+                    success: true,
+                    authUser: JSON.parse(JSON.stringify(createdAuthUser)),
+                };
+            }
+            return { success: false, error: error.message };
+        }
         const password_hash = authUser.provider_metadata?.password;
         if ((0, utils_1.isString)(password_hash)) {
             const buf = Buffer.from(password_hash, "base64");

package/dist/providers/google.d.ts

@@ -1,19 +1,19 @@
+import { AuthenticationInput, AuthenticationResponse, ModulesSdkTypes } from "@medusajs/types";
 import { AbstractAuthModuleProvider } from "@medusajs/utils";
-import { AuthenticationInput, AuthenticationResponse } from "@medusajs/types";
-import { AuthProviderService, AuthUserService } from "../services";
+import { AuthUserService } from "../services";
 type InjectedDependencies = {
     authUserService: AuthUserService;
-    authProviderService: AuthProviderService;
+    authProviderService: ModulesSdkTypes.InternalModuleService<any>;
 };
 declare class GoogleProvider extends AbstractAuthModuleProvider {
     static PROVIDER: string;
     static DISPLAY_NAME: string;
-    protected readonly authUserSerivce_: AuthUserService;
-    protected readonly authProviderService_: AuthProviderService;
+    protected readonly authUserService_: AuthUserService;
+    protected readonly authProviderService_: ModulesSdkTypes.InternalModuleService<any>;
     constructor({ authUserService, authProviderService }: InjectedDependencies);
     authenticate(req: AuthenticationInput): Promise<AuthenticationResponse>;
     validateCallback(req: AuthenticationInput): Promise<AuthenticationResponse>;
-    verify_(refreshToken: string, scope: string): Promise<{
+    verify_(refreshToken: string): Promise<{
         success: boolean;
         error: any;
         authUser?: undefined;

package/dist/providers/google.js

@@ -9,8 +9,11 @@ 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;
+        super(arguments[0], {
+            provider: GoogleProvider.PROVIDER,
+            displayName: GoogleProvider.DISPLAY_NAME,
+        });
+        this.authUserService_ = authUserService;
         this.authProviderService_ = authProviderService;
     }
     async authenticate(req) {
@@ -44,28 +47,29 @@ class GoogleProvider extends utils_1.AbstractAuthModuleProvider {
             return { success: false, error: error.message };
         }
         const code = req.query?.code ?? req.body?.code;
-        return await this.validateCallbackToken(code, req.scope, config);
+        return await this.validateCallbackToken(code, config);
     }
     // abstractable
-    async verify_(refreshToken, scope) {
-        const jwtData = (await jsonwebtoken_1.default.decode(refreshToken, {
+    async verify_(refreshToken) {
+        const jwtData = 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);
+            authUser = await this.authUserService_.retrieveByProviderAndEntityId(entity_id, GoogleProvider.PROVIDER);
         }
         catch (error) {
             if (error.type === utils_1.MedusaError.Types.NOT_FOUND) {
-                authUser = await this.authUserSerivce_.create([
+                const [createdAuthUser] = await this.authUserService_.create([
                     {
                         entity_id,
-                        provider_id: GoogleProvider.PROVIDER,
+                        provider: GoogleProvider.PROVIDER,
                         user_metadata: jwtData.payload,
-                        app_metadata: { scope },
+                        scope: this.scope_,
                     },
                 ]);
+                authUser = createdAuthUser;
             }
             else {
                 return { success: false, error: error.message };
@@ -74,7 +78,7 @@ class GoogleProvider extends utils_1.AbstractAuthModuleProvider {
         return { success: true, authUser };
     }
     // abstractable
-    async validateCallbackToken(code, scope, { clientID, callbackURL, clientSecret }) {
+    async validateCallbackToken(code, { clientID, callbackURL, clientSecret }) {
         const client = this.getAuthorizationCodeHandler({ clientID, clientSecret });
         const tokenParams = {
             code,
@@ -82,46 +86,35 @@ class GoogleProvider extends utils_1.AbstractAuthModuleProvider {
         };
         try {
             const accessToken = await client.getToken(tokenParams);
-            return await this.verify_(accessToken.token.id_token, scope);
+            return await this.verify_(accessToken.token.id_token);
         }
         catch (error) {
             return { success: false, error: error.message };
         }
     }
-    getConfigFromScope(config) {
-        const providerConfig = {};
-        if (config.clientId) {
-            providerConfig.clientID = config.clientId;
-        }
-        else {
+    getConfigFromScope() {
+        const config = { ...this.scopeConfig_ };
+        if (!config.clientID) {
             throw new Error("Google clientID is required");
         }
-        if (config.clientSecret) {
-            providerConfig.clientSecret = config.clientSecret;
-        }
-        else {
+        if (!config.clientSecret) {
             throw new Error("Google clientSecret is required");
         }
-        if (config.callbackURL) {
-            providerConfig.callbackURL = config.callbackUrl;
-        }
-        else {
+        if (!config.callbackURL) {
             throw new Error("Google callbackUrl is required");
         }
-        return providerConfig;
+        return config;
     }
     originalURL(req) {
-        const tls = req.connection.encrypted;
         const host = req.headers.host;
-        const protocol = tls ? "https" : "http";
+        const protocol = req.protocol;
         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 config = this.getConfigFromScope();
+        const callbackURL = config.callbackURL;
         const parsedCallbackUrl = !url_1.default.parse(callbackURL).protocol
             ? url_1.default.resolve(this.originalURL(req), callbackURL)
             : callbackURL;

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

@@ -1,46 +1,27 @@
-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 ".";
+import { AuthenticationInput, AuthenticationResponse, AuthTypes, AuthUserDTO, Context, CreateAuthUserDTO, DAL, InternalModuleDeclaration, ModuleJoinerConfig, ModulesSdkTypes, UpdateAuthUserDTO } from "@medusajs/types";
+import { AuthUser } from "../models";
+import { AbstractAuthModuleProvider, ModulesSdkUtils } from "@medusajs/utils";
 type InjectedDependencies = {
     baseRepository: DAL.RepositoryService;
-    authUserService: AuthUserService<any>;
-    authProviderService: AuthProviderService<any>;
+    authUserService: ModulesSdkTypes.InternalModuleService<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>;
+declare const AuthModuleService_base: new (container: InjectedDependencies) => ModulesSdkUtils.AbstractModuleService<InjectedDependencies, AuthTypes.AuthUserDTO, {
+    AuthUser: {
+        dto: AuthUserDTO;
     };
-    protected __container__: MedusaContainer;
+}>;
+export default class AuthModuleService<TAuthUser extends AuthUser = AuthUser> extends AuthModuleService_base implements AuthTypes.IAuthModuleService {
+    protected readonly moduleDeclaration: InternalModuleDeclaration;
     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;
+    protected authUserService_: ModulesSdkTypes.InternalModuleService<TAuthUser>;
+    constructor({ authUserService, baseRepository }: InjectedDependencies, moduleDeclaration: InternalModuleDeclaration);
+    __joinerConfig(): ModuleJoinerConfig;
+    create(data: CreateAuthUserDTO[], sharedContext?: Context): Promise<AuthUserDTO[]>;
+    create(data: CreateAuthUserDTO, sharedContext?: Context): Promise<AuthUserDTO>;
+    update(data: UpdateAuthUserDTO[], sharedContext?: Context): Promise<AuthUserDTO[]>;
+    update(data: UpdateAuthUserDTO, sharedContext?: Context): Promise<AuthUserDTO>;
+    protected getRegisteredAuthenticationProvider(provider: string, { authScope }: 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

@@ -12,122 +12,47 @@ 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 _models_1 = require("../models");
 const joiner_config_1 = require("../joiner-config");
-class AuthModuleService {
-    __joinerConfig() {
-        return joiner_config_1.joinerConfig;
-    }
-    constructor({ authUserService, authProviderService, baseRepository, }, moduleDeclaration) {
+const utils_1 = require("@medusajs/utils");
+const generateMethodForModels = [_models_1.AuthUser];
+class AuthModuleService extends utils_1.ModulesSdkUtils.abstractModuleServiceFactory(_models_1.AuthUser, generateMethodForModels, joiner_config_1.entityNameToLinkableKeysMap) {
+    constructor({ authUserService, baseRepository }, moduleDeclaration) {
+        // @ts-ignore
+        super(...arguments);
         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"],
-        });
+    __joinerConfig() {
+        return joiner_config_1.joinerConfig;
     }
-    async listAuthUsers(filters = {}, config = {}, sharedContext = {}) {
-        const authUsers = await this.authUserService_.list(filters, config, sharedContext);
+    async create(data, sharedContext = {}) {
+        const authUsers = await this.authUserService_.create(data, 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);
+    // TODO: should be pluralized, see convention about the methods naming or the abstract module service interface definition @engineering
+    async update(data, sharedContext = {}) {
+        const updatedUsers = await this.authUserService_.update(data, 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 }) {
+    getRegisteredAuthenticationProvider(provider, { authScope }) {
         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?`);
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_FOUND, `AuthenticationProvider: ${provider} wasn't registered in the module. Have you configured your options correctly?`);
         }
-        containerProvider.validateScope(scope);
-        return containerProvider;
+        return containerProvider.withScope(authScope);
     }
     async authenticate(provider, authenticationData) {
         try {
-            await this.retrieveAuthProvider(provider, {});
             const registeredProvider = this.getRegisteredAuthenticationProvider(provider, authenticationData);
             return await registeredProvider.authenticate(authenticationData);
         }
@@ -137,7 +62,6 @@ class AuthModuleService {
     }
     async validateCallback(provider, authenticationData) {
         try {
-            await this.retrieveAuthProvider(provider, {});
             const registeredProvider = this.getRegisteredAuthenticationProvider(provider, authenticationData);
             return await registeredProvider.validateCallback(authenticationData);
         }
@@ -145,132 +69,19 @@ class AuthModuleService {
             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);
+], AuthModuleService.prototype, "create", 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);
+], AuthModuleService.prototype, "update", null);

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

@@ -1,18 +1,11 @@
-import { AuthTypes, Context, DAL, FindConfig } from "@medusajs/types";
-import { ModulesSdkUtils } from "@medusajs/utils";
+import { AuthTypes, Context, DAL, FindConfig, RepositoryService } from "@medusajs/types";
 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;
-}>;
+declare const AuthUserService_base: new <TEntity_1 extends object = any>(container: InjectedDependencies) => import("@medusajs/types").InternalModuleService<TEntity_1, InjectedDependencies>;
 export default class AuthUserService<TEntity extends AuthUser = AuthUser> extends AuthUserService_base<TEntity> {
-    protected readonly authUserRepository_: RepositoryTypes.IAuthUserRepository<TEntity>;
+    protected readonly authUserRepository_: RepositoryService<TEntity>;
     constructor(container: InjectedDependencies);
     retrieveByProviderAndEntityId<TEntityMethod = AuthTypes.AuthUserDTO>(entityId: string, provider: string, config?: FindConfig<TEntityMethod>, sharedContext?: Context): Promise<TEntity>;
 }

package/dist/services/auth-user.js

@@ -14,7 +14,7 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const utils_1 = require("@medusajs/utils");
 const _models_1 = require("../models");
-class AuthUserService extends utils_1.ModulesSdkUtils.abstractServiceFactory(_models_1.AuthUser) {
+class AuthUserService extends utils_1.ModulesSdkUtils.internalModuleServiceFactory(_models_1.AuthUser) {
     constructor(container) {
         // @ts-ignore
         super(...arguments);

package/dist/services/index.d.ts

@@ -1,3 +1,2 @@
 export { default as AuthModuleService } from "./auth-module";
-export { default as AuthProviderService } from "./auth-provider";
 export { default as AuthUserService } from "./auth-user";

package/dist/services/index.js

@@ -3,10 +3,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AuthUserService = exports.AuthProviderService = exports.AuthModuleService = void 0;
+exports.AuthUserService = exports.AuthModuleService = void 0;
 var auth_module_1 = require("./auth-module");
 Object.defineProperty(exports, "AuthModuleService", { enumerable: true, get: function () { return __importDefault(auth_module_1).default; } });
-var auth_provider_1 = require("./auth-provider");
-Object.defineProperty(exports, "AuthProviderService", { enumerable: true, get: function () { return __importDefault(auth_provider_1).default; } });
 var auth_user_1 = require("./auth-user");
 Object.defineProperty(exports, "AuthUserService", { enumerable: true, get: function () { return __importDefault(auth_user_1).default; } });

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

@@ -1,16 +1 @@
-import { AuthProvider, AuthUser } from "../../models";
-import { CreateAuthProviderDTO, UpdateAuthProviderDTO } from "./auth-provider";
-import { DAL } from "@medusajs/types";
-import { CreateAuthUserDTO, UpdateAuthUserDTO } from "./auth-user";
 export * from "./auth-user";
-export * from "./auth-provider";
-export interface IAuthProviderRepository<TEntity extends AuthProvider = AuthProvider> extends DAL.RepositoryService<TEntity, {
-    create: CreateAuthProviderDTO;
-    update: UpdateAuthProviderDTO;
-}> {
-}
-export interface IAuthUserRepository<TEntity extends AuthUser = AuthUser> extends DAL.RepositoryService<TEntity, {
-    create: CreateAuthUserDTO;
-    update: UpdateAuthUserDTO;
-}> {
-}

package/dist/types/repositories/index.js

@@ -15,4 +15,3 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./auth-user"), exports);
-__exportStar(require("./auth-provider"), exports);

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

@@ -1,16 +1,17 @@
-import { AuthProviderDTO } from "./auth-provider";
 export type AuthUserDTO = {
     id: string;
     provider_id: string;
     entity_id: string;
-    provider: AuthProviderDTO;
+    scope: string;
+    provider: string;
     provider_metadata?: Record<string, unknown>;
     user_metadata: Record<string, unknown>;
     app_metadata: Record<string, unknown>;
 };
 export type CreateAuthUserDTO = {
     entity_id: string;
-    provider_id: string;
+    provider: string;
+    scope: string;
     provider_metadata?: Record<string, unknown>;
     user_metadata?: Record<string, unknown>;
     app_metadata?: Record<string, unknown>;

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

@@ -1,2 +1 @@
 export * from "./auth-user";
-export * from "./auth-provider";

package/dist/types/services/index.js

@@ -15,4 +15,3 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./auth-user"), exports);
-__exportStar(require("./auth-provider"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@medusajs/auth",
-  "version": "0.0.2",
+  "version": "0.0.3-next-20240319121007",
   "description": "Medusa Auth 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,14 @@
     "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.1.4",
+    "dotenv": "^16.4.5",
     "jsonwebtoken": "^9.0.2",
     "knex": "2.4.2",
     "scrypt-kdf": "^2.0.1",

package/dist/migrations/Migration20240122041959.d.ts

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

package/dist/migrations/Migration20240122041959.js

@@ -1,18 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Migration20240122041959 = void 0;
-const migrations_1 = require("@mikro-orm/migrations");
-class Migration20240122041959 extends migrations_1.Migration {
-    async up() {
-        this.addSql('create table if not exists "auth_provider" ("provider" text not null, "name" text not null, "domain" text check ("domain" in (\'all\', \'store\', \'admin\')) not null default \'all\', "config" jsonb null, "is_active" boolean not null default false, constraint "auth_provider_pkey" primary key ("provider"));');
-        this.addSql('create table if not exists "auth_user" ("id" text not null, "entity_id" text not null, "provider_id" text null, "user_metadata" jsonb null, "app_metadata" jsonb null, "provider_metadata" jsonb null, constraint "auth_user_pkey" primary key ("id"));');
-        this.addSql('alter table "auth_user" add constraint "IDX_auth_user_provider_entity_id" unique ("provider_id", "entity_id");');
-        this.addSql('alter table "auth_user" add constraint if not exists "auth_user_provider_id_foreign" foreign key ("provider_id") references "auth_provider" ("provider") on delete cascade;');
-    }
-    async down() {
-        this.addSql('alter table "auth_user" drop constraint if exists "auth_user_provider_id_foreign";');
-        this.addSql('drop table if exists "auth_provider" cascade;');
-        this.addSql('drop table if exists "auth_user" cascade;');
-    }
-}
-exports.Migration20240122041959 = Migration20240122041959;

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

@@ -1,12 +0,0 @@
-import { OptionalProps } from "@mikro-orm/core";
-import { ProviderDomain } from "../types/repositories/auth-provider";
-type OptionalFields = "domain" | "is_active" | "config";
-export default class AuthProvider {
-    [OptionalProps]: OptionalFields;
-    provider: string;
-    name: string;
-    domain: ProviderDomain;
-    config: Record<string, unknown> | null;
-    is_active: boolean;
-}
-export {};

package/dist/models/auth-provider.js

@@ -1,44 +0,0 @@
-"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 auth_provider_1 = require("../types/repositories/auth-provider");
-let AuthProvider = class AuthProvider {
-    constructor() {
-        this.domain = auth_provider_1.ProviderDomain.ALL;
-        this.config = null;
-        this.is_active = false;
-    }
-};
-__decorate([
-    (0, core_1.PrimaryKey)({ columnType: "text" }),
-    __metadata("design:type", String)
-], AuthProvider.prototype, "provider", void 0);
-__decorate([
-    (0, core_1.Property)({ columnType: "text" }),
-    __metadata("design:type", String)
-], AuthProvider.prototype, "name", void 0);
-__decorate([
-    (0, core_1.Enum)({ items: () => auth_provider_1.ProviderDomain, default: auth_provider_1.ProviderDomain.ALL }),
-    __metadata("design:type", String)
-], AuthProvider.prototype, "domain", void 0);
-__decorate([
-    (0, core_1.Property)({ columnType: "jsonb", nullable: true }),
-    __metadata("design:type", Object)
-], AuthProvider.prototype, "config", void 0);
-__decorate([
-    (0, core_1.Property)({ columnType: "boolean", default: false }),
-    __metadata("design:type", Object)
-], AuthProvider.prototype, "is_active", void 0);
-AuthProvider = __decorate([
-    (0, core_1.Entity)()
-], AuthProvider);
-exports.default = AuthProvider;

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

@@ -1,18 +0,0 @@
-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

@@ -1,11 +0,0 @@
-"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/types/repositories/auth-provider.d.ts

@@ -1,23 +0,0 @@
-import { AuthProvider } from "../../models";
-export type CreateAuthProviderDTO = {
-    provider: string;
-    name: string;
-    domain?: ProviderDomain;
-    is_active?: boolean;
-    config?: Record<string, unknown>;
-};
-export type UpdateAuthProviderDTO = {
-    update: {
-        provider: string;
-        name?: string;
-        domain?: ProviderDomain;
-        is_active?: boolean;
-        config?: Record<string, unknown>;
-    };
-    provider: AuthProvider;
-};
-export declare enum ProviderDomain {
-    ALL = "all",
-    STORE = "store",
-    ADMIN = "admin"
-}

package/dist/types/repositories/auth-provider.js

@@ -1,9 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ProviderDomain = void 0;
-var ProviderDomain;
-(function (ProviderDomain) {
-    ProviderDomain["ALL"] = "all";
-    ProviderDomain["STORE"] = "store";
-    ProviderDomain["ADMIN"] = "admin";
-})(ProviderDomain || (exports.ProviderDomain = ProviderDomain = {}));

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

@@ -1,27 +0,0 @@
-export type AuthProviderDTO = {
-    provider: string;
-    name: string;
-    domain: ProviderDomain;
-    is_active: boolean;
-    config: Record<string, unknown>;
-};
-export type CreateAuthProviderDTO = {
-    provider: string;
-    name: string;
-    domain?: ProviderDomain;
-    is_active?: boolean;
-    config?: Record<string, unknown>;
-};
-export type UpdateAuthProviderDTO = {
-    provider: string;
-    name?: string;
-    domain?: ProviderDomain;
-    is_active?: boolean;
-    config?: Record<string, unknown>;
-};
-export declare enum ProviderDomain {
-    ALL = "all",
-    STORE = "store",
-    ADMIN = "admin"
-}
-export type FilterableAuthProviderProps = {};

package/dist/types/services/auth-provider.js

@@ -1,9 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ProviderDomain = void 0;
-var ProviderDomain;
-(function (ProviderDomain) {
-    ProviderDomain["ALL"] = "all";
-    ProviderDomain["STORE"] = "store";
-    ProviderDomain["ADMIN"] = "admin";
-})(ProviderDomain || (exports.ProviderDomain = ProviderDomain = {}));