@contember/engine-tenant-api 1.3.4 → 1.4.0-alpha.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contember/engine-tenant-api",
-  "version": "1.3.4",
+  "version": "1.4.0-alpha.1",
   "license": "Apache-2.0",
   "main": "dist/src/index.js",
   "typings": "dist/src/index.d.ts",
@@ -13,17 +13,17 @@
     "test": "vitest --dir ./tests/cases --no-threads"
   },
   "dependencies": {
-    "@contember/authorization": "1.3.4",
-    "@contember/config-loader": "1.3.4",
-    "@contember/database": "1.3.4",
-    "@contember/database-migrations": "1.3.4",
-    "@contember/dic": "1.3.4",
-    "@contember/graphql-utils": "1.3.4",
-    "@contember/logger": "1.3.4",
-    "@contember/schema": "1.3.4",
-    "@contember/schema-utils": "1.3.4",
-    "@contember/typesafe": "1.3.4",
-    "@graphql-tools/utils": "^8.6.13",
+    "@contember/authorization": "1.4.0-alpha.1",
+    "@contember/config-loader": "1.4.0-alpha.1",
+    "@contember/database": "1.4.0-alpha.1",
+    "@contember/database-migrations": "1.4.0-alpha.1",
+    "@contember/dic": "1.4.0-alpha.1",
+    "@contember/graphql-utils": "1.4.0-alpha.1",
+    "@contember/logger": "1.4.0-alpha.1",
+    "@contember/schema": "1.4.0-alpha.1",
+    "@contember/schema-utils": "1.4.0-alpha.1",
+    "@contember/typesafe": "1.4.0-alpha.1",
+    "@graphql-tools/utils": "^10.0.7",
     "graphql-tag": "^2.12.5",
     "jose": "^4.10",
     "mustache": "^4.0.0",
@@ -32,12 +32,12 @@
     "otpauth": "^7.0.6"
   },
   "devDependencies": {
-    "@contember/database-tester": "1.3.4",
+    "@contember/database-tester": "1.4.0-alpha.1",
     "@graphql-codegen/cli": "^2.6.2",
     "@graphql-codegen/typescript": "^2.5.1",
     "@graphql-codegen/typescript-operations": "^2.4.2",
     "@graphql-codegen/typescript-resolvers": "^2.6.6",
-    "@graphql-tools/schema": "^8.3.5",
+    "@graphql-tools/schema": "^10.0.0",
     "@types/mustache": "^4.0.0",
     "@types/node": "^18",
     "@types/nodemailer": "^6.4.0",

package/src/TenantContainer.ts

@@ -7,11 +7,12 @@ import {
 	ApiKeyService,
 	AppleProvider,
 	DatabaseContext,
-	DatabaseContextFactory,
+	EmailValidator,
 	FacebookProvider,
 	Identity,
 	IdentityFactory,
 	IDPHandlerRegistry,
+	IDPManager,
 	IDPSignInManager,
 	InviteManager,
 	MailTemplateManager,
@@ -23,6 +24,8 @@ import {
 	PasswordResetManager,
 	PermissionContextFactory,
 	PermissionsFactory,
+	PersonAccessManager,
+	PersonManager,
 	ProjectInitializer,
 	ProjectManager,
 	ProjectMemberManager,
@@ -34,12 +37,12 @@ import {
 	SignInManager,
 	SignUpManager,
 	UserMailer,
-	PersonAccessManager,
 } from './model'
 import {
 	AddIDPMutationResolver,
 	AddProjectMemberMutationResolver,
 	ChangePasswordMutationResolver,
+	ChangeProfileMutationResolver,
 	CreateApiKeyMutationResolver,
 	CreateProjectMutationResolver,
 	DisableApiKeyMutationResolver,
@@ -70,12 +73,10 @@ import * as Schema from './schema'
 import { createMailer, MailerOptions, TemplateRenderer } from './utils'
 import { IdentityFetcher } from './bridges/system/IdentityFetcher'
 import { SignInResponseFactory } from './resolvers/responseHelpers/SignInResponseFactory'
-import { IDPManager } from './model/service/idp/IDPManager'
 import { IDPQueryResolver } from './resolvers/query/IDPQueryResolver'
 import { UpdateIDPMutationResolver } from './resolvers/mutation/idp/UpdateIDPMutationResolver'
 import { TenantCredentials, TenantMigrationsRunner } from './migrations'
 import { DisablePersonMutationResolver } from './resolvers/mutation/person/DisablePersonMutationResolver'
-import { PersonManager } from './model/service/PersonManager'
 
 export interface TenantContainer {
 	projectMemberManager: ProjectMemberManager
@@ -87,12 +88,15 @@ export interface TenantContainer {
 	authorizator: Authorizator<Identity>
 	identityFetcher: IdentityFetcher
 	databaseContext: DatabaseContext
+	readDatabaseContext: DatabaseContext
 	migrationsRunner: TenantMigrationsRunner
 	connection: Connection.ConnectionType
+	readConnection: Connection.ConnectionType
 }
 
 export interface TenantContainerArgs {
 	connection: Connection.ConnectionType
+	readConnection: Connection.ConnectionType
 	dbCredentials: DatabaseConfig
 	mailOptions: MailerOptions
 	projectSchemaResolver: ProjectSchemaResolver
@@ -104,7 +108,7 @@ export interface TenantContainerArgs {
 export class TenantContainerFactory {
 	constructor(
 		private readonly providers: Omit<Providers, 'encrypt' | 'decrypt'>,
-	) {}
+	) { }
 
 	create(args: TenantContainerArgs): TenantContainer {
 		return this.createBuilder(args)
@@ -119,8 +123,10 @@ export class TenantContainerFactory {
 				'resolverContextFactory',
 				'identityFetcher',
 				'databaseContext',
+				'readDatabaseContext',
 				'migrationsRunner',
 				'connection',
+				'readConnection',
 			)
 	}
 
@@ -134,7 +140,7 @@ export class TenantContainerFactory {
 				args.projectSchemaResolver)
 			.addService('templateRenderer', () =>
 				new TemplateRenderer())
-			.addService('accessEvaluator', ({}) =>
+			.addService('accessEvaluator', ({ }) =>
 				new AccessEvaluator.PermissionEvaluator(new PermissionsFactory().create()))
 			.addService('authorizator', ({ accessEvaluator }) =>
 				new Authorizator.Default(accessEvaluator))
@@ -144,8 +150,10 @@ export class TenantContainerFactory {
 				new ApiKeyService())
 			.addService('apiKeyManager', ({ apiKeyService }) =>
 				new ApiKeyManager(apiKeyService))
-			.addService('signUpManager', () =>
-				new SignUpManager())
+			.addService('emailValidator', () =>
+				new EmailValidator())
+			.addService('signUpManager', ({ emailValidator }) =>
+				new SignUpManager(emailValidator))
 			.addService('passwordChangeManager', ({ providers }) =>
 				new PasswordChangeManager(providers))
 			.addService('projectMemberManager', () =>
@@ -162,8 +170,8 @@ export class TenantContainerFactory {
 				new ProjectManager(secretManager, args.projectInitializer, apiKeyService))
 			.addService('personAccessManager', ({ apiKeyManager }) =>
 				new PersonAccessManager(apiKeyManager))
-			.addService('personManager', () =>
-				new PersonManager())
+			.addService('personManager', ({ emailValidator }) =>
+				new PersonManager(emailValidator))
 			.addService('passwordResetManager', ({ userMailer, projectManager }) =>
 				new PasswordResetManager(userMailer, projectManager))
 			.addService('idpRegistry', () => {
@@ -200,18 +208,20 @@ export class TenantContainerFactory {
 				new SignInResponseFactory(permissionContextFactory, identityTypeResolver))
 			.addService('meQueryResolver', () =>
 				new MeQueryResolver())
-			.addService('idpQueryResolver', () =>
-				new IDPQueryResolver())
+			.addService('idpQueryResolver', ({ idpManager }) =>
+				new IDPQueryResolver(idpManager))
 			.addService('projectQueryResolver', ({ projectManager }) =>
 				new ProjectQueryResolver(projectManager))
 			.addService('projectMembersQueryResolver', ({ projectManager, projectMemberManager }) =>
 				new ProjectMembersQueryResolver(projectManager, projectMemberManager))
 			.addService('signUpMutationResolver', ({ signUpManager, apiKeyManager }) =>
 				new SignUpMutationResolver(signUpManager, apiKeyManager))
-			.addService('signInMutationResolver', ({ signInManager, signInResponseFactory  }) =>
+			.addService('signInMutationResolver', ({ signInManager, signInResponseFactory }) =>
 				new SignInMutationResolver(signInManager, signInResponseFactory))
 			.addService('signOutMutationResolver', ({ apiKeyManager }) =>
 				new SignOutMutationResolver(apiKeyManager))
+			.addService('changeProfileMutationResolver', ({ personManager }) =>
+				new ChangeProfileMutationResolver(personManager))
 			.addService('changePasswordMutationResolver', ({ passwordChangeManager }) =>
 				new ChangePasswordMutationResolver(passwordChangeManager))
 			.addService('resetPasswordMutationResolver', ({ passwordResetManager, permissionContextFactory }) =>
@@ -258,8 +268,12 @@ export class TenantContainerFactory {
 				new ResolverFactory(container).create())
 			.addService('connection', () =>
 				args.connection)
+			.addService('readConnection', () =>
+				args.readConnection)
 			.addService('databaseContext', ({ connection, providers }) =>
-				new DatabaseContextFactory(connection, providers).create())
+				new DatabaseContext(connection.createClient('tenant', { module: 'tenant' }), providers))
+			.addService('readDatabaseContext', ({ readConnection, providers }) =>
+				new DatabaseContext(readConnection.createClient('tenant', { module: 'tenant' }), providers))
 			.addService('identityFetcher', ({ databaseContext }) =>
 				new IdentityFetcher(databaseContext.client))
 			.addService('migrationsRunner', ({ providers }) =>

package/src/migrations/2023-09-01-165000-idp-return-config.ts

@@ -0,0 +1,10 @@
+import { MigrationBuilder } from '@contember/database-migrations'
+
+const sql = `
+ALTER TABLE identity_provider
+	ADD COLUMN init_returns_config BOOLEAN NOT NULL DEFAULT FALSE;
+`
+
+export default async function (builder: MigrationBuilder) {
+	builder.sql(sql)
+}

package/src/migrations/runner.ts

@@ -35,6 +35,8 @@ import _20220714145000personloginoptions from './2022-07-14-145000-person-login-
 import _20221108projectupdatenotification from './2022-11-08-project-update-notification'
 import _20230120135500personemailnormalize from './2023-01-20-135500-person-email-normalize'
 import _20230603104000persondisabled from './2023-06-03-104000-person-disabled'
+import _20230901165000idpreturnconfig from './2023-09-01-165000-idp-return-config'
+
 import snapshot from './snapshot'
 import { computeTokenHash, Providers } from '../model'
 import { Logger } from '@contember/logger'
@@ -82,6 +84,7 @@ const migrations = {
 	'2022-11-08-project-update-notification': _20221108projectupdatenotification,
 	'2023-01-20-135500-person-email-normalize': _20230120135500personemailnormalize,
 	'2023-06-03-104000-person-disabled': _20230603104000persondisabled,
+	'2023-09-01-165000-idp-return-config': _20230901165000idpreturnconfig,
 }
 
 export class TenantMigrationsRunner {

package/src/migrations/snapshot.ts

@@ -54,7 +54,8 @@ CREATE TABLE "identity_provider" (
     "configuration" "jsonb" NOT NULL,
     "disabled_at" timestamp with time zone,
     "auto_sign_up" boolean DEFAULT false NOT NULL,
-    "exclusive" boolean DEFAULT false
+    "exclusive" boolean DEFAULT false,
+    "init_returns_config" boolean DEFAULT false NOT NULL
 );
 CREATE TABLE "mail_template" (
     "id" "uuid" NOT NULL,

package/src/model/authorization/PermissionActions.ts

@@ -23,6 +23,7 @@ namespace PermissionActions {
 	export const PERSON_SIGN_UP = (roles?: readonly string[]) => Authorizator.createAction(Resources.person, 'signUp', { roles })
 	export const PERSON_SIGN_OUT = Authorizator.createAction(Resources.person, 'signOut')
 	export const PERSON_SETUP_OTP = Authorizator.createAction(Resources.person, 'setupOtp')
+	export const PERSON_CHANGE_MY_PROFILE = Authorizator.createAction(Resources.person, 'changeMyProfile')
 	export const PERSON_CHANGE_PASSWORD = Authorizator.createAction(Resources.person, 'changePassword')
 	export const PERSON_CHANGE_MY_PASSWORD = Authorizator.createAction(Resources.person, 'changeMyPassword')
 	export const PERSON_RESET_PASSWORD = Authorizator.createAction(Resources.person, 'resetPassword')

package/src/model/authorization/PermissionsFactory.ts

@@ -26,6 +26,7 @@ class PermissionsFactory {
 		permissions.allow(TenantRole.LOGIN, PermissionActions.PERSON_SIGN_IN_IDP)
 
 		permissions.allow(TenantRole.PERSON, PermissionActions.PERSON_CHANGE_MY_PASSWORD)
+		permissions.allow(TenantRole.PERSON, PermissionActions.PERSON_CHANGE_MY_PROFILE)
 		permissions.allow(TenantRole.PERSON, PermissionActions.PERSON_SIGN_OUT)
 		permissions.allow(TenantRole.PERSON, PermissionActions.PERSON_SETUP_OTP)
 

package/src/model/commands/apiKey/ApiKeyHelper.ts

@@ -4,7 +4,7 @@ import { plusMinutes } from '../../utils/time'
 
 const DEFAULT_EXPIRATION = 30
 export class ApiKeyHelper {
-	public static getExpiration(providers: Providers, type: ApiKey.Type, expiration?: number): Date | null {
+	public static getExpiration(providers: Providers, type: ApiKey.Type, expiration?: number | null): Date | null {
 		switch (type) {
 			case ApiKey.Type.PERMANENT:
 				return null

package/src/model/commands/apiKey/ProlongApiKeyCommand.ts

@@ -3,15 +3,30 @@ import { ApiKey } from '../../type'
 import { ApiKeyHelper } from './ApiKeyHelper'
 import { UpdateBuilder } from '@contember/database'
 
+const PROLONG_THROTTLE_MS = 60_000
+
 export class ProlongApiKeyCommand implements Command<void> {
-	constructor(private readonly id: string, private readonly type: ApiKey.Type, private readonly expiration?: number) {}
+	constructor(
+		private readonly id: string,
+		private readonly type: ApiKey.Type,
+		private readonly expiration: number | null,
+		private readonly currentExpiration: Date | null,
+	) {}
 
 	async execute({ db, providers }: Command.Args): Promise<void> {
 		const newExpiration = ApiKeyHelper.getExpiration(providers, this.type, this.expiration)
 		if (newExpiration === null) {
 			return
 		}
-		const qb = UpdateBuilder.create() //
+
+		if (this.currentExpiration) {
+			const prolongMs = newExpiration.getTime() - this.currentExpiration.getTime()
+			if (prolongMs > 0 && prolongMs < PROLONG_THROTTLE_MS) {
+				return
+			}
+		}
+
+		const qb = UpdateBuilder.create()
 			.table('api_key')
 			.where({ id: this.id })
 			.values({

package/src/model/commands/idp/CreateIdpCommand.ts

@@ -9,7 +9,7 @@ export class CreateIdpCommand implements Command<void> {
 	}
 
 	async execute({ db, providers }: Command.Args): Promise<void> {
-		const { configuration, options: { autoSignUp, exclusive }, slug, type } = this.data
+		const { configuration, options: { autoSignUp, exclusive, initReturnsConfig }, slug, type } = this.data
 		await InsertBuilder.create()
 			.into('identity_provider')
 			.values({
@@ -19,6 +19,7 @@ export class CreateIdpCommand implements Command<void> {
 				type,
 				auto_sign_up: autoSignUp,
 				exclusive,
+				init_returns_config: initReturnsConfig,
 			})
 			.execute(db)
 	}

package/src/model/commands/idp/UpdateIdpCommand.ts

@@ -9,14 +9,15 @@ export class UpdateIdpCommand implements Command<void> {
 	) {
 	}
 
-	async execute({ db, providers }: Command.Args): Promise<void> {
-		const { configuration, options: { autoSignUp, exclusive } = {} } = this.data
+	async execute({ db }: Command.Args): Promise<void> {
+		const { configuration, options: { autoSignUp, exclusive, initReturnsConfig } = {} } = this.data
 		await UpdateBuilder.create()
 			.table('identity_provider')
 			.values({
 				configuration,
 				auto_sign_up: autoSignUp,
 				exclusive,
+				init_returns_config: initReturnsConfig,
 			})
 			.where({
 				id: this.id,

package/src/model/commands/person/ChangeProfileCommand.ts

@@ -0,0 +1,21 @@
+import { Command } from '../Command'
+import { UpdateBuilder } from '@contember/database'
+
+export type ChangeProfileData = {
+	readonly email?: string
+	readonly name?: string | null
+}
+
+export class ChangeProfileCommand implements Command<void> {
+	constructor(private readonly personId: string, private readonly data: ChangeProfileData) { }
+
+	async execute({ db }: Command.Args): Promise<void> {
+		await UpdateBuilder.create()
+			.table('person')
+			.values(this.data)
+			.where({
+				id: this.personId,
+			})
+			.execute(db)
+	}
+}

package/src/model/queries/idp/helpers.ts

@@ -10,11 +10,12 @@ export const createBaseIdpQuery = () =>
 		.select('disabled_at', 'disabledAt')
 		.select('auto_sign_up', 'autoSignUp')
 		.select('exclusive')
+		.select('init_returns_config', 'initReturnsConfig')
 		.from('identity_provider')
 
-export const createIdpDto = ({ exclusive, autoSignUp, ...row }: IdentityProviderRow): IdentityProviderDto => {
+export const createIdpDto = ({ exclusive, autoSignUp, initReturnsConfig, ...row }: IdentityProviderRow): IdentityProviderDto => {
 	return {
 		...row,
-		options: { autoSignUp, exclusive },
+		options: { autoSignUp, exclusive, initReturnsConfig },
 	}
 }

package/src/model/queries/idp/types.ts

@@ -8,6 +8,7 @@ export type IdentityProviderRow = {
 	configuration: Record<string, unknown>
 	autoSignUp: boolean
 	exclusive: boolean
+	initReturnsConfig: boolean
 }
 
 export type IdentityProviderDto =

package/src/model/service/EmailValidator.ts

@@ -0,0 +1,26 @@
+import { DatabaseContext } from '../utils'
+import { validateEmail } from '../utils/email'
+import { ResponseError } from '../utils/Response'
+import { PersonQuery } from '../queries'
+
+export class EmailValidator {
+
+	public async validateEmail(db: DatabaseContext, email: string): Promise<ResponseError<EmailValidatorError> | null> {
+		if (!validateEmail(email.trim())) {
+			return new ResponseError('INVALID_EMAIL_FORMAT', 'E-mail address is not in a valid format')
+		}
+		if (await this.isEmailAlreadyUsed(db, email)) {
+			return new ResponseError('EMAIL_ALREADY_EXISTS', `User with email ${email} already exists`)
+		}
+		return null
+	}
+
+	private async isEmailAlreadyUsed(db: DatabaseContext, email: string): Promise<boolean> {
+		const personOrNull = await db.queryHandler.fetch(PersonQuery.byEmail(email))
+		return personOrNull !== null
+	}
+}
+
+export type EmailValidatorError =
+	| 'EMAIL_ALREADY_EXISTS'
+	| 'INVALID_EMAIL_FORMAT'

package/src/model/service/IDPSignInManager.ts

@@ -2,7 +2,7 @@ import { ApiKeyManager } from './apiKey'
 import { IdentityProviderBySlugQuery, PersonByIdPQuery, PersonQuery, PersonRow } from '../queries'
 import { IDPClaim, IDPHandlerRegistry, IDPResponseError, IDPValidationError } from './idp'
 import { Response, ResponseError, ResponseOk } from '../utils/Response'
-import { InitSignInIdpErrorCode, SignInIdpErrorCode } from '../../schema'
+import { InitSignInIdpErrorCode, InitSignInIdpResult, SignInIdpErrorCode } from '../../schema'
 import { DatabaseContext } from '../utils'
 import { CreateIdentityCommand, CreatePersonCommand, CreatePersonIdentityProviderIdentifierCommand } from '../commands'
 import { TenantRole } from '../authorization'
@@ -67,7 +67,15 @@ class IDPSignInManager {
 		const validatedConfig = providerService.validateConfiguration(provider.configuration)
 		try {
 			const initResponse = await providerService.initAuth(validatedConfig, data)
-			return new ResponseOk(initResponse)
+
+			const publicConfig = providerService.getPublicConfiguration
+				? providerService.getPublicConfiguration(validatedConfig)
+				: validatedConfig
+
+			return new ResponseOk({
+				...initResponse,
+				idpConfiguration: provider.initReturnsConfig ? publicConfig : null,
+			})
 		} catch (e) {
 			if (e instanceof IDPValidationError) {
 				return new ResponseError('IDP_VALIDATION_FAILED', e.message)
@@ -123,12 +131,7 @@ class IDPSignInManager {
 }
 
 namespace IDPSignInManager {
-	export interface InitSignInIDPResult {
-		readonly authUrl: string
-		readonly sessionData: any
-	}
-
-	export type InitSignInIDPResponse = Response<InitSignInIDPResult, InitSignInIdpErrorCode>
+	export type InitSignInIDPResponse = Response<InitSignInIdpResult, InitSignInIdpErrorCode>
 
 	interface SignInIDPResult {
 		readonly person: PersonRow

package/src/model/service/PersonManager.ts

@@ -1,7 +1,15 @@
+import { ChangeMyProfileErrorCode } from '../../schema'
+import { ChangeProfileCommand, ChangeProfileData } from '../commands/person/ChangeProfileCommand'
+import { Response, ResponseError, ResponseOk } from '../utils/Response'
 import { PersonQuery, PersonRow } from '../queries'
 import { DatabaseContext } from '../utils'
+import { EmailValidator } from './EmailValidator'
 
 class PersonManager {
+	constructor(
+		private readonly emailValidator: EmailValidator,
+	) {
+	}
 
 	async findPersonById(dbContext: DatabaseContext, personId: string): Promise<PersonRow | null> {
 		return await dbContext.queryHandler.fetch(
@@ -9,6 +17,21 @@ class PersonManager {
 		)
 	}
 
+	async changeMyProfile(dbContext: DatabaseContext, person: PersonRow, data: ChangeProfileData): Promise<PersonManager.ProfileChangeResponse> {
+		if (data.email !== undefined) {
+			const validationError = await this.emailValidator.validateEmail(dbContext, data.email)
+			if (validationError !== null) {
+				return new ResponseError(validationError.error, validationError.errorMessage)
+			}
+		}
+		await dbContext.commandBus.execute(new ChangeProfileCommand(person.id, data))
+		return new ResponseOk(null)
+	}
+
+}
+
+namespace PersonManager {
+	export type ProfileChangeResponse = Response<null, ChangeMyProfileErrorCode>
 }
 
 export { PersonManager }

package/src/model/service/SignUpManager.ts

@@ -6,7 +6,7 @@ import { getPasswordWeaknessMessage } from '../utils/password'
 import { Response, ResponseError, ResponseOk } from '../utils/Response'
 import { DatabaseContext } from '../utils'
 import { MaybePassword } from '../dtos'
-import { validateEmail } from '../utils/email'
+import { EmailValidator } from './EmailValidator'
 
 type SignUpUser = {
 	email: string
@@ -16,12 +16,15 @@ type SignUpUser = {
 }
 
 export class SignUpManager {
+	constructor(
+		private readonly emailValidator: EmailValidator,
+	) {
+	}
+
 	async signUp(dbContext: DatabaseContext, { email, password, roles = [] }: SignUpUser): Promise<SignUpResponse> {
-		if (!validateEmail(email.trim())) {
-			return new ResponseError('INVALID_EMAIL_FORMAT', 'E-mail address is not in a valid format')
-		}
-		if (await this.isEmailAlreadyUsed(dbContext, email)) {
-			return new ResponseError('EMAIL_ALREADY_EXISTS', `User with email ${email} already exists`)
+		const validationError = await this.emailValidator.validateEmail(dbContext, email)
+		if (validationError !== null) {
+			return validationError
 		}
 		const plainPassword = password.getPlain()
 		const weakPassword = plainPassword ? getPasswordWeaknessMessage(plainPassword) : null
@@ -34,11 +37,6 @@ export class SignUpManager {
 		})
 		return new ResponseOk(new SignUpResult(person))
 	}
-
-	private async isEmailAlreadyUsed(dbContext: DatabaseContext, email: string): Promise<boolean> {
-		const personOrNull = await dbContext.queryHandler.fetch(PersonQuery.byEmail(email))
-		return personOrNull !== null
-	}
 }
 
 export class SignUpResult {

package/src/model/service/apiKey/ApiKeyManager.ts

@@ -21,9 +21,10 @@ export class ApiKeyManager {
 
 	async verifyAndProlong(
 		dbContext: DatabaseContext,
+		readDbContext: DatabaseContext,
 		token: string,
 	): Promise<VerifyResponse> {
-		const apiKeyRow = await dbContext.queryHandler.fetch(new ApiKeyByTokenQuery(token))
+		const apiKeyRow = await readDbContext.queryHandler.fetch(new ApiKeyByTokenQuery(token))
 		if (apiKeyRow === null) {
 			return new ResponseError(VerifyErrorCode.NOT_FOUND, 'API key was not found')
 		}
@@ -42,7 +43,12 @@ export class ApiKeyManager {
 
 		setImmediate(async () => {
 			await dbContext.commandBus.execute(
-				new ProlongApiKeyCommand(apiKeyRow.id, apiKeyRow.type, apiKeyRow.expiration || undefined),
+				new ProlongApiKeyCommand(
+					apiKeyRow.id,
+					apiKeyRow.type,
+					apiKeyRow.expiration,
+					apiKeyRow.expires_at,
+				),
 			)
 		})
 

package/src/model/service/idp/IDPHandlerRegistry.ts

@@ -8,6 +8,10 @@ export class IDPHandlerRegistry {
 		this.providers[type] = provider
 	}
 
+	public getHandlerOrNull(type: string): IdentityProviderHandler<{}> | null {
+		return this.providers[type] ?? null
+	}
+
 	public getHandler(type: string): IdentityProviderHandler<{}> {
 		const provider = this.providers[type]
 		if (!provider) {