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, assertNotNullOrUndefined, ErrorCode, isNil } from '@activepieces/core-utils'
import { cryptoUtils } from '@activepieces/server-utils'
import { ApEdition, ApEnvironment, ApFlagId, AuthenticationResponse, OtpType, PlatformWithoutSensitiveData, User, UserIdentity, UserIdentityProvider } from '@activepieces/shared'
import { FastifyBaseLogger } from 'fastify'
import { flagService } from '../flags/flag.service'
import { rejectedPromiseHandler } from '../helper/promise-handler'
import { system } from '../helper/system/system'
import { AppSystemProp } from '../helper/system/system-props'
import { platformService } from '../platform/platform.service'
import { userService } from '../user/user-service'
import { userInvitationsService } from '../user-invitations/user-invitation.service'
import { AuthenticationResult, authenticationUtils, SignInMethods } from './authentication-utils'
import { zerobounce } from './lib/zerobounce'
import { otpService } from './otp/otp-service'
import { userIdentityService } from './user-identity/user-identity-service'
import { verifiedDomainHooks } from './verified-domain-hooks'
const PLATFORM_CONTROLLED_PROVIDERS = new Set([UserIdentityProvider.JWT, UserIdentityProvider.SAML])
export const authenticationService = (log: FastifyBaseLogger) => ({
async signUp(params: SignUpParams): Promise<AuthenticationResult> {
if (requiresSignUpAbuseCheck(params.provider)) {
const maySignUp = await zerobounce.maySignUp({ email: params.email, log })
if (!maySignUp) {
throw refusedSignUpError(params)
}
}
const platformId = params.platformId
if (!isNil(platformId)) {
await authenticationUtils(log).assertEmailAuthIsEnabled({
platformId,
provider: params.provider,
})
await authenticationUtils(log).assertDomainIsAllowed({
email: params.email,
platformId,
})
if (system.get(AppSystemProp.ALLOW_OPEN_SIGN_UP) !== 'true') {
await authenticationUtils(log).assertUserIsInvitedToPlatformOrProject({
email: params.email,
platformId,
})
}
const userIdentity = await userIdentityService(log).create({
...params,
verified: true,
})
const { user } = await userService(log).getOrCreateWithProject({
identity: userIdentity,
platformId,
})
await userInvitationsService(log).provisionUserInvitation({ email: params.email })
log.info({ email: params.email, platform: { id: platformId } }, 'User signed up to existing platform')
const response = await authenticationUtils(log).getProjectAndToken({
userId: user.id,
platformId,
projectId: null,
})
return { response, signedUp: true }
}
const hasInvitations = await userInvitationsService(log).hasAnyAcceptedInvitationsForEmail({ email: params.email })
const isFederatedProvider = params.provider === UserIdentityProvider.GOOGLE || params.provider === UserIdentityProvider.JWT || params.provider === UserIdentityProvider.SAML
const userIdentity = await userIdentityService(log).create({
...params,
verified: hasInvitations || isFederatedProvider,
})
await sendVerificationOrAutoVerify(userIdentity, log)
await flagService(log).save({ id: ApFlagId.USER_CREATED, value: true })
await authenticationUtils(log).saveNewsLetterSubscriber(userIdentity)
await userInvitationsService(log).provisionUserInvitation({ email: params.email })
const preferredPlatformId = await authenticationService(log).selectCloudSignInPlatformId({ identityId: userIdentity.id })
if (!isNil(preferredPlatformId)) {
const { user } = await userService(log).getOrCreateWithProject({
identity: userIdentity,
platformId: preferredPlatformId,
})
log.info({ email: params.email, provider: params.provider, preferredPlatformId }, 'User signed up with invitation, returning preferred platform token')
const authResponse = await authenticationUtils(log).getProjectAndToken({
userId: user.id,
platformId: preferredPlatformId,
projectId: null,
})
rejectedPromiseHandler(authenticationUtils(log).sendTelemetry({ identity: userIdentity, user, projectId: authResponse.projectId ?? '' }), log)
return { response: authResponse, signedUp: true }
}
log.info({ email: params.email, provider: params.provider }, 'User signed up without a platform to join')
return authenticationUtils(log).provisionOrOnboard({ identityId: userIdentity.id })
},
async signInWithPassword(params: SignInWithPasswordParams): Promise<AuthenticationResult> {
const identity = await userIdentityService(log).verifyIdentityPassword(params)
const platformId = isNil(params.predefinedPlatformId) ? await authenticationService(log).selectCloudSignInPlatformId({ identityId: identity.id }) : params.predefinedPlatformId
if (isNil(platformId)) { // always cloud
// A Cloud password sign-up is created unverified and only gets its
// platform here, on the first sign-in after the verification email.
// `signedUp` carries that moment out so the controller can stamp it.
log.info({ email: params.email }, 'User signed in without an active platform on cloud')
return authenticationUtils(log).provisionOrOnboard({ identityId: identity.id })
}
await authenticationUtils(log).assertEmailAuthIsEnabled({
platformId,
provider: UserIdentityProvider.EMAIL,
})
await authenticationUtils(log).assertDomainIsAllowed({
email: params.email,
platformId,
})
const user = await userService(log).getOneByIdentityAndPlatform({
identityId: identity.id,
platformId,
})
if (isNil(user)) {
throw new ActivepiecesError({
code: ErrorCode.USER_NOT_FOUND_ON_PLATFORM,
params: {
email: identity.email,
},
})
}
log.info({ email: params.email, platform: { id: platformId } }, 'User signed in with password')
const response = await authenticationUtils(log).getProjectAndToken({
userId: user.id,
platformId,
projectId: null,
})
return { response, signedUp: false }
},
async selectCloudSignInPlatformId({ identityId }: SelectCloudSignInPlatformIdParams): Promise<string | null> {
if (system.getEdition() !== ApEdition.CLOUD) {
return null
}
const memberships = await platformService(log).listPlatformMembershipsForIdentity({ identityId })
const identity = await userIdentityService(log).getOneOrFail({ id: identityId })
const lastUsed = memberships.find((membership) => membership.platform.id === identity.lastLoggedInPlatformId)
const withProjects = memberships.find((membership) => membership.hasProjects)
return (lastUsed ?? withProjects ?? memberships[0])?.platform.id ?? null
},
async federatedAuthn(params: FederatedAuthnParams): Promise<AuthenticationResult> {
const platformId = isNil(params.predefinedPlatformId) ? await selectCloudSignInPlatformIdByEmail({ email: params.email, log }) : params.predefinedPlatformId
const userIdentity = await userIdentityService(log).getIdentityByEmail(params.email)
if (isNil(platformId)) { // always cloud
if (!isNil(userIdentity)) {
return authenticationUtils(log).provisionOrOnboard({ identityId: userIdentity.id })
}
return authenticationService(log).signUp({
email: params.email,
firstName: params.firstName,
lastName: params.lastName,
newsLetter: params.newsLetter,
trackEvents: params.trackEvents,
provider: params.provider,
platformId: null,
password: await cryptoUtils.generateRandomPassword(),
imageUrl: params.imageUrl,
})
}
if (params.provider == UserIdentityProvider.SAML) {
await authenticationUtils(log).assertEmailMatchesSsoDomain({
email: params.email,
platformId,
})
}
if (isNil(userIdentity)) {
return authenticationService(log).signUp({
email: params.email,
firstName: params.firstName,
lastName: params.lastName,
newsLetter: params.newsLetter,
trackEvents: params.trackEvents,
provider: params.provider,
platformId,
password: await cryptoUtils.generateRandomPassword(),
imageUrl: params.imageUrl,
})
}
const { user, created } = await userService(log).getOrCreateWithProject({
identity: userIdentity,
platformId,
})
await userInvitationsService(log).provisionUserInvitation({ email: params.email })
const response = await authenticationUtils(log).getProjectAndToken({
userId: user.id,
platformId,
projectId: null,
})
return { response, signedUp: created }
},
async switchPlatform(params: SwitchPlatformParams): Promise<AuthenticationResponse> {
const platforms = await platformService(log).listPlatformsForIdentity({ identityId: params.identityId })
const platform = platforms.find((platform) => platform.id === params.platformId)
await assertUserCanSwitchToPlatform(platform)
assertNotNullOrUndefined(platform, 'Platform not found')
const user = await getUserForPlatform(params.identityId, platform, log)
log.info({ user: { id: user.id }, platform: { id: platform.id } }, 'User switched platform')
return authenticationUtils(log).getProjectAndToken({
userId: user.id,
platformId: platform.id,
projectId: null,
})
},
async discoverSignInMethods({ domain }: DiscoverSignInMethodsParams): Promise<SignInDiscovery> {
const domainOwnerPlatformId = await verifiedDomainHooks.get(log).findPlatformIdByDomain({ domain })
if (isNil(domainOwnerPlatformId)) {
return { domainOwned: false }
}
const domainOwnerPlatform = await platformService(log).getOneWithPlanOrThrow(domainOwnerPlatformId)
return { domainOwned: true, methods: authenticationUtils(log).getSignInMethods({ platform: domainOwnerPlatform }) }
},
})
async function assertUserCanSwitchToPlatform(platform: PlatformWithoutSensitiveData | undefined): Promise<void> {
if (isNil(platform)) {
throw new ActivepiecesError({
code: ErrorCode.AUTHORIZATION,
params: {
message: 'The user is not a member of the platform',
},
})
}
}
async function getUserForPlatform(identityId: string, platform: PlatformWithoutSensitiveData, log: FastifyBaseLogger): Promise<User> {
const user = await userService(log).getOneByIdentityAndPlatform({
identityId,
platformId: platform.id,
})
if (isNil(user)) {
throw new ActivepiecesError({
code: ErrorCode.AUTHORIZATION,
params: {
message: 'User is not member of the platform',
},
})
}
return user
}
async function sendVerificationOrAutoVerify(userIdentity: UserIdentity, log: FastifyBaseLogger): Promise<void> {
const edition = system.getEdition()
const environment = system.get(AppSystemProp.ENVIRONMENT)
switch (edition) {
case ApEdition.CLOUD:
if (environment === ApEnvironment.DEVELOPMENT) {
await userIdentityService(log).verify(userIdentity.id)
break
}
if (!userIdentity.verified) {
await otpService(log).createAndSend({
platformId: null,
email: userIdentity.email,
type: OtpType.EMAIL_VERIFICATION,
})
}
break
case ApEdition.COMMUNITY:
case ApEdition.ENTERPRISE:
await userIdentityService(log).verify(userIdentity.id)
break
}
}
async function selectCloudSignInPlatformIdByEmail({ email, log }: SelectCloudSignInPlatformIdByEmailParams): Promise<string | null> {
const identity = await userIdentityService(log).getIdentityByEmail(email)
if (isNil(identity)) {
return null
}
return authenticationService(log).selectCloudSignInPlatformId({ identityId: identity.id })
}
function requiresSignUpAbuseCheck(provider: UserIdentityProvider): boolean {
return !PLATFORM_CONTROLLED_PROVIDERS.has(provider)
}
function refusedSignUpError({ email, provider }: SignUpParams): ActivepiecesError {
const normalizedEmail = email.toLowerCase().trim()
if (provider === UserIdentityProvider.EMAIL) {
return new ActivepiecesError({
code: ErrorCode.EMAIL_IS_NOT_VERIFIED,
params: { email: normalizedEmail },
})
}
return new ActivepiecesError({
code: ErrorCode.INVALID_CREDENTIALS,
params: null,
})
}
type SelectCloudSignInPlatformIdParams = {
identityId: string
}
type SelectCloudSignInPlatformIdByEmailParams = {
email: string
log: FastifyBaseLogger
}
type FederatedAuthnParams = {
email: string
firstName: string
lastName: string
newsLetter: boolean
trackEvents: boolean
provider: UserIdentityProvider
predefinedPlatformId: string | null
imageUrl?: string
}
type SignUpParams = {
email: string
firstName: string
lastName: string
password: string
platformId: string | null
trackEvents: boolean
newsLetter: boolean
provider: UserIdentityProvider
imageUrl?: string
}
type SignInWithPasswordParams = {
email: string
password: string
predefinedPlatformId: string | null
}
type SwitchPlatformParams = {
identityId: string
platformId: string
}
type DiscoverSignInMethodsParams = {
domain: string
}
export type SignInDiscovery =
| { domainOwned: true, methods: SignInMethods }
| { domainOwned: false }