AI Agents & MCPs & AI Workflow Automation • (~400 MCP servers for AI agents) • AI Automation / AI Agent with MCPs • AI Workflows & AI Agents • MCPs for AI Agents
TypeScript ai-agentai-agent-toolsai-agentsai-agents-frameworkmcpmcp-servermcp-toolsmcpsn8n-alternativeno-code-automationworkflowworkflow-automationworkflows
import { ActivepiecesError, apId, ErrorCode, isNil, partition, PlatformId, spreadIfDefined, spreadIfNotUndefined, tryCatch, UserId } from '@activepieces/core-utils'
import { ApEdition, AUDIT_LOG_RETENTION_MAX_DAYS, AUDIT_LOG_RETENTION_MIN_DAYS, AuthenticationResponse, OPEN_SOURCE_PLAN, Platform, PlatformPlanLimits, PlatformResponse, PlatformRole, PlatformUsage, PlatformWithoutFederatedAuth, PlatformWithoutSensitiveData, ProjectType, SsoDomainVerification, SsoDomainVerificationStatus, UpdatePlatformRequestBody, User, UserStatus } from '@activepieces/shared'
import { FastifyBaseLogger } from 'fastify'
import { nanoid } from 'nanoid'
import { EntityManager, IsNull } from 'typeorm'
import { authenticationUtils } from '../authentication/authentication-utils'
import { userIdentityRepository, userIdentityService } from '../authentication/user-identity/user-identity-service'
import { repoFactory } from '../core/db/repo-factory'
import { transaction } from '../core/db/transaction'
import { distributedLock } from '../database/redis-connections'
import { invalidateSamlClientCache } from '../ee/authentication/saml-authn/saml-client'
import { platformPlanService } from '../ee/platform/platform-plan/platform-plan.service'
import { defaultTheme } from '../flags/theme'
import { buildPaginator } from '../helper/pagination/build-paginator'
import { Order } from '../helper/pagination/paginator'
import { rejectedPromiseHandler } from '../helper/promise-handler'
import { auditLogRetentionCeiling } from '../helper/retention/audit-log-retention-ceiling'
import { system } from '../helper/system/system'
import { telemetry } from '../helper/telemetry.utils'
import { ProjectEntity } from '../project/project-entity'
import { projectRepo } from '../project/project-repo'
import { projectService } from '../project/project-service'
import { userService } from '../user/user-service'
import { authenticationAuditEvents } from './authentication-audit-events'
import { billingProvider } from './billing-provider'
import { platformSideEffects } from './platform-side-effects'
import { PlatformEntity } from './platform.entity'
export const platformRepo = repoFactory<Platform>(PlatformEntity)
const DEFAULT_PROJECT_IDS_PAGE_SIZE = 100
export const platformService = (log: FastifyBaseLogger) => ({
async listPlatformsForIdentity(params: ListPlatformsForIdentityParams): Promise<PlatformWithoutSensitiveData[]> {
const memberships = await this.listPlatformMembershipsForIdentity(params)
return memberships.map((membership) => membership.platform)
},
async listPlatformMembershipsForIdentity(params: ListPlatformsForIdentityParams): Promise<PlatformMembershipWithPlatform[]> {
const users = await userService(log).getByIdentityId({ identityId: params.identityId })
const activeUsers = users.flatMap((user) => isNil(user.platformId) || user.status === UserStatus.INACTIVE
? []
: [{ userId: user.id, platformId: user.platformId, isPrivileged: userService(log).isUserPrivileged(user) }])
const platformIdsWithProjects = new Set(await projectService(log).listPlatformIdsWhereUsersHaveProjects({ users: activeUsers }))
const memberships: PlatformMembership[] = activeUsers.map((user) => ({
platformId: user.platformId,
hasProjects: platformIdsWithProjects.has(user.platformId),
}))
const [withProjects, withoutProjects] = partition(memberships, (membership) => membership.hasProjects)
return Promise.all([...withProjects, ...withoutProjects].map(async (membership) => ({
platform: await this.getOneWithPlanOrThrow(membership.platformId),
hasProjects: membership.hasProjects,
})))
},
async create(params: AddParams): Promise<PlatformWithoutFederatedAuth> {
const {
ownerId,
name,
primaryColor,
logoIconUrl,
fullLogoUrl,
favIconUrl,
} = params
const newPlatform: NewPlatform = {
id: apId(),
ownerId,
name,
primaryColor: primaryColor ?? defaultTheme.colors.primary.default,
logoIconUrl: logoIconUrl ?? defaultTheme.logos.logoIconUrl,
fullLogoUrl: fullLogoUrl ?? defaultTheme.logos.fullLogoUrl,
favIconUrl: favIconUrl ?? defaultTheme.logos.favIconUrl,
emailAuthEnabled: true,
autoCreatePersonalProjects: true,
enforceAllowedAuthDomains: false,
allowedAuthDomains: [],
federatedAuthProviders: { saml: null },
cloudAuthEnabled: true,
pinnedPieces: [],
pieceSelectorConfig: null,
allowedEmbedOrigins: [],
googleAuthEnabled: true,
}
const savedPlatform = await platformRepo().save(newPlatform)
await userService(log).addOwnerToPlatform({
id: ownerId,
platformId: savedPlatform.id,
})
const platformPlan = await platformPlanService(log).onPlatformCreated(savedPlatform.id)
const { error: telemetryError } = await tryCatch(() => telemetry(log).identifyPlatformGroup({
platformId: savedPlatform.id,
properties: { name: savedPlatform.name, plan: platformPlan.plan ?? null, createdAt: savedPlatform.created },
}))
if (!isNil(telemetryError)) {
log.warn({ error: telemetryError, platform: { id: savedPlatform.id } }, 'Failed to identify the platform group')
}
log.info({ platform: { id: savedPlatform.id }, ownerId }, 'Platform created')
return stripFederatedAuth(savedPlatform)
},
async createPlatformWithProject({ identityId, name, invalidatePreviousTokens, isFirstPlatform, callerTokenVersion, beforeProvision }: CreatePlatformWithProjectParams): Promise<CreatePlatformWithProjectResult> {
return distributedLock(log).runExclusive({
key: `create-platform-${identityId}`,
timeoutInSeconds: 30,
fn: async () => {
const existingUsers = isFirstPlatform ? await userService(log).getByIdentityId({ identityId }) : []
const provisionedOwner = findProvisionedOwner(existingUsers)
const platformAlreadyProvisioned = !isNil(provisionedOwner)
if (platformAlreadyProvisioned) {
return resumeProvisionedPlatform({ owner: provisionedOwner, identityId, name, invalidatePreviousTokens, callerTokenVersion, log })
}
const ownerWithoutPlatform = existingUsers.find((user) => isNil(user.platformId))
const unlinkedPlatform = isNil(ownerWithoutPlatform) ? null : await platformRepo().findOneBy({ ownerId: ownerWithoutPlatform.id })
const provisioningStoppedBeforeLinkingTheOwner = !isNil(ownerWithoutPlatform) && !isNil(unlinkedPlatform)
if (provisioningStoppedBeforeLinkingTheOwner) {
await beforeProvision?.()
return linkOwnerToPlatform({ ownerId: ownerWithoutPlatform.id, platformId: unlinkedPlatform.id, identityId, name, invalidatePreviousTokens, log })
}
await beforeProvision?.()
const owner = ownerWithoutPlatform
?? await userService(log).create({
identityId,
platformRole: PlatformRole.ADMIN,
platformId: null,
})
const platform = await this.create({ ownerId: owner.id, name })
const personalProject = await projectService(log).create({
displayName: personalProjectName(name),
ownerId: owner.id,
platformId: platform.id,
type: ProjectType.PERSONAL,
})
if (invalidatePreviousTokens) {
await rotateTokenVersion(identityId)
}
await reportSignup({ identityId, user: owner, platformId: platform.id, projectId: personalProject.id, log })
const response = await authenticationUtils(log).getProjectAndToken({
userId: owner.id,
platformId: platform.id,
projectId: personalProject.id,
})
return { response, provisioned: true }
},
})
},
async getAll(): Promise<PlatformWithoutFederatedAuth[]> {
return platformRepo().find()
},
async getOldestPlatform(): Promise<PlatformWithoutFederatedAuth | null> {
return platformRepo().findOne({
where: {},
order: {
created: 'ASC',
},
})
},
async update(params: UpdateParams): Promise<PlatformWithoutFederatedAuth> {
if (params.federatedAuthProviders?.saml !== undefined) {
const plan = await platformPlanService(log).getOrCreateForPlatform(params.id)
if (!plan.ssoEnabled) {
throw new ActivepiecesError({
code: ErrorCode.FEATURE_DISABLED,
params: {
message: 'SSO is not enabled for this platform',
},
})
}
if (!isNil(params.federatedAuthProviders.saml)) {
const platform = await this.getOneOrThrow(params.id)
if (platform.ssoDomainVerification?.status !== SsoDomainVerificationStatus.VERIFIED) {
throw new ActivepiecesError({
code: ErrorCode.VALIDATION,
params: {
message: 'SSO domain must be verified before configuring SAML',
},
})
}
}
}
const platform = params.federatedAuthProviders !== undefined
? await this.getOneWithFederatedAuthOrThrow(params.id)
: await this.getOneOrThrow(params.id)
await assertAuditLogRetentionDaysAllowed({ log, platform, auditLogRetentionDays: params.auditLogRetentionDays })
if (params.autoCreatePersonalProjects === false && platform.autoCreatePersonalProjects) {
await assertPersonalProjectsCanBeTurnedOff({ platform, log })
}
const federatedAuthProviders = hasFederatedAuth(platform)
? {
...platform.federatedAuthProviders,
...(params.federatedAuthProviders ?? {}),
}
: undefined
const updatedPlatform = {
...platform,
...spreadIfDefined('federatedAuthProviders', federatedAuthProviders),
...spreadIfDefined('name', params.name),
...spreadIfDefined('primaryColor', params.primaryColor),
...spreadIfNotUndefined('themeColors', params.themeColors),
...spreadIfDefined('logoIconUrl', params.logoIconUrl),
...spreadIfDefined('fullLogoUrl', params.fullLogoUrl),
...spreadIfDefined('favIconUrl', params.favIconUrl),
...spreadIfDefined('cloudAuthEnabled', params.cloudAuthEnabled),
...spreadIfDefined('googleAuthEnabled', params.googleAuthEnabled),
...spreadIfDefined('emailAuthEnabled', params.emailAuthEnabled),
...spreadIfDefined('autoCreatePersonalProjects', params.autoCreatePersonalProjects),
...spreadIfDefined(
'enforceAllowedAuthDomains',
params.enforceAllowedAuthDomains,
),
...spreadIfDefined('allowedAuthDomains', params.allowedAuthDomains),
...spreadIfDefined('allowedEmbedOrigins', params.allowedEmbedOrigins),
...spreadIfNotUndefined('ssoDomain', params.ssoDomain),
...spreadIfNotUndefined('ssoDomainVerification', params.ssoDomainVerification),
...spreadIfDefined('pinnedPieces', params.pinnedPieces),
...spreadIfNotUndefined('pieceSelectorConfig', params.pieceSelectorConfig),
}
if (!isNil(params.plan)) {
await platformPlanService(log).update({
platformId: params.id,
...params.plan,
})
}
if (!isNil(params.federatedAuthProviders?.saml)) {
invalidateSamlClientCache(params.id)
}
log.info({ platform: { id: params.id } }, 'Platform updated')
const { saved, locked } = await transaction(async (entityManager) => {
const lockedPlatform = await lockPlatformForUpdate({ entityManager, platformId: params.id, includeFederatedAuth: true })
const signInSettingsToSave = buildSignInSettingsToSave({ lockedPlatform, params })
assertLeavesAWorkingSignInMethod({ log, before: lockedPlatform, after: signInSettingsToSave })
const savedPlatform = await platformRepo(entityManager).save({
...updatedPlatform,
...signInSettingsToSave,
auditLogRetentionDays: params.auditLogRetentionDays === undefined ? lockedPlatform.auditLogRetentionDays ?? null : params.auditLogRetentionDays,
})
return { saved: savedPlatform, locked: lockedPlatform }
})
const previousRetentionDays = locked.auditLogRetentionDays ?? null
if (params.auditLogRetentionDays !== undefined && params.auditLogRetentionDays !== previousRetentionDays) {
platformSideEffects(log).onAuditLogRetentionUpdated({
platformId: params.id,
userId: params.userId,
ip: params.ip,
previousRetentionDays,
retentionDays: params.auditLogRetentionDays,
instanceLimitDays: auditLogRetentionCeiling.get(),
})
}
const authenticationEvents = authenticationAuditEvents.build({ before: locked, after: saved })
if (authenticationEvents.length > 0) {
platformSideEffects(log).onAuthenticationSettingsChanged({
platformId: params.id,
userId: params.userId,
ip: params.ip,
events: authenticationEvents,
})
}
return stripFederatedAuth(saved)
},
async runWithPlatformSettingsLock<T>({ platformId, fn }: RunWithPlatformSettingsLockParams<T>): Promise<T> {
return distributedLock(log).runExclusive({
key: `platform-settings-${platformId}`,
timeoutInSeconds: 30,
fn,
})
},
async listDefaultProjectIds({ platformId, entityManager }: ListDefaultProjectIdsParams): Promise<string[]> {
return readDefaultProjectIdPages({ platformId, entityManager, afterCursor: null })
},
async getOneOrThrow(id: PlatformId): Promise<PlatformWithoutFederatedAuth> {
return platformRepo().findOneByOrFail({ id })
},
async getOne(id: PlatformId): Promise<PlatformWithoutFederatedAuth | null> {
return platformRepo().findOneBy({ id })
},
async getOneWithFederatedAuthOrThrow(id: PlatformId): Promise<Platform> {
return platformRepo()
.createQueryBuilder('platform')
.addSelect('platform.federatedAuthProviders')
.where({ id })
.getOneOrFail()
},
async hasSamlConfigured(id: PlatformId): Promise<boolean> {
const result = await platformRepo()
.createQueryBuilder('platform')
.select('platform."federatedAuthProviders"', 'federatedAuthProviders')
.where({ id })
.getRawOne<{ federatedAuthProviders: { saml?: unknown } | null }>()
return !isNil(result?.federatedAuthProviders?.saml)
},
async getOneWithPlan(id: PlatformId): Promise<PlatformWithoutSensitiveData | null> {
const platform = await this.getOne(id)
if (isNil(platform)) {
return null
}
const [samlConfigured, plan, usage] = await Promise.all([
this.hasSamlConfigured(id),
getPlan(log, platform),
getUsage(log, platform),
])
return {
...platform,
federatedAuthProviders: { saml: samlConfigured ? {} : null },
usage,
plan,
}
},
async getOneWithPlanOrThrow(id: PlatformId): Promise<Omit<PlatformWithoutSensitiveData, 'usage'>> {
const platform = await this.getOneOrThrow(id)
const [samlConfigured, plan] = await Promise.all([
this.hasSamlConfigured(id),
getPlan(log, platform),
])
return {
...platform,
federatedAuthProviders: { saml: samlConfigured ? {} : null },
plan,
}
},
async getOneWithPlanAndUsageOrThrow(id: PlatformId): Promise<PlatformResponse> {
const platform = await this.getOneOrThrow(id)
const [samlConfigured, usage, plan, billingEnforced, defaultProjectIds] = await Promise.all([
this.hasSamlConfigured(id),
getUsage(log, platform),
getPlan(log, platform),
getBillingEnforced(log, id),
this.listDefaultProjectIds({ platformId: id }),
])
return {
...platform,
federatedAuthProviders: { saml: samlConfigured ? {} : null },
usage,
billingEnforced,
plan,
defaultProjectIds,
}
},
})
async function readDefaultProjectIdPages({ platformId, entityManager, afterCursor }: ReadDefaultProjectIdPagesParams): Promise<string[]> {
const paginator = buildPaginator({
entity: ProjectEntity,
query: {
limit: DEFAULT_PROJECT_IDS_PAGE_SIZE,
afterCursor: afterCursor ?? undefined,
orderBy: [
{ field: 'created', order: Order.ASC },
{ field: 'id', order: Order.ASC },
],
},
})
const { data, cursor } = await paginator.paginate(
projectRepo(entityManager).createQueryBuilder('project').where({
platformId,
type: ProjectType.TEAM,
isDefault: true,
deleted: IsNull(),
}),
)
const pageIds = data.map((project) => project.id)
if (isNil(cursor.afterCursor)) {
return pageIds
}
return [...pageIds, ...await readDefaultProjectIdPages({ platformId, entityManager, afterCursor: cursor.afterCursor })]
}
async function lockPlatformForUpdate({ entityManager, platformId, includeFederatedAuth }: LockPlatformForUpdateParams): Promise<Platform> {
return platformRepo(entityManager).findOneOrFail({
where: { id: platformId },
select: {
id: true,
auditLogRetentionDays: true,
emailAuthEnabled: true,
googleAuthEnabled: true,
allowedAuthDomains: true,
enforceAllowedAuthDomains: true,
ssoDomain: true,
ssoDomainVerification: true,
federatedAuthProviders: includeFederatedAuth,
},
lock: { mode: 'pessimistic_write' },
})
}
function findProvisionedOwner(users: User[]): PlatformOwner | undefined {
return users.find((user): user is PlatformOwner => !isNil(user.platformId))
}
async function resumeProvisionedPlatform({ owner, identityId, name, invalidatePreviousTokens, callerTokenVersion, log }: ResumeProvisionedPlatformParams): Promise<CreatePlatformWithProjectResult> {
const identity = await userIdentityService(log).getOneOrFail({ id: identityId })
const earlierAttemptNeverRotated = isSameTokenVersion(identity.tokenVersion, callerTokenVersion)
const response = await finishExistingPlatform({
user: owner,
platformId: owner.platformId,
name,
invalidatePreviousTokens: invalidatePreviousTokens && earlierAttemptNeverRotated,
identityId,
log,
})
return { response, provisioned: false }
}
async function linkOwnerToPlatform({ ownerId, platformId, identityId, name, invalidatePreviousTokens, log }: LinkOwnerToPlatformParams): Promise<CreatePlatformWithProjectResult> {
await userService(log).addOwnerToPlatform({ id: ownerId, platformId })
const owner = await userService(log).getOneOrFail({ id: ownerId })
const response = await finishExistingPlatform({
user: owner,
platformId,
name,
invalidatePreviousTokens,
identityId,
log,
})
if (!isNil(response.projectId)) {
rejectedPromiseHandler(reportSignup({ identityId, user: owner, platformId, projectId: response.projectId, log }), log)
}
return { response, provisioned: true }
}
async function reportSignup({ identityId, user, platformId, projectId, log }: ReportSignupParams): Promise<void> {
await authenticationUtils(log).sendTelemetry({
identity: await userIdentityService(log).getOneOrFail({ id: identityId }),
user,
projectId,
})
rejectedPromiseHandler(telemetry(log).aliasIdentity({ identityId, userId: user.id, platformId }), log)
}
function isSameTokenVersion(current: string | undefined, caller: string | undefined): boolean {
const neitherHasBeenRotated = isNil(current) && isNil(caller)
return neitherHasBeenRotated || current === caller
}
async function rotateTokenVersion(identityId: string): Promise<void> {
await userIdentityRepository().update(identityId, {
tokenVersion: nanoid(),
})
}
function personalProjectName(platformName: string): string {
const noun = ' Platform'
if (platformName.endsWith(noun)) {
return `${platformName.slice(0, -noun.length)} Project`
}
return /['’]s$/.test(platformName) ? `${platformName} Project` : `${platformName}'s Project`
}
async function finishExistingPlatform({ user, platformId, name, invalidatePreviousTokens, identityId, log }: FinishExistingPlatformParams): Promise<AuthenticationResponse> {
const hasProjects = await projectService(log).userHasProjects({
platformId,
userId: user.id,
isPrivileged: userService(log).isUserPrivileged(user),
})
const project = hasProjects
? null
: await projectService(log).create({
displayName: personalProjectName(name),
ownerId: user.id,
platformId,
type: ProjectType.PERSONAL,
})
if (invalidatePreviousTokens) {
await rotateTokenVersion(identityId)
}
return authenticationUtils(log).getProjectAndToken({
userId: user.id,
platformId,
projectId: project?.id ?? null,
})
}
async function getUsage(log: FastifyBaseLogger, platform: PlatformWithoutFederatedAuth): Promise<PlatformUsage | undefined> {
const edition = system.getEdition()
if (edition === ApEdition.COMMUNITY) {
return undefined
}
return platformPlanService(log).getUsage(platform.id)
}
async function getBillingEnforced(log: FastifyBaseLogger, platformId: PlatformId): Promise<boolean | undefined> {
if (system.getEdition() === ApEdition.COMMUNITY) {
return undefined
}
const { data, error } = await tryCatch(() => billingProvider.get(log).isBillingEnforced(platformId))
if (!isNil(error)) {
log.warn({ error, platform: { id: platformId } }, 'Failed to resolve billing enforcement for the platform payload')
return undefined
}
return data ?? undefined
}
async function assertAuditLogRetentionDaysAllowed({ log, platform, auditLogRetentionDays }: AssertAuditLogRetentionDaysAllowedParams): Promise<void> {
if (auditLogRetentionDays === undefined) {
return
}
const plan = await getPlan(log, platform)
if (!plan.auditLogEnabled) {
throw new ActivepiecesError({
code: ErrorCode.FEATURE_DISABLED,
params: {
message: 'Audit logs are not enabled for this platform',
},
})
}
if (isNil(auditLogRetentionDays)) {
return
}
const maxDays = auditLogRetentionCeiling.get() ?? AUDIT_LOG_RETENTION_MAX_DAYS
if (auditLogRetentionDays < AUDIT_LOG_RETENTION_MIN_DAYS || auditLogRetentionDays > maxDays) {
throw new ActivepiecesError({
code: ErrorCode.VALIDATION,
params: {
message: `auditLogRetentionDays must be between ${AUDIT_LOG_RETENTION_MIN_DAYS} and ${maxDays}`,
},
})
}
}
function buildSignInSettingsToSave({ lockedPlatform, params }: BuildSignInSettingsToSaveParams): SignInSettings {
return {
emailAuthEnabled: params.emailAuthEnabled ?? lockedPlatform.emailAuthEnabled,
googleAuthEnabled: params.googleAuthEnabled ?? lockedPlatform.googleAuthEnabled,
ssoDomainVerification: params.ssoDomainVerification === undefined ? lockedPlatform.ssoDomainVerification : params.ssoDomainVerification,
federatedAuthProviders: { ...lockedPlatform.federatedAuthProviders, ...params.federatedAuthProviders },
}
}
function assertLeavesAWorkingSignInMethod({ log, before, after }: AssertLeavesAWorkingSignInMethodParams): void {
const methodsBefore = authenticationUtils(log).getSignInMethods({ platform: before })
const methodsAfter = authenticationUtils(log).getSignInMethods({ platform: after })
const hadWorkingMethod = methodsBefore.email || methodsBefore.google || methodsBefore.sso
const hasWorkingMethod = methodsAfter.email || methodsAfter.google || methodsAfter.sso
if (hadWorkingMethod && !hasWorkingMethod) {
throw new ActivepiecesError({
code: ErrorCode.VALIDATION,
params: {
message: 'This is the only way left to sign in. Turn on another sign-in method first.',
},
})
}
}
async function getPlan(log: FastifyBaseLogger, platform: PlatformWithoutFederatedAuth): Promise<PlatformPlanLimits> {
const edition = system.getEdition()
if (edition === ApEdition.COMMUNITY) {
return {
...OPEN_SOURCE_PLAN,
}
}
return platformPlanService(log).getOrCreateForPlatform(platform.id)
}
async function assertPersonalProjectsCanBeTurnedOff({ platform, log }: AssertPersonalProjectsCanBeTurnedOffParams): Promise<void> {
const plan = await getPlan(log, platform)
if (!plan.projectRolesEnabled) {
throw new ActivepiecesError({
code: ErrorCode.FEATURE_DISABLED,
params: {
message: 'Turning personal projects off is not enabled for this platform',
},
})
}
}
function stripFederatedAuth(platform: Platform): PlatformWithoutFederatedAuth {
const { federatedAuthProviders: _omitted, ...rest } = platform
return rest
}
function hasFederatedAuth(platform: Platform | PlatformWithoutFederatedAuth): platform is Platform {
return 'federatedAuthProviders' in platform
}
type AddParams = {
ownerId: UserId
name: string
primaryColor?: string
logoIconUrl?: string
fullLogoUrl?: string
favIconUrl?: string
}
type NewPlatform = Omit<Platform, 'created' | 'updated'>
type AssertAuditLogRetentionDaysAllowedParams = {
log: FastifyBaseLogger
platform: PlatformWithoutFederatedAuth
auditLogRetentionDays: number | null | undefined
}
type SignInSettings = Pick<Platform, 'emailAuthEnabled' | 'googleAuthEnabled' | 'ssoDomainVerification' | 'federatedAuthProviders'>
type BuildSignInSettingsToSaveParams = {
lockedPlatform: Platform
params: UpdateParams
}
type AssertLeavesAWorkingSignInMethodParams = {
log: FastifyBaseLogger
before: SignInSettings
after: SignInSettings
}
type LockPlatformForUpdateParams = {
entityManager: EntityManager
platformId: PlatformId
includeFederatedAuth: boolean
}
type PlatformMembership = {
platformId: PlatformId
hasProjects: boolean
}
type PlatformMembershipWithPlatform = {
platform: PlatformWithoutSensitiveData
hasProjects: boolean
}
type AssertPersonalProjectsCanBeTurnedOffParams = {
platform: PlatformWithoutFederatedAuth
log: FastifyBaseLogger
}
type RunWithPlatformSettingsLockParams<T> = {
platformId: string
fn: () => Promise<T>
}
type ListDefaultProjectIdsParams = {
platformId: PlatformId
entityManager?: EntityManager
}
type ReadDefaultProjectIdPagesParams = {
platformId: PlatformId
entityManager?: EntityManager
afterCursor: string | null
}
type UpdateParams = UpdatePlatformRequestBody & {
id: PlatformId
plan?: Partial<PlatformPlanLimits>
logoIconUrl?: string
fullLogoUrl?: string
favIconUrl?: string
ssoDomain?: string | null
ssoDomainVerification?: SsoDomainVerification | null
userId?: UserId
ip?: string
}
type CreatePlatformWithProjectResult = {
response: AuthenticationResponse
provisioned: boolean
}
type CreatePlatformWithProjectParams = {
identityId: string
name: string
invalidatePreviousTokens: boolean
isFirstPlatform: boolean
callerTokenVersion: string | undefined
beforeProvision?: () => Promise<void>
}
type PlatformOwner = User & {
platformId: PlatformId
}
type ResumeProvisionedPlatformParams = {
owner: PlatformOwner
identityId: string
name: string
invalidatePreviousTokens: boolean
callerTokenVersion: string | undefined
log: FastifyBaseLogger
}
type LinkOwnerToPlatformParams = {
ownerId: UserId
platformId: PlatformId
identityId: string
name: string
invalidatePreviousTokens: boolean
log: FastifyBaseLogger
}
type FinishExistingPlatformParams = {
user: User
platformId: PlatformId
name: string
invalidatePreviousTokens: boolean
identityId: string
log: FastifyBaseLogger
}
type ReportSignupParams = {
identityId: string
user: User
platformId: string
projectId: string
log: FastifyBaseLogger
}
type ListPlatformsForIdentityParams = {
identityId: string
}