@contember/engine-tenant-api 2.1.0-alpha.30 → 2.1.0-alpha.36

package/src/model/service/PasswordlessSignInManager.ts

@@ -1,7 +1,13 @@
 import { ApiKeyManager } from './apiKey'
 import { ConfigurationQuery, PersonQuery, PersonRow } from '../queries'
 import { Response, ResponseError, ResponseOk } from '../utils/Response'
-import { ActivatePasswordlessOtpErrorCode, ConfigPolicy, InitSignInPasswordlessErrorCode, InitSignInPasswordlessResult, SignInPasswordlessErrorCode } from '../../schema'
+import {
+	ActivatePasswordlessOtpErrorCode,
+	ConfigPolicy,
+	InitSignInPasswordlessErrorCode,
+	InitSignInPasswordlessResult,
+	SignInPasswordlessErrorCode,
+} from '../../schema'
 import { DatabaseContext, validateToken } from '../utils'
 import { UserMailer } from '../mailing'
 import { ActivateOtpCommand, CreatePersonTokenCommand, IncreaseOtpAttemptCommand, InvalidateTokenCommand } from '../commands'
@@ -21,7 +27,6 @@ class PasswordlessSignInManager {
 		private readonly mailer: UserMailer,
 		private readonly projectManager: ProjectManager,
 		private readonly otpAuthenticator: OtpAuthenticator,
-
 	) {}
 
 	async initSignInPasswordless({ db, permissionContext, mailVariant, mailProject, email }: {
@@ -56,10 +61,12 @@ class PasswordlessSignInManager {
 				})
 			}
 
-			const createTokenCommand = CreatePersonTokenCommand.createPasswordlessRequest(person.id, intervalToSeconds(configuration.passwordless.expiration) / 60)
+			const createTokenCommand = CreatePersonTokenCommand.createPasswordlessRequest(
+				person.id,
+				intervalToSeconds(configuration.passwordless.expiration) / 60,
+			)
 			const result = await db.commandBus.execute(createTokenCommand)
 
-
 			const url = this.formatUrl(configuration.passwordless.url ?? null, result.token, result.id, email) ?? undefined
 
 			const projects = await this.projectManager.getProjectsByIdentity(db, person.identity_id, permissionContext)
@@ -110,7 +117,6 @@ class PasswordlessSignInManager {
 		expiration?: number
 	}): Promise<PasswordlessSignInManager.SignInPasswordlessResponse> {
 		return db.transaction(async (db): Promise<PasswordlessSignInManager.SignInPasswordlessResponse> => {
-
 			const tokenResult = await db.queryHandler.fetch(PersonTokenQuery.byId(requestId, 'passwordless'))
 			const tokenValidationResult = validateToken({
 				entry: tokenResult,
@@ -187,7 +193,6 @@ class PasswordlessSignInManager {
 		otpHash: string
 	}): Promise<PasswordlessSignInManager.ActivatePasswordlessOtpResponse> {
 		return db.transaction(async (db): Promise<PasswordlessSignInManager.ActivatePasswordlessOtpResponse> => {
-
 			const tokenResult = await db.queryHandler.fetch(PersonTokenQuery.byId(requestId, 'passwordless'))
 			const tokenValidationResult = validateToken({
 				entry: tokenResult,
@@ -232,12 +237,15 @@ class PasswordlessSignInManager {
 }
 
 namespace PasswordlessSignInManager {
-	export type InitSignInPasswordlessResponse = Response<InitSignInPasswordlessResult & {
-		[AuthLogService.Key]: AuthLogService.Bag
-	}, InitSignInPasswordlessErrorCode, {
-		[AuthLogService.Key]: AuthLogService.Bag
-	}>
-
+	export type InitSignInPasswordlessResponse = Response<
+		InitSignInPasswordlessResult & {
+			[AuthLogService.Key]: AuthLogService.Bag
+		},
+		InitSignInPasswordlessErrorCode,
+		{
+			[AuthLogService.Key]: AuthLogService.Bag
+		}
+	>
 
 	interface SignInPasswordlessResult {
 		readonly person: PersonRow
@@ -248,11 +256,15 @@ namespace PasswordlessSignInManager {
 		[AuthLogService.Key]: AuthLogService.Bag
 	}>
 
-	export type ActivatePasswordlessOtpResponse = Response<{
-		[AuthLogService.Key]: AuthLogService.Bag
-	}, ActivatePasswordlessOtpErrorCode, {
-		[AuthLogService.Key]: AuthLogService.Bag
-	}>
+	export type ActivatePasswordlessOtpResponse = Response<
+		{
+			[AuthLogService.Key]: AuthLogService.Bag
+		},
+		ActivatePasswordlessOtpErrorCode,
+		{
+			[AuthLogService.Key]: AuthLogService.Bag
+		}
+	>
 }
 
 export { PasswordlessSignInManager }

package/src/model/service/PersonAccessManager.ts

@@ -6,7 +6,6 @@ import { Response, ResponseError, ResponseOk } from '../utils/Response'
 import { DisablePersonErrorCode } from '../../schema'
 
 class PersonAccessManager {
-
 	constructor(private readonly apiKeyManager: ApiKeyManager) {}
 
 	async disablePerson(dbContext: DatabaseContext, person: PersonRow): Promise<PersonDisableAccessResponse> {

package/src/model/service/PersonManager.ts

@@ -32,7 +32,6 @@ class PersonManager {
 		await dbContext.commandBus.execute(new TogglePersonPasswordlessCommand(person.id, value))
 		return new ResponseOk(null)
 	}
-
 }
 
 namespace PersonManager {

package/src/model/service/ProjectManager.ts

@@ -1,9 +1,4 @@
-import {
-	AddProjectMemberCommand,
-	CreateProjectCommand,
-	SetProjectSecretCommand,
-	UpdateProjectCommand,
-} from '../commands'
+import { AddProjectMemberCommand, CreateProjectCommand, SetProjectSecretCommand, UpdateProjectCommand } from '../commands'
 import { PermissionContext } from '../authorization'
 import { Project, ProjectInitializer, ProjectWithSecrets } from '../type'
 import { ProjectBySlugQuery, ProjectsByIdentityQuery, ProjectsQuery, ProjectUpdateTimestampQuery } from '../queries'
@@ -115,7 +110,6 @@ export class ProjectManager {
 
 export class ProjectInitError extends Error {}
 
-
 export type CreateProjectResponse = Response<CreateProjectResult, CreateProjectResponseErrorCode>
 
 export class CreateProjectResult {

package/src/model/service/ProjectMemberManager.ts

@@ -92,8 +92,12 @@ export class ProjectMemberManager {
 		return []
 	}
 
-
-	async getProjectMembers(dbContext: DatabaseContext, projectId: string, accessVerifier: AccessVerifier, input: ProjectMembersInput): Promise<GetProjectMembersResponse> {
+	async getProjectMembers(
+		dbContext: DatabaseContext,
+		projectId: string,
+		accessVerifier: AccessVerifier,
+		input: ProjectMembersInput,
+	): Promise<GetProjectMembersResponse> {
 		return dbContext.transaction(async db => {
 			const members = await db.queryHandler.fetch(new ProjectMembersQuery(projectId, input))
 			const memberships = await db.queryHandler.fetch(

package/src/model/service/RolesManager.ts

@@ -12,7 +12,12 @@ export class RolesManager {
 		return this.patchGlobalRoles(dbContext, identityId, [], roles)
 	}
 
-	private async patchGlobalRoles(dbContext: DatabaseContext, identityId: string, addRoles: readonly string[], removeRoles: readonly string[]): Promise<Response<null, GlobalRolesErrorCode>> {
+	private async patchGlobalRoles(
+		dbContext: DatabaseContext,
+		identityId: string,
+		addRoles: readonly string[],
+		removeRoles: readonly string[],
+	): Promise<Response<null, GlobalRolesErrorCode>> {
 		const rolesValidationError = this.validateRoles([...addRoles, ...removeRoles])
 		if (rolesValidationError) {
 			return rolesValidationError
@@ -24,7 +29,6 @@ export class RolesManager {
 		return new ResponseOk(null)
 	}
 
-
 	private validateRoles(roles: string[]): Response<null, GlobalRolesErrorCode> | null {
 		for (const role of roles) {
 			if (!Object.values(TenantRole).includes(role as TenantRole)) {

package/src/model/service/SecretsManager.ts

@@ -17,7 +17,7 @@ export class SecretsManager {
 		return Object.fromEntries(result.map(it => [it.key, it.value.toString()]))
 	}
 
-	private async setSecrets(dbContext: DatabaseContext, projectId: string, secrets: {key: string; value: Buffer}[]): Promise<void> {
+	private async setSecrets(dbContext: DatabaseContext, projectId: string, secrets: { key: string; value: Buffer }[]): Promise<void> {
 		if (secrets.length === 0) {
 			return
 		}

package/src/model/service/SignInManager.ts

@@ -75,7 +75,6 @@ class SignInManager {
 						personInput: personIdentifier.email,
 					}),
 				})
-
 			} else if (personIdentifier.type === 'id') {
 				return new ResponseError('UNKNOWN_PERSON_ID', `Person with id ${personIdentifier.id} not found`, {
 					[AuthLogService.Key]: new AuthLogService.Bag({

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

@@ -61,14 +61,15 @@ export class ApiKeyManager {
 	async createSessionApiKey(dbContext: DatabaseContext, identityId: string, expiration?: number): Promise<string> {
 		const config = await dbContext.queryHandler.fetch(new ConfigurationQuery())
 		const expirationResolved = expiration ?? (intervalToSeconds(config.login.defaultTokenExpiration) / 60)
-		const expirationCapped = config.login.maxTokenExpiration ? Math.min(expirationResolved, intervalToSeconds(config.login.maxTokenExpiration) / 60) : expirationResolved
+		const expirationCapped = config.login.maxTokenExpiration
+			? Math.min(expirationResolved, intervalToSeconds(config.login.maxTokenExpiration) / 60)
+			: expirationResolved
 		const command = new CreateApiKeyCommand({ type: ApiKey.Type.SESSION, identityId, expiration: expirationCapped })
 		const token = (await dbContext.commandBus.execute(command)).token
 		assert(token !== undefined)
 		return token
 	}
 
-
 	async findApiKey(dbContext: DatabaseContext, apiKeyId: string): Promise<ApiKeyRow | null> {
 		return await dbContext.queryHandler.fetch(
 			new ApiKeyByIdQuery(apiKeyId),
@@ -109,7 +110,6 @@ export class ApiKeyManager {
 			return await this.apiKeyService.createProjectPermanentApiKey(db, projectId, memberships, description, tokenHash)
 		})
 	}
-
 }
 
 export type VerifyResponse = Response<VerifyResult, VerifyErrorCode>
@@ -125,7 +125,7 @@ export class VerifyResult {
 	) {}
 }
 
-export const enum VerifyErrorCode {
+export enum VerifyErrorCode {
 	NOT_FOUND = 'not_found',
 	DISABLED = 'disabled',
 	EXPIRED = 'expired',

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

@@ -39,11 +39,10 @@ export class ApiKeyService {
 	}
 }
 
-
 export type CreateApiKeyResponse = Response<CreateApiKeyResult, never>
 
 export class CreateApiKeyResult {
-	constructor(public readonly identity: {id: string; description?: string}, public readonly apiKey: { id: string; token?: string }) {
+	constructor(public readonly identity: { id: string; description?: string }, public readonly apiKey: { id: string; token?: string }) {
 	}
 
 	toApiKeyWithToken(): ApiKeyWithToken {

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

@@ -55,7 +55,6 @@ export class IDPManager {
 		})
 	}
 
-
 	public async enableIDP(db: DatabaseContext, slug: string): Promise<EnableIDPResponse> {
 		return await db.transaction(async db => {
 			const existing = await db.queryHandler.fetch(new IdentityProviderBySlugQuery(slug))
@@ -109,10 +108,12 @@ export class IDPManager {
 				throw e
 			}
 
-			await db.commandBus.execute(new UpdateIdpCommand(existing.id, {
-				...data,
-				configuration: data.configuration ? newConfiguration : undefined,
-			}))
+			await db.commandBus.execute(
+				new UpdateIdpCommand(existing.id, {
+					...data,
+					configuration: data.configuration ? newConfiguration : undefined,
+				}),
+			)
 
 			return new ResponseOk(null)
 		})

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

@@ -1,5 +1,2 @@
 export class IDPResponseError extends Error {
-	constructor(message: string) {
-		super(message)
-	}
 }

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

@@ -1,5 +1,2 @@
 export class IDPValidationError extends Error {
-	constructor(message: string) {
-		super(message)
-	}
 }

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

@@ -10,10 +10,9 @@ export type IDPResponse = {
 } & Record<string, unknown>
 
 export interface IdentityProviderHandler<Configuration extends {}> {
-
 	initAuth: (configuration: Configuration, data: unknown) => Promise<InitIDPAuthResult>
 
-	processResponse: (configuration: Configuration, responseData: unknown) =>  Promise<IDPResponse>
+	processResponse: (configuration: Configuration, responseData: unknown) => Promise<IDPResponse>
 
 	validateConfiguration: (config: unknown) => Configuration
 

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

@@ -1,5 +1,2 @@
 export class IdentityProviderNotFoundError extends Error {
-	constructor(message: string) {
-		super(message)
-	}
 }

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

@@ -1,5 +1,2 @@
 export class InvalidIDPConfigurationError extends Error {
-	constructor(message: string) {
-		super(message)
-	}
 }

package/src/model/service/idp/providers/FacebookProvider.ts

@@ -9,8 +9,6 @@ import { handleOIDCResponse, initOIDCAuth } from './OIDCHelpers'
 import { createHmac } from 'node:crypto'
 import { IDPResponseError } from '../IDPResponseError'
 
-
-
 const FacebookConfiguration = BaseOIDCConfiguration
 type FacebookConfiguration = ReturnType<typeof FacebookConfiguration>
 
@@ -30,7 +28,6 @@ const FacebookResponsePayload = Typesafe.object({
 
 type FacebookResponseData = ReturnType<typeof FacebookResponseData>
 
-
 export class FacebookProvider implements IdentityProviderHandler<FacebookConfiguration> {
 	// based on https://www.facebook.com/.well-known/openid-configuration/
 	// facebook .well-known endpoint does have "token_endpoint" field

package/src/model/service/idp/providers/OIDCHelpers.ts

@@ -4,7 +4,10 @@ import { IDPValidationError } from '../IDPValidationError'
 import { IDPResponseError } from '../IDPResponseError'
 import { IDPResponse, InitIDPAuthResult } from '../IdentityProviderHandler'
 
-export const initOIDCAuth = async (client: Client, { redirectUrl, scope, responseMode }: { redirectUrl: string; scope?: string; responseMode?: string }): Promise<InitIDPAuthResult> => {
+export const initOIDCAuth = async (
+	client: Client,
+	{ redirectUrl, scope, responseMode }: { redirectUrl: string; scope?: string; responseMode?: string },
+): Promise<InitIDPAuthResult> => {
 	const nonce = generators.nonce()
 	const state = generators.state()
 	const url = client.authorizationUrl({
@@ -21,7 +24,12 @@ export const initOIDCAuth = async (client: Client, { redirectUrl, scope, respons
 	}
 }
 
-export const handleOIDCResponse = async (client: Client, { sessionData, redirectUrl, ...otherData }: OIDCResponseData, fetchUserInfo?: boolean, returnOIDCResult?: boolean): Promise<IDPResponse> => {
+export const handleOIDCResponse = async (
+	client: Client,
+	{ sessionData, redirectUrl, ...otherData }: OIDCResponseData,
+	fetchUserInfo?: boolean,
+	returnOIDCResult?: boolean,
+): Promise<IDPResponse> => {
 	const params = 'parameters' in otherData ? otherData.parameters : client.callbackParams(otherData.url)
 	if (params.state && !sessionData?.state) {
 		throw new IDPValidationError(`state is present in parameters, but missing in session data`)

package/src/model/service/idp/providers/OIDCProvider.ts

@@ -33,7 +33,6 @@ export class OIDCProvider implements IdentityProviderHandler<OIDCConfiguration>
 		)
 	}
 
-
 	getPublicConfiguration({ clientSecret, ...config }: OIDCConfiguration): Partial<OIDCConfiguration> {
 		return config
 	}

package/src/model/service/idp/providers/OIDCTypes.ts

@@ -49,7 +49,6 @@ export const OIDCResponseData = Typesafe.intersection(
 			nonce: Typesafe.string,
 			state: Typesafe.string,
 		}),
-
 	}),
 )
 

package/src/model/service/idp/providers/helpers.ts

@@ -1,12 +1,13 @@
 import * as Typesafe from '@contember/typesafe'
 
-export const catchTypesafe = <T extends Typesafe.Json>(type: Typesafe.Type<T>, errorConstructor: { new(message: string): Error }) => (value: unknown): T => {
-	try {
-		return type(value)
-	} catch (e) {
-		if (e instanceof Typesafe.ParseError) {
-			throw new errorConstructor(e.message)
+export const catchTypesafe =
+	<T extends Typesafe.Json>(type: Typesafe.Type<T>, errorConstructor: { new(message: string): Error }) => (value: unknown): T => {
+		try {
+			return type(value)
+		} catch (e) {
+			if (e instanceof Typesafe.ParseError) {
+				throw new errorConstructor(e.message)
+			}
+			throw e
 		}
-		throw e
 	}
-}

package/src/model/type/ApiKey.ts

@@ -1,5 +1,5 @@
 namespace ApiKey {
-	export const enum Type {
+	export enum Type {
 		SESSION = 'session',
 		PERMANENT = 'permanent',
 		ONE_OFF = 'one_off',

package/src/model/type/Config.ts

@@ -21,9 +21,11 @@ export type ConfigRow = {
 	login_max_token_expiration: IPostgresInterval | null
 }
 
-
-export type Config = Omit<{
-	[K in keyof ConfigSchema]: {
-		[K2 in keyof ConfigSchema[K]]: Exclude<ConfigSchema[K][K2], Interval>
-	}
-}, '__typename'>
+export type Config = Omit<
+	{
+		[K in keyof ConfigSchema]: {
+			[K2 in keyof ConfigSchema[K]]: Exclude<ConfigSchema[K][K2], Interval>
+		}
+	},
+	'__typename'
+>

package/src/model/type/Project.ts

@@ -8,7 +8,6 @@ export interface Project {
 	readonly config: Record<string, unknown>
 }
 
-
 export interface ProjectWithSecrets extends Project {
 	readonly secrets: Record<string, string>
 	readonly updatedAt: Date

package/src/model/utils/DatabaseContext.ts

@@ -3,7 +3,6 @@ import { Providers } from '../providers'
 import { CommandBus } from '../commands'
 import { BatchLoaderArgs, initBatchLoader, ItemLoader } from '../../utils/batchQuery'
 
-
 export class DatabaseContext<Conn extends Connection.ConnectionLike = Connection.ConnectionLike> {
 	private loaders = new Map<BatchLoaderArgs<any, any, any>, ItemLoader<any, any>>()
 

package/src/model/utils/Response.ts

@@ -17,4 +17,3 @@ export class ResponseError<const Error, Metadata extends {} | undefined = undefi
 		public readonly metadata?: Metadata,
 	) {}
 }
-