@drax/identity-back 0.1.0 → 0.1.4

package/types/config/IdentityConfig.d.ts

@@ -0,0 +1,12 @@
+declare enum IdentityConfig {
+    JwtSecret = "DRAX_JWT_SECRET",
+    JwtExpiration = "DRAX_JWT_EXPIRATION",
+    JwtIssuer = "DRAX_JWT_ISSUER",
+    ApiKeySecret = "DRAX_APIKEY_SECRET",
+    ApiKeyCacheTTL = "DRAX_APIKEY_CACHE_TTL",
+    RbacCacheTTL = "DRAX_RBAC_CACHE_TTL",
+    AvatarDir = "DRAX_AVATAR_DIR"
+}
+export default IdentityConfig;
+export { IdentityConfig };
+//# sourceMappingURL=IdentityConfig.d.ts.map

package/types/config/IdentityConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IdentityConfig.d.ts","sourceRoot":"","sources":["../../src/config/IdentityConfig.ts"],"names":[],"mappings":"AAAA,aAAK,cAAc;IAIf,SAAS,oBAAoB;IAC7B,aAAa,wBAAwB;IACrC,SAAS,oBAAoB;IAE7B,YAAY,uBAAuB;IACnC,cAAc,0BAA0B;IAExC,YAAY,wBAAwB;IAEpC,SAAS,oBAAoB;CAGhC;AAED,eAAe,cAAc,CAAC;AAC9B,OAAO,EAAC,cAAc,EAAC,CAAC"}

package/types/errors/BadCredentialsError.d.ts

@@ -0,0 +1,6 @@
+declare class BadCredentialsError extends Error {
+    constructor();
+    get statusCode(): number;
+}
+export default BadCredentialsError;
+//# sourceMappingURL=BadCredentialsError.d.ts.map

package/types/errors/BadCredentialsError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BadCredentialsError.d.ts","sourceRoot":"","sources":["../../src/errors/BadCredentialsError.ts"],"names":[],"mappings":"AAAA,cAAM,mBAAoB,SAAQ,KAAK;;IAMnC,IAAI,UAAU,WAEb;CAEJ;AAED,eAAe,mBAAmB,CAAA"}

package/types/errors/UnauthorizedError.d.ts

@@ -0,0 +1,6 @@
+declare class UnauthorizedError extends Error {
+    constructor();
+    get statusCode(): number;
+}
+export default UnauthorizedError;
+//# sourceMappingURL=UnauthorizedError.d.ts.map

package/types/errors/UnauthorizedError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UnauthorizedError.d.ts","sourceRoot":"","sources":["../../src/errors/UnauthorizedError.ts"],"names":[],"mappings":"AAAA,cAAM,iBAAkB,SAAQ,KAAK;;IAMjC,IAAI,UAAU,WAEb;CAEJ;AAED,eAAe,iBAAiB,CAAA"}

package/types/factory/RoleServiceFactory.d.ts

@@ -0,0 +1,4 @@
+import RoleService from "../services/RoleService.js";
+declare const RoleServiceFactory: (verbose?: boolean) => RoleService;
+export default RoleServiceFactory;
+//# sourceMappingURL=RoleServiceFactory.d.ts.map

package/types/factory/TenantServiceFactory.d.ts

@@ -0,0 +1,4 @@
+import TenantService from "../services/TenantService.js";
+declare const TenantServiceFactory: (verbose?: boolean) => TenantService;
+export default TenantServiceFactory;
+//# sourceMappingURL=TenantServiceFactory.d.ts.map

package/types/factory/UserApiKeyServiceFactory.d.ts

@@ -0,0 +1,4 @@
+import UserApiKeyService from "../services/UserApiKeyService.js";
+declare const UserApiKeyServiceFactory: (verbose?: boolean) => UserApiKeyService;
+export default UserApiKeyServiceFactory;
+//# sourceMappingURL=UserApiKeyServiceFactory.d.ts.map

package/types/factory/UserServiceFactory.d.ts

@@ -0,0 +1,4 @@
+import UserService from "../services/UserService.js";
+declare const UserServiceFactory: (verbose?: boolean) => UserService;
+export default UserServiceFactory;
+//# sourceMappingURL=UserServiceFactory.d.ts.map

package/types/graphql/index.d.ts

@@ -0,0 +1,6 @@
+declare const _default: () => Promise<{
+    typeDefs: Promise<import("@graphql-tools/utils").TypeSource>;
+    resolvers: Promise<import("@graphql-tools/utils").IResolvers>;
+}>;
+export default _default;
+//# sourceMappingURL=index.d.ts.map

package/types/graphql/resolvers/role.resolvers.d.ts

@@ -0,0 +1,52 @@
+declare const _default: {
+    Query: {
+        findRoleById: (_: any, { id }: {
+            id: any;
+        }, { rbac }: {
+            rbac: any;
+        }) => Promise<import("packages/identity/identity-share/types/index.js").IRole>;
+        findRoleByName: (_: any, { name }: {
+            name: any;
+        }, { rbac }: {
+            rbac: any;
+        }) => Promise<import("packages/identity/identity-share/types/index.js").IRole>;
+        fetchRole: (_: any, {}: {}, { rbac }: {
+            rbac: any;
+        }) => Promise<import("packages/identity/identity-share/types/index.js").IRole[]>;
+        fetchPermissions: (_: any, {}: {}, { rbac }: {
+            rbac: any;
+        }) => Promise<string[]>;
+        paginateRole: (_: any, { options }: {
+            options?: {
+                page: number;
+                limit: number;
+                orderBy: string;
+                orderDesc: boolean;
+                search: string;
+                filters: any[];
+            };
+        }, { rbac }: {
+            rbac: any;
+        }) => Promise<import("packages/common/common-share/types/index.js").IDraxPaginateResult<import("packages/identity/identity-share/types/index.js").IRole>>;
+    };
+    Mutation: {
+        createRole: (_: any, { input }: {
+            input: any;
+        }, { rbac }: {
+            rbac: any;
+        }) => Promise<import("packages/identity/identity-share/types/index.js").IRole>;
+        updateRole: (_: any, { id, input }: {
+            id: any;
+            input: any;
+        }, { rbac }: {
+            rbac: any;
+        }) => Promise<import("packages/identity/identity-share/types/index.js").IRole>;
+        deleteRole: (_: any, { id }: {
+            id: any;
+        }, { rbac }: {
+            rbac: any;
+        }) => Promise<boolean>;
+    };
+};
+export default _default;
+//# sourceMappingURL=role.resolvers.d.ts.map

package/types/graphql/resolvers/tenant.resolvers.d.ts

@@ -0,0 +1,49 @@
+declare const _default: {
+    Query: {
+        findTenantById: (_: any, { id }: {
+            id: any;
+        }, { rbac }: {
+            rbac: any;
+        }) => Promise<import("packages/identity/identity-share/types/index.js").ITenant>;
+        findTenantByName: (_: any, { name }: {
+            name: any;
+        }, { rbac }: {
+            rbac: any;
+        }) => Promise<import("packages/identity/identity-share/types/index.js").ITenant>;
+        fetchTenant: (_: any, {}: {}, { rbac }: {
+            rbac: any;
+        }) => Promise<import("packages/identity/identity-share/types/index.js").ITenant[]>;
+        paginateTenant: (_: any, { options }: {
+            options?: {
+                page: number;
+                limit: number;
+                orderBy: string;
+                orderDesc: boolean;
+                search: string;
+                filters: any[];
+            };
+        }, { rbac }: {
+            rbac: any;
+        }) => Promise<import("packages/common/common-share/types/index.js").IDraxPaginateResult<import("packages/identity/identity-share/types/index.js").ITenant>>;
+    };
+    Mutation: {
+        createTenant: (_: any, { input }: {
+            input: any;
+        }, { rbac }: {
+            rbac: any;
+        }) => Promise<import("packages/identity/identity-share/types/index.js").ITenant>;
+        updateTenant: (_: any, { id, input }: {
+            id: any;
+            input: any;
+        }, { rbac }: {
+            rbac: any;
+        }) => Promise<import("packages/identity/identity-share/types/index.js").ITenant>;
+        deleteTenant: (_: any, { id }: {
+            id: any;
+        }, { rbac }: {
+            rbac: any;
+        }) => Promise<boolean>;
+    };
+};
+export default _default;
+//# sourceMappingURL=tenant.resolvers.d.ts.map

package/types/graphql/resolvers/user-api-key.resolvers.d.ts

@@ -0,0 +1,37 @@
+declare const _default: {
+    Query: {
+        paginateUserApiKey: (_: any, { options }: {
+            options?: {
+                page: number;
+                limit: number;
+                orderBy: string;
+                orderDesc: boolean;
+                search: string;
+                filters: any[];
+            };
+        }, { rbac, authUser }: {
+            rbac: any;
+            authUser: any;
+        }) => Promise<import("packages/common/common-share/types/index.js").IDraxPaginateResult<import("packages/identity/identity-share/types/index.js").IUserApiKey>>;
+    };
+    Mutation: {
+        createUserApiKey: (_: any, { input }: {
+            input: any;
+        }, { rbac }: {
+            rbac: any;
+        }) => Promise<import("packages/identity/identity-share/types/index.js").IUserApiKey>;
+        updateUserApiKey: (_: any, { id, input }: {
+            id: any;
+            input: any;
+        }, { rbac }: {
+            rbac: any;
+        }) => Promise<import("packages/identity/identity-share/types/index.js").IUserApiKey>;
+        deleteUserApiKey: (_: any, { id }: {
+            id: any;
+        }, { rbac }: {
+            rbac: any;
+        }) => Promise<boolean>;
+    };
+};
+export default _default;
+//# sourceMappingURL=user-api-key.resolvers.d.ts.map

package/types/graphql/resolvers/user.resolvers.d.ts

@@ -0,0 +1,67 @@
+declare const _default: {
+    Query: {
+        me: (_: any, {}: {}, { authUser }: {
+            authUser: any;
+        }) => Promise<import("packages/identity/identity-share/types/index.js").IUser>;
+        findUserById: (_: any, { id }: {
+            id: any;
+        }, { rbac }: {
+            rbac: any;
+        }) => Promise<import("packages/identity/identity-share/types/index.js").IUser>;
+        paginateUser: (_: any, { options }: {
+            options?: {
+                page: number;
+                limit: number;
+                orderBy: string;
+                orderDesc: boolean;
+                search: string;
+                filters: any[];
+            };
+        }, { rbac }: {
+            rbac: any;
+        }) => Promise<import("packages/common/common-share/types/index.js").IDraxPaginateResult<import("packages/identity/identity-share/types/index.js").IUser>>;
+    };
+    Mutation: {
+        auth: (_: any, { input }: {
+            input: any;
+        }) => Promise<{
+            accessToken: string;
+        }>;
+        createUser: (_: any, { input }: {
+            input: any;
+        }, { rbac }: {
+            rbac: any;
+        }) => Promise<import("packages/identity/identity-share/types/index.js").IUser>;
+        updateUser: (_: any, { id, input }: {
+            id: any;
+            input: any;
+        }, { rbac }: {
+            rbac: any;
+        }) => Promise<import("packages/identity/identity-share/types/index.js").IUser>;
+        deleteUser: (_: any, { id }: {
+            id: any;
+        }, { rbac }: {
+            rbac: any;
+        }) => Promise<boolean>;
+        changeOwnPassword: (_: any, { currentPassword, newPassword }: {
+            currentPassword: any;
+            newPassword: any;
+        }, { authUser }: {
+            authUser: any;
+        }) => Promise<boolean>;
+        changeUserPassword: (_: any, { userId, newPassword }: {
+            userId: any;
+            newPassword: any;
+        }, { rbac }: {
+            rbac: any;
+        }) => Promise<boolean>;
+        changeAvatar: (_: any, { file }: {
+            file: any;
+        }, { rbac, authUser }: {
+            rbac: any;
+            authUser: any;
+        }) => Promise<boolean>;
+    };
+};
+export default _default;
+//# sourceMappingURL=user.resolvers.d.ts.map

package/types/index.d.ts

@@ -0,0 +1,35 @@
+import UserServiceFactory from "./factory/UserServiceFactory.js";
+import RoleServiceFactory from "./factory/RoleServiceFactory.js";
+import TenantServiceFactory from "./factory/TenantServiceFactory.js";
+import RoleService from "./services/RoleService.js";
+import UserService from "./services/UserService.js";
+import TenantService from "./services/TenantService.js";
+import PermissionService from "./services/PermissionService.js";
+import Rbac from "./rbac/Rbac.js";
+import { UserRoutes } from "./routes/UserRoutes.js";
+import { UserAvatarRoutes } from "./routes/UserAvatarRoutes.js";
+import { RoleRoutes } from "./routes/RoleRoutes.js";
+import { TenantRoutes } from "./routes/TenantRoutes.js";
+import { UserApiKeyRoutes } from "./routes/UserApiKeyRoutes.js";
+import AuthUtils from "./utils/AuthUtils.js";
+import { jwtMiddleware } from "./middleware/jwtMiddleware.js";
+import { rbacMiddleware } from "./middleware/rbacMiddleware.js";
+import { apiKeyMiddleware } from "./middleware/apiKeyMiddleware.js";
+import IdentityPermissions from "./permissions/IdentityPermissions.js";
+import IdentityConfig from "./config/IdentityConfig.js";
+import UnauthorizedError from "./errors/UnauthorizedError.js";
+import BadCredentialsError from "./errors/BadCredentialsError.js";
+import CreateUserIfNotExist from "./setup/CreateUserIfNotExist.js";
+import CreateOrUpdateRole from "./setup/CreateOrUpdateRole.js";
+import LoadPermissions from "./setup/LoadPermissions.js";
+import LoadIdentityConfigFromEnv from "./setup/LoadIdentityConfigFromEnv.js";
+import RecoveryUserPassword from "./setup/RecoveryUserPassword.js";
+import type { IRoleRepository } from "./interfaces/IRoleRepository";
+import type { ITenantRepository } from "./interfaces/ITenantRepository";
+import type { IUserRepository } from "./interfaces/IUserRepository";
+import type { IUserApiKeyRepository } from "./interfaces/IUserApiKeyRepository";
+declare const identityTypeDefs: import("@graphql-tools/utils").TypeSource;
+declare const identityResolvers: import("@graphql-tools/utils").IResolvers;
+export type { IRoleRepository, ITenantRepository, IUserRepository, IUserApiKeyRepository };
+export { UserService, RoleService, TenantService, PermissionService, Rbac, UserServiceFactory, RoleServiceFactory, TenantServiceFactory, identityTypeDefs, identityResolvers, UserRoutes, RoleRoutes, TenantRoutes, UserAvatarRoutes, UserApiKeyRoutes, AuthUtils, jwtMiddleware, rbacMiddleware, apiKeyMiddleware, IdentityPermissions, IdentityConfig, UnauthorizedError, BadCredentialsError, LoadIdentityConfigFromEnv, LoadPermissions, CreateOrUpdateRole, CreateUserIfNotExist, RecoveryUserPassword };
+//# sourceMappingURL=index.d.ts.map

package/types/interfaces/IRoleRepository.d.ts

@@ -0,0 +1,9 @@
+import { IRole, IRoleBase } from "@drax/identity-share";
+import { IDraxCrud } from "@drax/common-share";
+interface IRoleRepository extends IDraxCrud<IRole, IRoleBase, IRoleBase> {
+    findById(id: string): Promise<IRole | null>;
+    findByName(name: string): Promise<IRole | null>;
+    fetchAll(): Promise<IRole[]>;
+}
+export { IRoleRepository };
+//# sourceMappingURL=IRoleRepository.d.ts.map

package/types/interfaces/ITenantRepository.d.ts

@@ -0,0 +1,9 @@
+import { ITenant, ITenantBase } from '@drax/identity-share';
+import { IDraxCrud } from "@drax/common-share";
+interface ITenantRepository extends IDraxCrud<ITenant, ITenantBase, ITenantBase> {
+    findById(id: string): Promise<ITenant | null>;
+    findByName(name: string): Promise<ITenant | null>;
+    fetchAll(): Promise<ITenant[]>;
+}
+export { ITenantRepository };
+//# sourceMappingURL=ITenantRepository.d.ts.map

package/types/interfaces/IUserApiKeyRepository.d.ts

@@ -0,0 +1,7 @@
+import { IUserApiKey, IUserApiKeyBase } from '@drax/identity-share';
+import { IDraxCrud } from "@drax/common-share";
+interface IUserApiKeyRepository extends IDraxCrud<IUserApiKey, IUserApiKeyBase, IUserApiKeyBase> {
+    findBySecret(username: string): Promise<IUserApiKey | null>;
+}
+export { IUserApiKeyRepository };
+//# sourceMappingURL=IUserApiKeyRepository.d.ts.map

package/types/interfaces/IUserRepository.d.ts

@@ -0,0 +1,10 @@
+import { IUser, IUserCreate, IUserUpdate } from '@drax/identity-share';
+import { IDraxCrud } from "@drax/common-share";
+interface IUserRepository extends IDraxCrud<IUser, IUserCreate, IUserUpdate> {
+    findById(id: string): Promise<IUser | null>;
+    findByUsername(username: string): Promise<IUser | null>;
+    changePassword(id: string, password: string): Promise<Boolean>;
+    changeAvatar(id: string, avatarUrl: string): Promise<Boolean>;
+}
+export { IUserRepository };
+//# sourceMappingURL=IUserRepository.d.ts.map

package/types/middleware/apiKeyMiddleware.d.ts

@@ -0,0 +1,4 @@
+declare function apiKeyMiddleware(request: any, reply: any): Promise<void>;
+export default apiKeyMiddleware;
+export { apiKeyMiddleware };
+//# sourceMappingURL=apiKeyMiddleware.d.ts.map

package/types/middleware/jwtMiddleware.d.ts

@@ -0,0 +1,4 @@
+declare function jwtMiddleware(request: any, reply: any, done: any): void;
+export default jwtMiddleware;
+export { jwtMiddleware };
+//# sourceMappingURL=jwtMiddleware.d.ts.map

package/types/middleware/rbacMiddleware.d.ts

@@ -0,0 +1,4 @@
+declare function rbacMiddleware(request: any, reply: any): Promise<void>;
+export default rbacMiddleware;
+export { rbacMiddleware };
+//# sourceMappingURL=rbacMiddleware.d.ts.map

package/types/models/RoleModel.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="mongoose/types/document.js" />
+/// <reference types="mongoose/types/types.js" />
+/// <reference types="mongoose/types/models.js" />
+/// <reference types="mongoose/types/schemaoptions.js" />
+/// <reference types="mongoose/types/utility.js" />
+import { mongoose } from '@drax/common-back';
+import { IRole } from '@drax/identity-share';
+declare const RoleSchema: mongoose.Schema<IRole, mongoose.Model<IRole, any, any, any, mongoose.Document<unknown, any, IRole> & IRole & {
+    _id: mongoose.Types.ObjectId;
+}, any>, {}, {}, {}, {}, mongoose.DefaultSchemaOptions, IRole, mongoose.Document<unknown, {}, mongoose.FlatRecord<IRole>> & mongoose.FlatRecord<IRole> & {
+    _id: mongoose.Types.ObjectId;
+}>;
+declare const RoleModel: mongoose.PaginateModel<IRole, {}, {}>;
+export { RoleSchema, RoleModel };
+export default RoleModel;
+//# sourceMappingURL=RoleModel.d.ts.map

package/types/models/TenantModel.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="mongoose/types/document.js" />
+/// <reference types="mongoose/types/types.js" />
+/// <reference types="mongoose/types/models.js" />
+/// <reference types="mongoose/types/schemaoptions.js" />
+/// <reference types="mongoose/types/utility.js" />
+import { mongoose } from '@drax/common-back';
+import { ITenant } from '@drax/identity-share';
+declare const TenantSchema: mongoose.Schema<ITenant, mongoose.Model<ITenant, any, any, any, mongoose.Document<unknown, any, ITenant> & ITenant & {
+    _id: mongoose.Types.ObjectId;
+}, any>, {}, {}, {}, {}, mongoose.DefaultSchemaOptions, ITenant, mongoose.Document<unknown, {}, mongoose.FlatRecord<ITenant>> & mongoose.FlatRecord<ITenant> & {
+    _id: mongoose.Types.ObjectId;
+}>;
+declare const TenantModel: mongoose.PaginateModel<ITenant, {}, {}>;
+export { TenantSchema, TenantModel };
+export default TenantModel;
+//# sourceMappingURL=TenantModel.d.ts.map

package/types/models/UserApiKeyModel.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="mongoose/types/document.js" />
+/// <reference types="mongoose/types/types.js" />
+/// <reference types="mongoose/types/models.js" />
+/// <reference types="mongoose/types/schemaoptions.js" />
+/// <reference types="mongoose/types/utility.js" />
+import { mongoose } from '@drax/common-back';
+import { IUserApiKey } from "@drax/identity-share";
+declare const UserApiKeySchema: mongoose.Schema<IUserApiKey, mongoose.Model<IUserApiKey, any, any, any, mongoose.Document<unknown, any, IUserApiKey> & IUserApiKey & {
+    _id: mongoose.Types.ObjectId;
+}, any>, {}, {}, {}, {}, mongoose.DefaultSchemaOptions, IUserApiKey, mongoose.Document<unknown, {}, mongoose.FlatRecord<IUserApiKey>> & mongoose.FlatRecord<IUserApiKey> & {
+    _id: mongoose.Types.ObjectId;
+}>;
+declare const UserApiKeyModel: mongoose.PaginateModel<IUserApiKey, {}, {}>;
+export { UserApiKeySchema, UserApiKeyModel };
+export default UserApiKeyModel;
+//# sourceMappingURL=UserApiKeyModel.d.ts.map

package/types/models/UserGroupModel.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="mongoose/types/document.js" />
+/// <reference types="mongoose/types/types.js" />
+/// <reference types="mongoose/types/models.js" />
+/// <reference types="mongoose/types/schemaoptions.js" />
+/// <reference types="mongoose/types/utility.js" />
+import { mongoose } from '@drax/common-back';
+import { IUserGroup } from "@drax/identity-share";
+declare const UserGroupSchema: mongoose.Schema<IUserGroup, mongoose.Model<IUserGroup, any, any, any, mongoose.Document<unknown, any, IUserGroup> & IUserGroup & {
+    _id: mongoose.Types.ObjectId;
+}, any>, {}, {}, {}, {}, mongoose.DefaultSchemaOptions, IUserGroup, mongoose.Document<unknown, {}, mongoose.FlatRecord<IUserGroup>> & mongoose.FlatRecord<IUserGroup> & {
+    _id: mongoose.Types.ObjectId;
+}>;
+declare const UserGroupModel: mongoose.PaginateModel<IUserGroup, {}, {}>;
+export { UserGroupSchema, UserGroupModel };
+export default UserGroupModel;
+//# sourceMappingURL=UserGroupModel.d.ts.map

package/types/models/UserModel.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="mongoose/types/document.js" />
+/// <reference types="mongoose/types/types.js" />
+/// <reference types="mongoose/types/models.js" />
+/// <reference types="mongoose/types/schemaoptions.js" />
+/// <reference types="mongoose/types/utility.js" />
+import { mongoose } from '@drax/common-back';
+import { IUser } from "@drax/identity-share";
+declare const UserSchema: mongoose.Schema<IUser, mongoose.Model<IUser, any, any, any, mongoose.Document<unknown, any, IUser> & IUser & {
+    _id: mongoose.Types.ObjectId;
+}, any>, {}, {}, {}, {}, mongoose.DefaultSchemaOptions, IUser, mongoose.Document<unknown, {}, mongoose.FlatRecord<IUser>> & mongoose.FlatRecord<IUser> & {
+    _id: mongoose.Types.ObjectId;
+}>;
+declare const UserModel: mongoose.PaginateModel<IUser, {}, {}>;
+export { UserSchema, UserModel };
+export default UserModel;
+//# sourceMappingURL=UserModel.d.ts.map

package/types/permissions/IdentityPermissions.d.ts

@@ -0,0 +1,27 @@
+declare enum IdentityPermissions {
+    CreateUser = "user:create",
+    UpdateUser = "user:update",
+    DeleteUser = "user:delete",
+    ViewUser = "user:view",
+    ManageUser = "user:manage",
+    CreateUserApiKey = "userApiKey:create",
+    UpdateUserApiKey = "userApiKey:update",
+    DeleteUserApiKey = "userApiKey:delete",
+    ViewUserApiKey = "userApiKey:view",
+    ViewMyUserApiKey = "userApiKey:myView",
+    ManageUserApiKey = "userApiKey:manage",
+    CreateRole = "role:create",
+    UpdateRole = "role:update",
+    DeleteRole = "role:delete",
+    ViewRole = "role:view",
+    ManageRole = "role:manage",
+    PermissionsRole = "role:permissions",
+    CreateTenant = "tenant:create",
+    UpdateTenant = "tenant:update",
+    DeleteTenant = "tenant:delete",
+    ViewTenant = "tenant:view",
+    ManageTenant = "tenant:manage"
+}
+export default IdentityPermissions;
+export { IdentityPermissions };
+//# sourceMappingURL=IdentityPermissions.d.ts.map

package/types/permissions/IdentityPermissions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IdentityPermissions.d.ts","sourceRoot":"","sources":["../../src/permissions/IdentityPermissions.ts"],"names":[],"mappings":"AAAA,aAAK,mBAAmB;IAGpB,UAAU,gBAAgB;IAC1B,UAAU,gBAAgB;IAC1B,UAAU,gBAAgB;IAC1B,QAAQ,cAAc;IACtB,UAAU,gBAAgB;IAE1B,gBAAgB,sBAAsB;IACtC,gBAAgB,sBAAsB;IACtC,gBAAgB,sBAAsB;IACtC,cAAc,oBAAoB;IAClC,gBAAgB,sBAAsB;IACtC,gBAAgB,sBAAsB;IAEtC,UAAU,gBAAgB;IAC1B,UAAU,gBAAgB;IAC1B,UAAU,gBAAgB;IAC1B,QAAQ,cAAc;IACtB,UAAU,gBAAgB;IAC1B,eAAe,qBAAqB;IAGpC,YAAY,kBAAkB;IAC9B,YAAY,kBAAkB;IAC9B,YAAY,kBAAkB;IAC9B,UAAU,gBAAgB;IAC1B,YAAY,kBAAkB;CAEjC;AAED,eAAe,mBAAmB,CAAC;AACnC,OAAO,EAAC,mBAAmB,EAAC,CAAC"}

package/types/repository/mongo/RoleMongoRepository.d.ts

@@ -0,0 +1,14 @@
+import { IRoleRepository } from '../../interfaces/IRoleRepository';
+import { IDraxPaginateOptions, IDraxPaginateResult } from "@drax/common-share";
+import { IRoleBase, IRole } from "@drax/identity-share";
+declare class RoleMongoRepository implements IRoleRepository {
+    create(roleData: IRoleBase): Promise<IRole>;
+    update(id: string, roleData: IRoleBase): Promise<IRole>;
+    delete(id: string): Promise<boolean>;
+    findById(id: string): Promise<IRole | null>;
+    findByName(name: string): Promise<IRole | null>;
+    fetchAll(): Promise<IRole[]>;
+    paginate({ page, limit, orderBy, orderDesc, search, filters }: IDraxPaginateOptions): Promise<IDraxPaginateResult<IRole>>;
+}
+export default RoleMongoRepository;
+//# sourceMappingURL=RoleMongoRepository.d.ts.map

package/types/repository/mongo/TenantMongoRepository.d.ts

@@ -0,0 +1,14 @@
+import { ITenantRepository } from '../../interfaces/ITenantRepository';
+import { IDraxPaginateOptions, IDraxPaginateResult } from "@drax/common-share";
+import { ITenant, ITenantBase } from "@drax/identity-share";
+declare class TenantMongoRepository implements ITenantRepository {
+    create(tenantData: ITenantBase): Promise<ITenant>;
+    update(id: string, tenantData: ITenantBase): Promise<ITenant>;
+    delete(id: string): Promise<boolean>;
+    findById(id: string): Promise<ITenant | null>;
+    findByName(name: string): Promise<ITenant | null>;
+    fetchAll(): Promise<ITenant[]>;
+    paginate({ page, limit, orderBy, orderDesc, search, filters }: IDraxPaginateOptions): Promise<IDraxPaginateResult<ITenant>>;
+}
+export default TenantMongoRepository;
+//# sourceMappingURL=TenantMongoRepository.d.ts.map

package/types/repository/mongo/UserApiKeyMongoRepository.d.ts

@@ -0,0 +1,14 @@
+import type { IUserApiKey, IUserApiKeyBase } from "@drax/identity-share";
+import { IDraxPaginateOptions, IDraxPaginateResult } from "@drax/common-share";
+import { IUserApiKeyRepository } from "../../interfaces/IUserApiKeyRepository";
+declare class UserMongoRepository implements IUserApiKeyRepository {
+    constructor();
+    create(data: IUserApiKeyBase): Promise<IUserApiKey>;
+    update(id: string, data: IUserApiKeyBase): Promise<IUserApiKey>;
+    delete(id: string): Promise<boolean>;
+    findById(id: string): Promise<IUserApiKey>;
+    findBySecret(secret: string): Promise<IUserApiKey>;
+    paginate({ page, limit, orderBy, orderDesc, search, filters }: IDraxPaginateOptions): Promise<IDraxPaginateResult<IUserApiKey>>;
+}
+export default UserMongoRepository;
+//# sourceMappingURL=UserApiKeyMongoRepository.d.ts.map

package/types/repository/mongo/UserMongoRepository.d.ts

@@ -0,0 +1,17 @@
+import type { IUser, IUserCreate, IUserUpdate } from "@drax/identity-share";
+import type { IUserRepository } from "../../interfaces/IUserRepository";
+import { IDraxPaginateOptions, IDraxPaginateResult } from "@drax/common-share";
+declare class UserMongoRepository implements IUserRepository {
+    private roleRepository;
+    constructor();
+    create(userData: IUserCreate): Promise<IUser>;
+    update(id: string, userData: IUserUpdate): Promise<IUser>;
+    delete(id: string): Promise<boolean>;
+    findById(id: string): Promise<IUser>;
+    findByUsername(username: string): Promise<IUser>;
+    paginate({ page, limit, orderBy, orderDesc, search, filters }: IDraxPaginateOptions): Promise<IDraxPaginateResult<IUser>>;
+    changePassword(id: string, password: string): Promise<boolean>;
+    changeAvatar(id: string, avatar: string): Promise<boolean>;
+}
+export default UserMongoRepository;
+//# sourceMappingURL=UserMongoRepository.d.ts.map

package/types/repository/sqlite/RoleSqliteRepository.d.ts

@@ -0,0 +1,22 @@
+import { IRoleRepository } from '../../interfaces/IRoleRepository';
+import { IDraxPaginateResult, IDraxPaginateOptions } from "@drax/common-share";
+import { IRole, IRoleBase } from "@drax/identity-share";
+declare class RoleSqliteRepository implements IRoleRepository {
+    private db;
+    private dataBaseFile;
+    constructor(dataBaseFile: string, verbose?: boolean);
+    table(): void;
+    normalizeData(roleData: IRoleBase): void;
+    create(roleData: IRoleBase): Promise<IRole>;
+    update(id: string, roleData: IRoleBase): Promise<IRole>;
+    paginate({ page, limit, orderBy, orderDesc, search, filters }: IDraxPaginateOptions): Promise<IDraxPaginateResult<IRole>>;
+    delete(id: string): Promise<boolean>;
+    deleteAll(): Promise<boolean>;
+    findById(id: string): Promise<IRole | null>;
+    findByName(name: string): Promise<IRole | null>;
+    fetchAll(): Promise<IRole[]>;
+    findWithoutPopulateById(id: string): Promise<IRole | null>;
+    populateRole(role: any): Promise<any>;
+}
+export default RoleSqliteRepository;
+//# sourceMappingURL=RoleSqliteRepository.d.ts.map

package/types/repository/sqlite/TenantSqliteRepository.d.ts

@@ -0,0 +1,19 @@
+import { ITenant, ITenantBase } from '@drax/identity-share';
+import { ITenantRepository } from '../../interfaces/ITenantRepository';
+import { IDraxPaginateResult, IDraxPaginateOptions } from "@drax/common-share";
+declare class TenantSqliteRepository implements ITenantRepository {
+    private db;
+    private dataBaseFile;
+    constructor(dataBaseFile: string, verbose?: boolean);
+    table(): void;
+    create(tenantData: ITenantBase): Promise<ITenant>;
+    findById(id: string): Promise<ITenant | null>;
+    findByName(name: string): Promise<ITenant | null>;
+    update(id: string, tenantData: ITenantBase): Promise<ITenant>;
+    delete(id: string): Promise<boolean>;
+    deleteAll(): Promise<boolean>;
+    fetchAll(): Promise<ITenant[]>;
+    paginate({ page, limit, orderBy, orderDesc, search, filters }: IDraxPaginateOptions): Promise<IDraxPaginateResult<ITenant>>;
+}
+export default TenantSqliteRepository;
+//# sourceMappingURL=TenantSqliteRepository.d.ts.map

package/types/repository/sqlite/UserSqliteRepository.d.ts

@@ -0,0 +1,25 @@
+import { IUser, IUserCreate, IUserUpdate } from "@drax/identity-share";
+import { IUserRepository } from "../../interfaces/IUserRepository";
+import { IDraxPaginateResult, IDraxPaginateOptions } from "@drax/common-share";
+declare class UserSqliteRepository implements IUserRepository {
+    private db;
+    private roleRepository;
+    private tenantRepository;
+    private dataBaseFile;
+    constructor(dataBaseFile: string, verbose?: boolean);
+    table(): void;
+    normalizeData(userData: IUserCreate | IUserUpdate): void;
+    create(userData: IUserCreate): Promise<IUser>;
+    update(id: string, userData: IUserUpdate): Promise<IUser>;
+    delete(id: string): Promise<boolean>;
+    deleteAll(): Promise<boolean>;
+    findById(id: string): Promise<IUser>;
+    findByUsername(username: string): Promise<IUser>;
+    paginate({ page, limit, orderBy, orderDesc, search, filters }: IDraxPaginateOptions): Promise<IDraxPaginateResult<IUser>>;
+    findRoleById(id: string): Promise<import("@drax/identity-share").IRole>;
+    findTenantById(id: string): Promise<import("@drax/identity-share").ITenant>;
+    changePassword(id: string, password: string): Promise<boolean>;
+    changeAvatar(id: string, avatar: string): Promise<boolean>;
+}
+export default UserSqliteRepository;
+//# sourceMappingURL=UserSqliteRepository.d.ts.map