@contember/engine-tenant-api 2.1.0-alpha.9 → 2.1.0-beta.1

package/src/model/commands/configuration/UpdateConfigurationCommand.ts

@@ -1,6 +1,8 @@
 import { Command } from '../Command'
 import { ConfigInput } from '../../../schema'
 import { UpdateBuilder } from '@contember/database'
+import { ConfigRow } from '../../type/Config'
+import { IPostgresInterval } from 'postgres-interval'
 
 export class UpdateConfigurationCommand implements Command<void> {
 	constructor(
@@ -12,15 +14,31 @@ export class UpdateConfigurationCommand implements Command<void> {
 		const result = await UpdateBuilder.create()
 			.table('config')
 			.where({ id: 'singleton' })
-			.values({
-				passwordless_enabled: this.configuration.passwordless?.enabled,
-				passwordless_url: this.configuration.passwordless?.url,
-				passwordless_expiration_minutes: this.configuration.passwordless?.expirationMinutes,
-			})
+			.values(
+				{
+					passwordless_enabled: this.configuration.passwordless?.enabled ?? undefined,
+					passwordless_url: this.configuration.passwordless?.url,
+					passwordless_expiration: this.configuration.passwordless?.expiration ?? undefined,
+					password_min_length: this.configuration.password?.minLength ?? undefined,
+					password_require_uppercase: this.configuration.password?.requireUppercase ?? undefined,
+					password_require_lowercase: this.configuration.password?.requireLowercase ?? undefined,
+					password_require_digit: this.configuration.password?.requireDigit ?? undefined,
+					password_require_special: this.configuration.password?.requireSpecial ?? undefined,
+					password_pattern: this.configuration.password?.pattern,
+					password_check_blacklist: this.configuration.password?.checkBlacklist ?? undefined,
+					login_base_backoff: this.configuration.login?.baseBackoff ?? undefined,
+					login_max_backoff: this.configuration.login?.maxBackoff ?? undefined,
+					login_attempt_window: this.configuration.login?.attemptWindow ?? undefined,
+					login_reveal_user_exits: this.configuration.login?.revealUserExists ?? undefined,
+					login_default_token_expiration: this.configuration.login?.defaultTokenExpiration ?? undefined,
+					login_max_token_expiration: this.configuration.login?.maxTokenExpiration,
+				} satisfies {
+					[K in keyof ConfigRow]: (IPostgresInterval extends ConfigRow[K] ? string : never) | Exclude<ConfigRow[K], IPostgresInterval> | undefined
+				},
+			)
 			.execute(db)
 		if (!result) {
 			throw new Error('Configuration not found')
 		}
 	}
-
 }

package/src/model/commands/identity/PatchIdentityGlobalRoles.ts

@@ -16,11 +16,16 @@ export class PatchIdentityGlobalRoles implements Command<boolean> {
 				id: this.id,
 			})
 			.values({
-				roles: it => it.raw(`(
+				roles: it =>
+					it.raw(
+						`(
 						SELECT JSONB_AGG(DISTINCT out_role)
 						FROM JSONB_ARRAY_ELEMENTS_TEXT(roles || ?::jsonb) t(out_role)
 						WHERE NOT(out_role = ANY (?::text[]))
-					)`, JSON.stringify(this.add), this.remove),
+					)`,
+						JSON.stringify(this.add),
+						this.remove,
+					),
 			})
 			.execute(db)
 		return result > 0

package/src/model/commands/mailTemplate/AddMailTemplateCommand.ts

@@ -18,18 +18,24 @@ export class AddMailTemplateCommand implements Command<void> {
 				use_layout: this.mailTemplate.useLayout,
 				reply_to: this.mailTemplate.replyTo,
 			})
-			.onConflict(ConflictActionType.update, this.mailTemplate.projectId ? {
-				columns: ['project_id', 'mail_type', 'variant'],
-				where: it => it.isNotNull('project_id'),
-			} : {
-				columns: ['mail_type', 'variant'],
-				where: it => it.isNull('project_id'),
-			}, {
-				reply_to: expr => expr.select(['excluded', 'reply_to']),
-				subject: expr => expr.select(['excluded', 'subject']),
-				content: expr => expr.select(['excluded', 'content']),
-				use_layout: expr => expr.select(['excluded', 'use_layout']),
-			})
+			.onConflict(
+				ConflictActionType.update,
+				this.mailTemplate.projectId
+					? {
+						columns: ['project_id', 'mail_type', 'variant'],
+						where: it => it.isNotNull('project_id'),
+					}
+					: {
+						columns: ['mail_type', 'variant'],
+						where: it => it.isNull('project_id'),
+					},
+				{
+					reply_to: expr => expr.select(['excluded', 'reply_to']),
+					subject: expr => expr.select(['excluded', 'subject']),
+					content: expr => expr.select(['excluded', 'content']),
+					use_layout: expr => expr.select(['excluded', 'use_layout']),
+				},
+			)
 			.execute(db)
 	}
 }

package/src/model/commands/membership/types.ts

@@ -3,11 +3,11 @@ export type VariableUpdateInput =
 	& (
 		| {
 			set: ReadonlyArray<string>
-	  }
+		}
 		| {
 			remove: ReadonlyArray<string>
 			append: ReadonlyArray<string>
-	  }
+		}
 	)
 
 export type MembershipInput = {

package/src/model/commands/membership/variables/PatchProjectMembershipVariableValuesCommand.ts

@@ -18,15 +18,13 @@ export class PatchProjectMembershipVariableValuesCommand implements Command<stri
 						membership_id: this.membershipId,
 						variable: this.name,
 					})
-					.select(expr => expr.raw('jsonb_array_elements_text(value)'), 'value'),
-			)
+					.select(expr => expr.raw('jsonb_array_elements_text(value)'), 'value'))
 			.with('filtered', qb => qb.from('current').where(expr => expr.not(expr => expr.in('value', [...this.remove]))))
 			.with('new_list', qb =>
 				qb
 					.select(['filtered', 'value'])
 					.from('filtered')
-					.unionDistinct(qb => qb.select(expr => expr.raw('*')).from(new Literal('unnest(?::text[])', [this.append]))),
-			)
+					.unionDistinct(qb => qb.select(expr => expr.raw('*')).from(new Literal('unnest(?::text[])', [this.append]))))
 			.with('new', qb => qb.from('new_list').select(expr => expr.raw(`coalesce(jsonb_agg(value), ?::jsonb)`, '[]'), 'value'))
 			.into('project_membership_variable')
 			.from(qb => qb.from('new'))

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

@@ -7,7 +7,7 @@ export type ChangeProfileData = {
 }
 
 export class ChangeProfileCommand implements Command<void> {
-	constructor(private readonly personId: string, private readonly data: ChangeProfileData) { }
+	constructor(private readonly personId: string, private readonly data: ChangeProfileData) {}
 
 	async execute({ db }: Command.Args): Promise<void> {
 		await UpdateBuilder.create()

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

@@ -5,13 +5,15 @@ import { MaybePassword } from '../../dtos/Password'
 import { normalizeEmail } from '../../utils/email'
 
 export class CreatePersonCommand implements Command<Omit<PersonRow, 'roles'>> {
-	constructor(private readonly data: {
-		identityId: string
-		email?: string
-		name?: string
-		password: MaybePassword
-		idpOnly?: boolean
-	}) {}
+	constructor(
+		private readonly data: {
+			identityId: string
+			email?: string
+			name?: string
+			password: MaybePassword
+			idpOnly?: boolean
+		},
+	) {}
 
 	async execute({ db, providers }: Command.Args): Promise<Omit<PersonRow, 'roles'>> {
 		const id = providers.uuid()
@@ -35,8 +37,8 @@ export class CreatePersonCommand implements Command<Omit<PersonRow, 'roles'>> {
 			id,
 			email,
 			name,
-			password_hash, identity_id:
-			this.data.identityId,
+			password_hash,
+			identity_id: this.data.identityId,
 			otp_uri: null,
 			otp_activated_at: null,
 			disabled_at: null,

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

@@ -2,7 +2,7 @@ import { Command } from '../Command'
 import { UpdateBuilder } from '@contember/database'
 
 export class TogglePersonPasswordlessCommand implements Command<void> {
-	constructor(private readonly personId: string, private readonly value: boolean | null) { }
+	constructor(private readonly personId: string, private readonly value: boolean | null) {}
 
 	async execute({ db }: Command.Args): Promise<void> {
 		await UpdateBuilder.create()

package/src/model/commands/personToken/CreatePersonTokenCommand.ts

@@ -22,12 +22,14 @@ export class CreatePersonTokenCommand implements Command<CreatePersonTokenComman
 	async execute({ db, providers, bus }: Command.Args): Promise<CreatePersonTokenCommand.Result> {
 		const token = await generateToken(providers)
 		const tokenHash = computeTokenHash(token)
-		const result = await bus.execute(new SavePersonTokenCommand(
-			this.personId,
-			tokenHash,
-			this.type,
-			this.expirationMinutes,
-		))
+		const result = await bus.execute(
+			new SavePersonTokenCommand(
+				this.personId,
+				tokenHash,
+				this.type,
+				this.expirationMinutes,
+			),
+		)
 
 		return { ...result, token }
 	}

package/src/model/commands/personToken/ResetPasswordCommand.ts

@@ -22,7 +22,6 @@ export class ResetPasswordCommand implements Command<ResetPasswordCommandRespons
 		return new ResponseOk(null)
 	}
 }
-export type ResetPasswordCommandErrorCode =
-	| PersonToken.TokenValidationError
+export type ResetPasswordCommandErrorCode = PersonToken.TokenValidationError
 
 export type ResetPasswordCommandResponse = Response<null, PersonToken.TokenValidationError>

package/src/model/dtos/AuthLogBag.ts

@@ -0,0 +1,2 @@
+export namespace AuthLogData {
+}

package/src/model/dtos/Password.ts

@@ -1,6 +1,5 @@
 import { Providers } from '../providers'
 
-
 export type MaybePassword = Password | typeof NoPassword
 
 export const NoPassword = {

package/src/model/mailing/UserMailer.ts

@@ -13,11 +13,18 @@ export class UserMailer {
 	constructor(
 		private readonly mailer: Mailer,
 		private readonly templateRenderer: TemplateRenderer,
-	) { }
+	) {}
 
 	async sendNewUserInvitedMail(
 		dbContext: DatabaseContext,
-		mailArguments: { email: string; password: string | null; token: string | null; project: string; projectSlug: string; memberships: readonly Acl.Membership[]},
+		mailArguments: {
+			email: string
+			password: string | null
+			token: string | null
+			project: string
+			projectSlug: string
+			memberships: readonly Acl.Membership[]
+		},
 		customMailOptions: { projectId: string; variant: string },
 	): Promise<void> {
 		const templateId = { type: MailType.newUserInvited, ...customMailOptions }
@@ -59,7 +66,7 @@ export class UserMailer {
 
 	async sendPasswordlessEmail(
 		dbContext: DatabaseContext,
-		mailArguments: { email: string; token: string; project?: string; projectSlug?: string; url?: string },
+		mailArguments: { email: string; token: string; project?: string; projectSlug?: string; url?: string; requestId: string },
 		customMailOptions: { projectId: string | null; variant: string },
 	): Promise<void> {
 		const templateId = { type: MailType.passwordlessSignIn, ...customMailOptions }
@@ -83,9 +90,11 @@ export class UserMailer {
 			html,
 			variables,
 			template: templateId,
-			...(template.replyTo ? {
-				replyTo: template.replyTo,
-			} : {}),
+			...(template.replyTo
+				? {
+					replyTo: template.replyTo,
+				}
+				: {}),
 		})
 	}
 
@@ -93,8 +102,7 @@ export class UserMailer {
 		dbContext: DatabaseContext,
 		identifier: MailTemplateIdentifier,
 	): Promise<Pick<MailTemplateData, 'subject' | 'content' | 'replyTo'> | null> {
-		const customTemplate =
-			(await dbContext.queryHandler.fetch(new MailTemplateQuery(identifier)))
+		const customTemplate = (await dbContext.queryHandler.fetch(new MailTemplateQuery(identifier)))
 			?? (await dbContext.queryHandler.fetch(new MailTemplateQuery({ ...identifier, projectId: null })))
 
 		if (!customTemplate) {

package/src/model/queries/apiKey/ApiKeyQuery.ts

@@ -54,11 +54,14 @@ const apiKeyBaseQuery = SelectBuilder.create<null | ApiKeyRow>()
 	.select(['api_key', 'expiration'])
 	.select(['person', 'id'], 'person_id')
 	.from('api_key')
-	.join('identity', 'identity', joinClause =>
-		joinClause.compareColumns(['api_key', 'identity_id'], Operator.eq, ['identity', 'id']),
-	)
+	.join('identity', 'identity', joinClause => joinClause.compareColumns(['api_key', 'identity_id'], Operator.eq, ['identity', 'id']))
 	.leftJoin(
-		'person', 'person', on => on.compareColumns(
-			['person', 'identity_id'], Operator.eq, ['identity', 'id'],
-		),
+		'person',
+		'person',
+		on =>
+			on.compareColumns(
+				['person', 'identity_id'],
+				Operator.eq,
+				['identity', 'id'],
+			),
 	)

package/src/model/queries/authLog/NextLoginAttemptQuery.ts

@@ -0,0 +1,66 @@
+import { DatabaseQuery, DatabaseQueryable, Literal, SelectBuilder } from '@contember/database'
+
+export class NextLoginAttemptQuery extends DatabaseQuery<Date> {
+	constructor(
+		private readonly email: string,
+	) {
+		super()
+	}
+
+	async fetch({ db }: DatabaseQueryable): Promise<Date> {
+		const qb = SelectBuilder.create()
+			.with('cfg', it => it.from('config'))
+			.with('last_successful_reset', it =>
+				it
+					.select(new Literal('MAX(person_auth_log.created_at)'), 'created_at')
+					.from('person_auth_log')
+					.join('person', 'person', it => it.columnsEq(['person', 'id'], ['person_auth_log', 'person_id']))
+					.where({
+						type: 'password_reset',
+						success: true,
+						email: this.email,
+					}))
+			.with('window_start', it =>
+				it
+					.select(
+						new Literal(`
+					GREATEST(
+						COALESCE(last_successful_reset.created_at, NOW() - cfg.login_attempt_window), 
+						NOW() - cfg.login_attempt_window
+					)`),
+						'start_time',
+					)
+					.from('cfg')
+					.from('last_successful_reset'))
+			.with('failed_logins', it =>
+				it
+					.select(new Literal('COUNT(*)'), 'fails')
+					.select(new Literal('MAX(person_auth_log.created_at)'), 'last_fail')
+					.from('person_auth_log')
+					.from('window_start')
+					.where({
+						person_input_identifier: this.email,
+						type: 'login',
+						success: false,
+					})
+					.where(new Literal('person_auth_log.created_at >= window_start.start_time')))
+			.select(
+				new Literal(`
+				CASE WHEN failed_logins.fails = 0 
+				THEN NOW() 
+				ELSE LEAST(
+					failed_logins.last_fail + cfg.login_max_backoff, 
+					failed_logins.last_fail + cfg.login_base_backoff * (POWER(2, failed_logins.fails - 1))
+				) END`),
+				'next_allowed_login',
+			)
+			.from('failed_logins')
+			.from('cfg')
+
+		const result = await qb.getResult(db)
+		if (result.length === 0) {
+			return new Date()
+		}
+		return result[0].next_allowed_login
+	}
+}

package/src/model/queries/configuration/ConfigurationQuery.ts

@@ -1,10 +1,9 @@
 import { DatabaseQuery, DatabaseQueryable, Literal, SelectBuilder } from '@contember/database'
-import { Config, ConfigPolicy } from '../../../schema'
+import { Config, ConfigRow } from '../../type/Config'
 
 export class ConfigurationQuery extends DatabaseQuery<Config> {
-
 	async fetch({ db }: DatabaseQueryable): Promise<Config> {
-		const rows = await SelectBuilder.create<ConfigurationRow>()
+		const rows = await SelectBuilder.create<ConfigRow>()
 			.from('config')
 			.select(new Literal('*'))
 			.getResult(db)
@@ -17,14 +16,25 @@ export class ConfigurationQuery extends DatabaseQuery<Config> {
 			passwordless: {
 				enabled: result.passwordless_enabled,
 				url: result.passwordless_url,
-				expirationMinutes: result.passwordless_expiration_minutes,
+				expiration: result.passwordless_expiration,
+			},
+			password: {
+				minLength: result.password_min_length,
+				requireUppercase: result.password_require_uppercase,
+				requireLowercase: result.password_require_lowercase,
+				requireDigit: result.password_require_digit,
+				requireSpecial: result.password_require_special,
+				pattern: result.password_pattern,
+				checkBlacklist: result.password_check_blacklist,
+			},
+			login: {
+				baseBackoff: result.login_base_backoff,
+				maxBackoff: result.login_max_backoff,
+				attemptWindow: result.login_attempt_window,
+				revealUserExists: result.login_reveal_user_exits,
+				defaultTokenExpiration: result.login_default_token_expiration,
+				maxTokenExpiration: result.login_max_token_expiration,
 			},
 		}
 	}
 }
-
-interface ConfigurationRow {
-	passwordless_enabled: ConfigPolicy
-	passwordless_url: string | null
-	passwordless_expiration_minutes: number
-}

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

@@ -8,13 +8,14 @@ export type MailTemplateRow =
 	& MailTemplateData
 	& MailTemplateIdentifier
 
-export const createMailTemplateQuery = <T extends MailTemplateRow>() => SelectBuilder.create<T>()
-	.select(['mail_template', 'id'])
-	.select('subject')
-	.select('content')
-	.select('use_layout', 'useLayout')
-	.select('reply_to', 'replyTo')
-	.select('project_id', 'projectId')
-	.select('mail_type', 'type')
-	.select('variant')
-	.from('mail_template')
+export const createMailTemplateQuery = <T extends MailTemplateRow>() =>
+	SelectBuilder.create<T>()
+		.select(['mail_template', 'id'])
+		.select('subject')
+		.select('content')
+		.select('use_layout', 'useLayout')
+		.select('reply_to', 'replyTo')
+		.select('project_id', 'projectId')
+		.select('mail_type', 'type')
+		.select('variant')
+		.from('mail_template')

package/src/model/queries/membership/ProjectMembersQuery.ts

@@ -3,7 +3,6 @@ import { MemberType, ProjectMembersInput } from '../../../schema'
 import { ImplementationException } from '../../../exceptions'
 
 export class ProjectMembersQuery extends DatabaseQuery<ProjectMembersQueryResult> {
-
 	constructor(
 		private readonly projectId: string,
 		private readonly projectMemberInput: ProjectMembersInput,
@@ -16,12 +15,15 @@ export class ProjectMembersQuery extends DatabaseQuery<ProjectMembersQueryResult
 			.select('id')
 			.select('description')
 			.from('identity')
-			.where(it => it.exists(
-				builder => builder
-					.from('project_membership')
-					.where(expr => expr.columnsEq(['project_membership', 'identity_id'], ['identity', 'id']))
-					.where({ project_id: this.projectId }),
-			))
+			.where(it =>
+				it.exists(
+					builder =>
+						builder
+							.from('project_membership')
+							.where(expr => expr.columnsEq(['project_membership', 'identity_id'], ['identity', 'id']))
+							.where({ project_id: this.projectId }),
+				)
+			)
 			.match(qb => {
 				const identityId = this.projectMemberInput.filter?.identityId
 				return identityId ? qb.where(it => it.in(['identity', 'id'], identityId)) : qb
@@ -38,7 +40,6 @@ export class ProjectMembersQuery extends DatabaseQuery<ProjectMembersQueryResult
 					.match(qb => email ? qb.where(it => it.in('email', email)) : qb)
 					.match(qb => personId ? qb.where(it => it.in(['person', 'id'], personId)) : qb)
 
-
 				if (email || personId || memberType === 'PERSON') {
 					return qb.where(it => it.exists(personQuery))
 				}

package/src/model/queries/membership/ProjectMembershipByIdentityQuery.ts

@@ -21,20 +21,16 @@ class ProjectMembershipByIdentityQuery extends DatabaseQuery<ProjectMembershipBy
 						'id' in this.project
 							? qb.where({
 								project_id: this.project.id,
-							  })
-							: qb.match(byProjectSlug(this.project.slug)),
-					),
-			)
+							})
+							: qb.match(byProjectSlug(this.project.slug))
+					))
 			.with('variables', qb =>
 				qb
 					.select('membership_id')
 					.select(cb => cb.raw("json_agg(json_build_object('name', variable, 'values', value))"), 'variables')
 					.from('project_membership_variable')
-					.join('memberships', undefined, expr =>
-						expr.columnsEq(['project_membership_variable', 'membership_id'], ['memberships', 'id']),
-					)
-					.groupBy('membership_id'),
-			)
+					.join('memberships', undefined, expr => expr.columnsEq(['project_membership_variable', 'membership_id'], ['memberships', 'id']))
+					.groupBy('membership_id'))
 			.select('role')
 			.select(expr => expr.raw("coalesce(variables, '[]'::json)"), 'variables')
 			.select('identity_id', 'identityId')

package/src/model/queries/membership/ProjectRolesByIdentityQuery.ts

@@ -13,12 +13,11 @@ class ProjectRolesByIdentityQuery extends DatabaseQuery<ProjectRolesByIdentityQu
 			.where({
 				identity_id: this.identityId,
 			})
-		const qbWithProjectWhere =
-			'id' in this.project
-				? qb.where({
-					project_id: this.project.id,
-				  })
-				: qb.match(byProjectSlug(this.project.slug))
+		const qbWithProjectWhere = 'id' in this.project
+			? qb.where({
+				project_id: this.project.id,
+			})
+			: qb.match(byProjectSlug(this.project.slug))
 		const result = await qbWithProjectWhere.getResult(db)
 
 		return { roles: result.map(it => it.role) }

package/src/model/queries/membership/ProjectSlugSpecification.ts

@@ -1,14 +1,11 @@
 import { ConditionBuilder, SelectBuilderSpecification } from '@contember/database'
 
-export const byProjectSlug =
-	(slug: string): SelectBuilderSpecification =>
-		qb =>
-			qb
-				.where((expr: ConditionBuilder) => expr.columnsEq('project_id', ['project', 'id']))
-				.with('project', qb =>
-					qb //
-						.from('project')
-						.select('id')
-						.where({ slug: slug }),
-				)
-				.join('project', 'project', (cond: ConditionBuilder) => cond.columnsEq(['project', 'id'], 'project_id'))
+export const byProjectSlug = (slug: string): SelectBuilderSpecification => qb =>
+	qb
+		.where((expr: ConditionBuilder) => expr.columnsEq('project_id', ['project', 'id']))
+		.with('project', qb =>
+			qb //
+				.from('project')
+				.select('id')
+				.where({ slug: slug }))
+		.join('project', 'project', (cond: ConditionBuilder) => cond.columnsEq(['project', 'id'], 'project_id'))

package/src/model/queries/person/PersonQuery.ts

@@ -68,7 +68,6 @@ class PersonByEmailFallbackQuery extends DatabaseQuery<MaybePersonRow> {
 		}
 		return await handler.fetch(PersonQuery.byExactEmail(normalizedEmail))
 	}
-
 }
 
 export { PersonQuery }

package/src/model/queries/personToken/PersonTokenQuery.ts

@@ -3,7 +3,6 @@ import { PersonToken } from '../../type'
 import { computeTokenHash } from '../../utils'
 
 export class PersonTokenQuery extends DatabaseQuery<PersonToken.Row | null> {
-
 	private constructor(
 		private readonly identifierType: 'id' | 'token_hash',
 		private readonly identifier: string,

package/src/model/queries/project/ProjectSecretsQuery.ts

@@ -24,8 +24,7 @@ export class ProjectSecretsQuery extends DatabaseQuery<ProjectSecretsQueryResult
 					key: it.key,
 					...await this.providers.decrypt(it.value, it.version),
 				})
-			},
-			),
+			}),
 		)
 	}
 }

package/src/model/queries/project/ProjectsByIdentityQuery.ts

@@ -32,7 +32,7 @@ export class ProjectsByIdentityQuery extends DatabaseQuery<Project[]> {
 						.where({
 							identity_id: this.identityId,
 						}),
-				),
+				)
 			)
 
 		const qbWithIdentityPermissions = canAuthorizedEntityViewAll
@@ -43,8 +43,8 @@ export class ProjectsByIdentityQuery extends DatabaseQuery<Project[]> {
 					SelectBuilder.create().from('project_membership').select('project_id').where({
 						identity_id: this.permissionContext.identity.id,
 					}),
-				),
-			  )
+				)
+			)
 
 		return await qbWithIdentityPermissions.getResult(queryable.db)
 	}