@contember/engine-tenant-api 1.3.0-alpha.8 → 1.3.0-beta.1

package/src/resolvers/membershipUtils.ts

@@ -1,23 +1,23 @@
 import { MembershipValidationError, MembershipValidationErrorType } from '../model/service/MembershipValidator'
 import { MembershipValidationError as MembershipValidationErrorSchema, MembershipValidationErrorCode } from '../schema'
 
-export enum MembershipErrorCode {
-	InvalidMembership = 'INVALID_MEMBERSHIP',
-	RoleNotFound = 'ROLE_NOT_FOUND',
-	VariableEmpty = 'VARIABLE_EMPTY',
-	VariableNotFound = 'VARIABLE_NOT_FOUND',
-}
+export type MembershipErrorCode =
+	| 'INVALID_MEMBERSHIP'
+	| 'ROLE_NOT_FOUND'
+	| 'VARIABLE_EMPTY'
+	| 'VARIABLE_NOT_FOUND'
+
 
-export interface MembershipErrorVariable<Code> {
-	code: Code
+export interface MembershipErrorVariable {
+	code: MembershipErrorCode
 	membershipValidation?: MembershipValidationErrorSchema[]
 	endUserMessage?: string
 	developerMessage: string
 }
 
-export const createMembershipValidationErrorResult = <Code>(
+export const createMembershipValidationErrorResult = (
 	result: MembershipValidationError[],
-): MembershipErrorVariable<Code>[] => {
+): MembershipErrorVariable[] => {
 	const formatDeveloperError = (it: MembershipValidationError) => {
 		switch (it.error) {
 			case MembershipValidationErrorType.ROLE_NOT_FOUND:
@@ -31,58 +31,58 @@ export const createMembershipValidationErrorResult = <Code>(
 		}
 	}
 
-	const legacyErrors = result.map((it): MembershipErrorVariable<Code> | undefined => {
+	const legacyErrors = result.map((it): MembershipErrorVariable | undefined => {
 		switch (it.error) {
 			case MembershipValidationErrorType.ROLE_NOT_FOUND:
 				return {
-					code: MembershipErrorCode.RoleNotFound as unknown as Code,
+					code: 'ROLE_NOT_FOUND',
 					endUserMessage: 'Given role not found',
 					developerMessage: formatDeveloperError(it),
 				}
 			case MembershipValidationErrorType.VARIABLE_EMPTY:
 				return {
-					code: MembershipErrorCode.VariableEmpty as unknown as Code,
+					code: 'VARIABLE_EMPTY',
 					endUserMessage: 'Required variable is empty',
 					developerMessage: formatDeveloperError(it),
 				}
 			case MembershipValidationErrorType.VARIABLE_NOT_FOUND:
 				return {
-					code: MembershipErrorCode.VariableNotFound as unknown as Code,
+					code: 'VARIABLE_NOT_FOUND',
 					endUserMessage: 'Provided variable does not exist',
 					developerMessage: formatDeveloperError(it),
 				}
 		}
-	}).filter((it): it is MembershipErrorVariable<Code> => it !== undefined)
+	}).filter((it): it is MembershipErrorVariable => it !== undefined)
 
 	return [
 		{
-			code: MembershipErrorCode.InvalidMembership as unknown as Code,
+			code: 'INVALID_MEMBERSHIP',
 			developerMessage:
 				'Provided membership is invalid: ' +
 				result.map(it => formatDeveloperError(it)).join('. ') +
 				'. You can also check membershipValidation field for structured details.',
-			membershipValidation: result.map(it => {
+			membershipValidation: result.map((it): MembershipValidationErrorSchema => {
 				switch (it.error) {
 					case MembershipValidationErrorType.ROLE_NOT_FOUND:
 						return {
-							code: MembershipValidationErrorCode.RoleNotFound,
+							code: 'ROLE_NOT_FOUND',
 							role: it.role,
 						}
 					case MembershipValidationErrorType.VARIABLE_EMPTY:
 						return {
-							code: MembershipValidationErrorCode.VariableEmpty,
+							code: 'VARIABLE_EMPTY',
 							role: it.role,
 							variable: it.variable,
 						}
 					case MembershipValidationErrorType.VARIABLE_NOT_FOUND:
 						return {
-							code: MembershipValidationErrorCode.VariableNotFound,
+							code: 'VARIABLE_NOT_FOUND',
 							role: it.role,
 							variable: it.variable,
 						}
 					case MembershipValidationErrorType.VARIABLE_INVALID:
 						return {
-							code: MembershipValidationErrorCode.VariableInvalid,
+							code: 'VARIABLE_INVALID',
 							role: it.role,
 							variable: it.variable,
 						}

package/src/resolvers/mutation/apiKey/CreateApiKeyMutationResolver.ts

@@ -31,14 +31,14 @@ export class CreateApiKeyMutationResolver implements MutationResolvers {
 			message: 'You are not allowed to create an API key for this project',
 		})
 		if (!project) {
-			return createProjectNotFoundResponse(CreateApiKeyErrorCode.ProjectNotFound, projectSlug)
+			return createProjectNotFoundResponse('PROJECT_NOT_FOUND', projectSlug)
 		}
 		if (typeof tokenHash === 'string' && !isTokenHash(tokenHash)) {
 			throw new UserInputError('Invalid format of tokenHash. Must be hex-encoded sha256.')
 		}
 		const validationResult = await this.membershipValidator.validate(project.slug, memberships)
 		if (validationResult.length > 0) {
-			const errors = createMembershipValidationErrorResult<CreateApiKeyErrorCode>(validationResult)
+			const errors = createMembershipValidationErrorResult(validationResult)
 			return {
 				ok: false,
 				errors: errors,

package/src/resolvers/mutation/apiKey/DisableApiKeyMutationResolver.ts

@@ -26,7 +26,7 @@ export class DisableApiKeyMutationResolver implements MutationResolvers {
 		const result = await this.apiKeyManager.disableApiKey(context.db, id)
 
 		if (!result) {
-			return createErrorResponse(DisableApiKeyErrorCode.KeyNotFound, 'API key not found')
+			return createErrorResponse('KEY_NOT_FOUND', 'API key not found')
 		}
 
 		return {

package/src/resolvers/mutation/identity/GlobalRolesMutationResolver.ts

@@ -0,0 +1,69 @@
+import {
+	AddGlobalIdentityRolesResponse,
+	MutationAddGlobalIdentityRolesArgs,
+	MutationRemoveGlobalIdentityRolesArgs,
+	MutationResolvers,
+	RemoveGlobalIdentityRolesResponse,
+} from '../../../schema'
+import { GraphQLResolveInfo } from 'graphql'
+import { TenantResolverContext } from '../../TenantResolverContext'
+import { PermissionActions } from '../../../model'
+import { createErrorResponse } from '../../errorUtils'
+import { RolesManager } from '../../../model'
+
+export class IdentityGlobalRolesMutationResolver implements MutationResolvers {
+	constructor(
+		private readonly rolesManager: RolesManager,
+	) {
+	}
+
+	async addGlobalIdentityRoles(
+		parent: any,
+		{ roles, identityId }: MutationAddGlobalIdentityRolesArgs,
+		context: TenantResolverContext,
+		info: GraphQLResolveInfo,
+	): Promise<AddGlobalIdentityRolesResponse> {
+		await context.requireAccess({
+			action: PermissionActions.IDENTITY_ADD_GLOBAL_ROLES(roles),
+			message: 'You are not allowed to add global roles',
+		})
+
+		const result = await this.rolesManager.addGlobalRoles(context.db, identityId, roles)
+
+		if (!result.ok) {
+			return createErrorResponse(result.error, result.errorMessage)
+		}
+
+		return {
+			ok: true,
+			result: {
+				identity: { id: identityId, projects: [] },
+			},
+		}
+	}
+
+	async removeGlobalIdentityRoles(
+		parent: any,
+		{ roles, identityId }: MutationRemoveGlobalIdentityRolesArgs,
+		context: TenantResolverContext,
+		info: GraphQLResolveInfo,
+	): Promise<RemoveGlobalIdentityRolesResponse> {
+		await context.requireAccess({
+			action: PermissionActions.IDENTITY_REMOVE_GLOBAL_ROLES(roles),
+			message: 'You are not allowed to remove global roles',
+		})
+
+		const result = await this.rolesManager.removeGlobalRoles(context.db, identityId, roles)
+
+		if (!result.ok) {
+			return createErrorResponse(result.error, result.errorMessage)
+		}
+
+		return {
+			ok: true,
+			result: {
+				identity: { id: identityId, projects: [] },
+			},
+		}
+	}
+}

package/src/resolvers/mutation/identity/index.ts

@@ -0,0 +1 @@
+export * from './GlobalRolesMutationResolver'

package/src/resolvers/mutation/index.ts

@@ -1,4 +1,5 @@
 export * from './apiKey'
+export * from './identity'
 export * from './idp'
 export * from './mailTemplates'
 export * from './person'

package/src/resolvers/mutation/mailTemplates/MailTemplateMutationResolver.ts

@@ -30,7 +30,7 @@ export class MailTemplateMutationResolver implements MutationResolvers {
 			message: 'You are not allowed to add a mail template',
 		})
 		if (projectSlug && !project) {
-			return createProjectNotFoundResponse(AddMailTemplateErrorCode.ProjectNotFound, projectSlug)
+			return createProjectNotFoundResponse('PROJECT_NOT_FOUND', projectSlug)
 		}
 
 		await this.mailTemplateManager.addMailTemplate(context.db, {
@@ -60,7 +60,7 @@ export class MailTemplateMutationResolver implements MutationResolvers {
 			message: 'You are not allowed to remove a mail template',
 		})
 		if (projectSlug && !project) {
-			return createProjectNotFoundResponse(RemoveMailTemplateErrorCode.ProjectNotFound, projectSlug)
+			return createProjectNotFoundResponse('PROJECT_NOT_FOUND', projectSlug)
 		}
 
 		const removed = await this.mailTemplateManager.removeMailTemplate(context.db, {
@@ -69,7 +69,7 @@ export class MailTemplateMutationResolver implements MutationResolvers {
 			type: this.mapMailType(type),
 		})
 		if (!removed) {
-			return createErrorResponse(RemoveMailTemplateErrorCode.TemplateNotFound, 'Mail template not found')
+			return createErrorResponse('PROJECT_NOT_FOUND', 'Mail template not found')
 		}
 
 		return {
@@ -80,9 +80,9 @@ export class MailTemplateMutationResolver implements MutationResolvers {
 
 	private mapMailType(type: SchemaMailType): MailType {
 		return {
-			[SchemaMailType.ExistingUserInvited]: MailType.existingUserInvited,
-			[SchemaMailType.NewUserInvited]: MailType.newUserInvited,
-			[SchemaMailType.ResetPasswordRequest]: MailType.passwordReset,
+			EXISTING_USER_INVITED: MailType.existingUserInvited,
+			NEW_USER_INVITED: MailType.newUserInvited,
+			RESET_PASSWORD_REQUEST: MailType.passwordReset,
 		}[type]
 	}
 }

package/src/resolvers/mutation/person/ChangePasswordMutationResolver.ts

@@ -25,7 +25,7 @@ export class ChangePasswordMutationResolver implements MutationResolvers {
 	): Promise<ChangePasswordResponse> {
 		const person = await context.db.queryHandler.fetch(PersonQuery.byId(args.personId))
 		if (!person) {
-			return createErrorResponse(ChangePasswordErrorCode.PersonNotFound, 'Person not found')
+			return createErrorResponse('PERSON_NOT_FOUND', 'Person not found')
 		}
 
 		await context.requireAccess({
@@ -50,7 +50,7 @@ export class ChangePasswordMutationResolver implements MutationResolvers {
 	): Promise<ChangeMyPasswordResponse> {
 		const person = await context.db.queryHandler.fetch(PersonQuery.byIdentity(context.identity.id))
 		if (!person) {
-			return createErrorResponse(ChangeMyPasswordErrorCode.NotAPerson, 'Only a person can change a password')
+			return createErrorResponse('NOT_A_PERSON', 'Only a person can change a password')
 		}
 		await context.requireAccess({
 			action: PermissionActions.PERSON_CHANGE_MY_PASSWORD,

package/src/resolvers/mutation/person/DisablePersonMutationResolver.ts

@@ -0,0 +1,48 @@
+import {
+	DisablePersonResponse,
+	MutationDisablePersonArgs,
+	MutationResolvers,
+} from '../../../schema'
+import { TenantResolverContext } from '../../TenantResolverContext'
+import { PermissionActions, PersonAccessManager } from '../../../model'
+import { PersonManager } from '../../../model/service/PersonManager'
+import { createErrorResponse } from '../../errorUtils'
+
+export class DisablePersonMutationResolver implements MutationResolvers {
+
+	constructor(
+		private readonly personAccessManager: PersonAccessManager,
+		private readonly personManager: PersonManager,
+	) {}
+
+	async disablePerson(
+		parent: any, args: MutationDisablePersonArgs, context: TenantResolverContext,
+	): Promise<DisablePersonResponse> {
+		const targetPerson = await this.personManager.findPersonById(context.db, args.personId)
+
+		if (targetPerson === null) {
+			return {
+				ok: false,
+				error: {
+					code: 'PERSON_NOT_FOUND',
+					developerMessage: `Person <${args.personId}> was not found`,
+				},
+			}
+		}
+
+		await context.requireAccess({
+			action: PermissionActions.PERSON_DISABLE(targetPerson.roles),
+			message: 'You are not allowed to disable person account',
+		})
+
+		const result = await this.personAccessManager.disablePerson(context.db, args.personId)
+
+		if (!result.ok) {
+			return createErrorResponse(result.error, result.errorMessage)
+		}
+
+		return {
+			ok: true,
+		}
+	}
+}

package/src/resolvers/mutation/person/InviteMutationResolver.ts

@@ -1,11 +1,4 @@
-import {
-	InviteErrorCode,
-	InviteMethod,
-	InviteResponse,
-	MutationInviteArgs,
-	MutationResolvers,
-	MutationUnmanagedInviteArgs,
-} from '../../../schema'
+import { InviteErrorCode, InviteResponse, MutationInviteArgs, MutationResolvers, MutationUnmanagedInviteArgs } from '../../../schema'
 import { TenantResolverContext } from '../../TenantResolverContext'
 import {
 	DatabaseContext,
@@ -40,7 +33,7 @@ export class InviteMutationResolver implements MutationResolvers {
 			message: 'You are not allowed to invite a person',
 		})
 		if (!project) {
-			return createProjectNotFoundResponse(InviteErrorCode.ProjectNotFound, projectSlug)
+			return createProjectNotFoundResponse('PROJECT_NOT_FOUND', projectSlug)
 		}
 		return this.doInvite(context.db, {
 			email,
@@ -48,7 +41,7 @@ export class InviteMutationResolver implements MutationResolvers {
 			memberships,
 			name: name ?? undefined,
 			emailVariant: options?.mailVariant || '',
-			method: options?.method ?? InviteMethod.CreatePassword,
+			method: options?.method ?? 'CREATE_PASSWORD',
 		})
 	}
 
@@ -64,7 +57,7 @@ export class InviteMutationResolver implements MutationResolvers {
 			message: 'You are not allowed to unmanaged person invite',
 		})
 		if (!project) {
-			return createProjectNotFoundResponse(InviteErrorCode.ProjectNotFound, projectSlug)
+			return createProjectNotFoundResponse('PROJECT_NOT_FOUND', projectSlug)
 		}
 		if (typeof options?.resetTokenHash === 'string' && !isTokenHash(options?.resetTokenHash)) {
 			throw new UserInputError('Invalid format of resetTokenHash. Must be hex-encoded sha256.')
@@ -85,7 +78,7 @@ export class InviteMutationResolver implements MutationResolvers {
 	): Promise<InviteResponse> {
 		const validationResult = await this.membershipValidator.validate(invite.project.slug, invite.memberships)
 		if (validationResult.length > 0) {
-			const errors = createMembershipValidationErrorResult<InviteErrorCode>(validationResult)
+			const errors = createMembershipValidationErrorResult(validationResult)
 			return {
 				ok: false,
 				errors: errors,

package/src/resolvers/mutation/person/OtpMutationResolver.ts

@@ -1,7 +1,5 @@
 import {
-	ConfirmOtpErrorCode,
 	ConfirmOtpResponse,
-	DisableOtpErrorCode,
 	DisableOtpResponse,
 	MutationConfirmOtpArgs,
 	MutationPrepareOtpArgs,
@@ -9,7 +7,7 @@ import {
 	PrepareOtpResponse,
 } from '../../../schema'
 import { TenantResolverContext } from '../../TenantResolverContext'
-import { DatabaseContext, OtpManager, PermissionActions, PersonQuery, PersonRow } from '../../../model'
+import { OtpManager, PermissionActions, PersonQuery, PersonRow } from '../../../model'
 import { ImplementationException } from '../../../exceptions'
 import { createErrorResponse } from '../../errorUtils'
 
@@ -32,12 +30,12 @@ export class OtpMutationResolver implements MutationResolvers {
 		const person = await this.getPersonFromContext(context)
 		if (!person.otp_uri) {
 			return createErrorResponse(
-				ConfirmOtpErrorCode.NotPrepared,
+				'NOT_PREPARED',
 				`OTP setup was not initialized. Call prepareOtp first.`,
 			)
 		}
 		if (!this.otpManager.verifyOtp(person, args.otpToken)) {
-			return createErrorResponse(ConfirmOtpErrorCode.InvalidOtpToken, 'Provided token is not correct.')
+			return createErrorResponse('INVALID_OTP_TOKEN', 'Provided token is not correct.')
 		}
 		await this.otpManager.confirmOtp(context.db, person)
 		return {
@@ -49,7 +47,7 @@ export class OtpMutationResolver implements MutationResolvers {
 	async disableOtp(parent: any, args: {}, context: TenantResolverContext): Promise<DisableOtpResponse> {
 		const person = await this.getPersonFromContext(context)
 		if (!person.otp_uri) {
-			return createErrorResponse(DisableOtpErrorCode.OtpNotActive, 'OTP is not active, you cannot disable it.')
+			return createErrorResponse('OTP_NOT_ACTIVE', 'OTP is not active, you cannot disable it.')
 		}
 		await this.otpManager.disableOtp(context.db, person)
 		return {

package/src/resolvers/mutation/person/ResetPasswordMutationResolver.ts

@@ -37,10 +37,9 @@ export class ResetPasswordMutationResolver implements MutationResolvers {
 		})
 		const person = await context.db.queryHandler.fetch(PersonQuery.byEmail(args.email))
 		if (!person) {
-			return createErrorResponse(CreatePasswordResetRequestErrorCode.PersonNotFound, 'Person was not found.')
+			return createErrorResponse('PERSON_NOT_FOUND', 'Person was not found.')
 		}
 
-
 		const permissionContext = await this.permissionContextFactory.create(context.db, {
 			id: person.identity_id,
 			roles: person.roles,
@@ -67,13 +66,6 @@ export class ResetPasswordMutationResolver implements MutationResolvers {
 		if (result.ok) {
 			return { ok: true, errors: [] }
 		}
-		const err = result.error
-		const code = {
-			[ResetPasswordErrorCode.PASSWORD_TOO_WEAK]: SchemaResetPasswordErrorCode.PasswordTooWeak,
-			[ResetPasswordCommandErrorCode.TOKEN_EXPIRED]: SchemaResetPasswordErrorCode.TokenExpired,
-			[ResetPasswordCommandErrorCode.TOKEN_NOT_FOUND]: SchemaResetPasswordErrorCode.TokenNotFound,
-			[ResetPasswordCommandErrorCode.TOKEN_USED]: SchemaResetPasswordErrorCode.TokenUsed,
-		}[err]
-		return createErrorResponse(code, result.errorMessage)
+		return createErrorResponse(result.error, result.errorMessage)
 	}
 }

package/src/resolvers/mutation/person/SignInMutationResolver.ts

@@ -34,6 +34,7 @@ export class SignInMutationResolver implements MutationResolvers {
 		if (!response.ok) {
 			return createErrorResponse(response.error, response.errorMessage)
 		}
+
 		return {
 			ok: true,
 			errors: [],

package/src/resolvers/mutation/person/SignOutMutationResolver.ts

@@ -1,6 +1,6 @@
-import { MutationResolvers, MutationSignOutArgs, SignOutErrorCode, SignOutResponse } from '../../../schema'
+import { MutationResolvers, MutationSignOutArgs, SignOutResponse } from '../../../schema'
 import { TenantResolverContext } from '../../TenantResolverContext'
-import { ApiKeyManager, DatabaseContext, PermissionActions, PersonQuery } from '../../../model'
+import { ApiKey, ApiKeyManager, PermissionActions, PersonQuery } from '../../../model'
 import { createErrorResponse } from '../../errorUtils'
 
 export class SignOutMutationResolver implements MutationResolvers {
@@ -8,8 +8,17 @@ export class SignOutMutationResolver implements MutationResolvers {
 
 	async signOut(parent: any, args: MutationSignOutArgs, context: TenantResolverContext): Promise<SignOutResponse> {
 		const person = await context.db.queryHandler.fetch(PersonQuery.byIdentity(context.identity.id))
+
 		if (!person) {
-			return createErrorResponse(SignOutErrorCode.NotAPerson, 'Only a person can sign out')
+			return createErrorResponse('NOT_A_PERSON', 'Only a person can sign out')
+		}
+
+		const personApiKeyId = await this.apiKeyManager.findApiKey(context.db, context.apiKeyId)
+
+		if (personApiKeyId?.type === ApiKey.Type.PERMANENT) {
+			return createErrorResponse(
+				'NOT_POSSIBLE_SIGN_OUT_WITH_PERMANENT_API_KEY', 'Only session API keys can be used for person sign out.',
+			)
 		}
 
 		await context.requireAccess({
@@ -22,6 +31,7 @@ export class SignOutMutationResolver implements MutationResolvers {
 		} else {
 			await this.apiKeyManager.disableApiKey(context.db, context.apiKeyId)
 		}
+
 		return { ok: true, errors: [] }
 	}
 }

package/src/resolvers/mutation/project/CreateProjectMutationResolver.ts

@@ -1,9 +1,4 @@
-import {
-	CreateProjectResponse,
-	CreateProjectResponseErrorCode,
-	MutationCreateProjectArgs,
-	MutationResolvers,
-} from '../../../schema'
+import { CreateProjectResponse, MutationCreateProjectArgs, MutationResolvers } from '../../../schema'
 import { TenantResolverContext } from '../../TenantResolverContext'
 import { isTokenHash, PermissionActions, ProjectManager, TenantRole } from '../../../model'
 import { createErrorResponse } from '../../errorUtils'
@@ -20,7 +15,7 @@ export class CreateProjectMutationResolver implements MutationResolvers {
 		const project = await this.projectManager.getProjectBySlug(context.db, projectSlug)
 
 		if (project) {
-			return createErrorResponse(CreateProjectResponseErrorCode.AlreadyExists, `Project ${projectSlug} already exists`)
+			return createErrorResponse('ALREADY_EXISTS', `Project ${projectSlug} already exists`)
 		}
 
 		await context.requireAccess({

package/src/resolvers/mutation/project/SetProjectSecretMutationResolver.ts

@@ -24,7 +24,7 @@ export class SetProjectSecretMutationResolver implements MutationResolvers {
 			message: 'You are not allowed to set project secrets',
 		})
 		if (!project) {
-			return createProjectNotFoundResponse(AddProjectMemberErrorCode.ProjectNotFound, args.projectSlug)
+			return createProjectNotFoundResponse('PROJECT_NOT_FOUND', args.projectSlug)
 		}
 		await this.secretManager.setSecret(context.db, project.id, args.key, args.value)
 		return { ok: true }

package/src/resolvers/mutation/project/UpdateProjectMutationResolver.ts

@@ -1,9 +1,4 @@
-import {
-	AddProjectMemberErrorCode,
-	MutationResolvers,
-	MutationUpdateProjectArgs,
-	UpdateProjectResponse,
-} from '../../../schema'
+import { MutationResolvers, MutationUpdateProjectArgs, UpdateProjectResponse } from '../../../schema'
 import { TenantResolverContext } from '../../TenantResolverContext'
 import { PermissionActions, ProjectManager } from '../../../model'
 import { createProjectNotFoundResponse } from '../../errorUtils'
@@ -24,7 +19,7 @@ export class UpdateProjectMutationResolver implements MutationResolvers {
 			message: 'You are not allowed to update a project',
 		})
 		if (!project) {
-			return createProjectNotFoundResponse(AddProjectMemberErrorCode.ProjectNotFound, args.projectSlug)
+			return createProjectNotFoundResponse('PROJECT_NOT_FOUND', args.projectSlug)
 		}
 		await this.projectManager.updateProject(context.db, project.id, {
 			name: args.name || undefined,

package/src/resolvers/mutation/projectMember/AddProjectMemberMutationResolver.ts

@@ -28,11 +28,11 @@ export class AddProjectMemberMutationResolver implements MutationResolvers {
 			message: 'You are not allowed to add a project member',
 		})
 		if (!project) {
-			return createProjectNotFoundResponse(AddProjectMemberErrorCode.ProjectNotFound, projectSlug)
+			return createProjectNotFoundResponse('PROJECT_NOT_FOUND', projectSlug)
 		}
 		const validationResult = await this.membershipValidator.validate(project.slug, memberships)
 		if (validationResult.length > 0) {
-			const errors = createMembershipValidationErrorResult<AddProjectMemberErrorCode>(validationResult)
+			const errors = createMembershipValidationErrorResult(validationResult)
 			return {
 				ok: false,
 				errors: errors,

package/src/resolvers/mutation/projectMember/RemoveProjectMemberMutationResolver.ts

@@ -27,7 +27,7 @@ export class RemoveProjectMemberMutationResolver implements MutationResolvers {
 			message: 'You are not allowed to remove a project member',
 		})
 		if (!project) {
-			return createProjectNotFoundResponse(RemoveProjectMemberErrorCode.ProjectNotFound, projectSlug)
+			return createProjectNotFoundResponse('PROJECT_NOT_FOUND', projectSlug)
 		}
 		const memberships = await this.projectMemberManager.getStoredProjectsMemberships(
 			context.db,

package/src/resolvers/mutation/projectMember/UpdateProjectMemberMutationResolver.ts

@@ -37,7 +37,7 @@ export class UpdateProjectMemberMutationResolver implements MutationResolvers {
 			message: 'You are not allowed to update project member variables',
 		})
 		if (!project) {
-			return createProjectNotFoundResponse(UpdateProjectMemberErrorCode.ProjectNotFound, projectSlug)
+			return createProjectNotFoundResponse('PROJECT_NOT_FOUND', projectSlug)
 		}
 		const visibleMemberships = await this.projectMemberManager.getStoredProjectsMemberships(
 			context.db,
@@ -65,7 +65,7 @@ export class UpdateProjectMemberMutationResolver implements MutationResolvers {
 			it => it.error !== MembershipValidationErrorType.VARIABLE_EMPTY,
 		)
 		if (validationResult.length > 0) {
-			const errors = createMembershipValidationErrorResult<UpdateProjectMemberErrorCode>(validationResult)
+			const errors = createMembershipValidationErrorResult(validationResult)
 			return {
 				ok: false,
 				errors: errors,

package/src/resolvers/types/ProjectTypeResolver.ts

@@ -1,4 +1,4 @@
-import { MemberType, ProjectIdentityRelation, ProjectMembersArgs, ProjectResolvers } from '../../schema'
+import { ProjectIdentityRelation, ProjectMembersArgs, ProjectResolvers } from '../../schema'
 import { TenantResolverContext } from '../TenantResolverContext'
 import { PermissionActions, Project, ProjectMemberManager, ProjectSchemaResolver } from '../../model'
 import { getRoleVariables } from '@contember/schema-utils'
@@ -21,7 +21,7 @@ export class ProjectTypeResolver implements ProjectResolvers {
 		if (!(await verifier(PermissionActions.PROJECT_VIEW_MEMBER([])))) {
 			return []
 		}
-		if (args.input?.filter?.email && args.input.filter.memberType === MemberType.ApiKey) {
+		if (args.input?.filter?.email && args.input.filter.memberType === 'API_KEY') {
 			throw new UserInputError(`Cannot use email filter for ApiKey member type.`)
 		}
 		if (args.memberType && args.input) {