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 { isNil } from '@activepieces/core-utils'
import { attributionUtils, CompleteSignUpRequest, PrincipalType, SignInRequest, SignUpMethod, SignUpRequest, SwitchPlatformRequest, TelemetryEventName, UserIdentityProvider } from '@activepieces/shared'
import { FastifyRequest } from 'fastify'
import { FastifyPluginAsyncZod } from 'fastify-type-provider-zod'
import { securityAccess } from '../core/security/authorization/fastify-security'
import { authnRateLimit } from '../core/security/rate-limit'
import { networkUtils } from '../helper/network-utils'
import { rejectedPromiseHandler } from '../helper/promise-handler'
import { system } from '../helper/system/system'
import { AppSystemProp } from '../helper/system/system-props'
import { telemetry } from '../helper/telemetry.utils'
import { platformUtils } from '../platform/platform.utils'
import { userService } from '../user/user-service'
import { authenticationSideEffects } from './authentication-side-effects'
import { authenticationService } from './authentication.service'
import { turnstile } from './lib/turnstile'
import { passwordlessAuthService } from './passwordless-auth.service'
export const authenticationController: FastifyPluginAsyncZod = async (
app,
) => {
app.post('/sign-up', SignUpRequestOptions, async (request) => {
const platformId = await platformUtils.getPlatformIdForRequest(request)
await turnstile.assertSolved({
token: request.body.captchaToken,
remoteIp: clientIp(request),
log: request.log,
})
const { attribution, ...signUpRequest } = request.body
const { response, signedUp } = await authenticationService(request.log).signUp({
...signUpRequest,
provider: UserIdentityProvider.EMAIL,
platformId: platformId ?? null,
})
authenticationSideEffects(request.log).onSignIn({
response,
signedUp,
method: UserIdentityProvider.EMAIL,
ip: networkUtils.clientIp(request),
})
if (signedUp && !isNil(response.platformId)) {
rejectedPromiseHandler(telemetry(request.log).identifySignUp({
userId: response.id,
platformId: response.platformId,
method: SignUpMethod.PASSWORD,
attribution,
}), request.log)
}
return response
})
app.post('/sign-in', SignInRequestOptions, async (request) => {
const predefinedPlatformId = await platformUtils.getPlatformIdForRequest(request)
const { response, signedUp } = await authenticationService(request.log).signInWithPassword({
email: request.body.email,
password: request.body.password,
predefinedPlatformId,
})
if (signedUp && !isNil(response.platformId)) {
rejectedPromiseHandler(telemetry(request.log).identifySignUp({
userId: response.id,
platformId: response.platformId,
method: SignUpMethod.PASSWORD,
attribution: request.body.attribution,
}), request.log)
}
authenticationSideEffects(request.log).onSignIn({
response,
signedUp,
method: UserIdentityProvider.EMAIL,
ip: networkUtils.clientIp(request),
})
if (!isNil(response.platformId)) {
rejectedPromiseHandler(telemetry(request.log).trackUser({
userId: response.id,
platformId: response.platformId,
event: {
name: TelemetryEventName.SIGNED_IN,
payload: {
userId: response.id,
platformId: response.platformId,
},
},
}), request.log)
}
return response
})
app.post('/complete-sign-up', CompleteSignUpRequestOptions, async (request) => {
const { response, signedUp, provider } = await passwordlessAuthService(request.log).completeSignUp({
identityId: request.principal.id,
fullName: request.body.fullName,
})
authenticationSideEffects(request.log).onSignIn({
response,
signedUp,
method: provider,
ip: networkUtils.clientIp(request),
})
if (signedUp && !isNil(response.platformId)) {
rejectedPromiseHandler(telemetry(request.log).identifySignUp({
userId: response.id,
platformId: response.platformId,
method: attributionUtils.signUpMethodFromProvider({ provider }),
attribution: request.body.attribution,
}), request.log)
rejectedPromiseHandler(telemetry(request.log).trackUser({
userId: response.id,
platformId: response.platformId,
event: {
name: TelemetryEventName.ONBOARDING_COMPLETED,
payload: {
userId: response.id,
platformId: response.platformId,
},
},
}), request.log)
}
return response
})
app.post('/switch-platform', SwitchPlatformRequestOptions, async (request) => {
const user = await userService(request.log).getOneOrFail({ id: request.principal.id })
return authenticationService(request.log).switchPlatform({
identityId: user.identityId,
platformId: request.body.platformId,
})
})
}
const SwitchPlatformRequestOptions = {
config: {
security: securityAccess.publicPlatform([PrincipalType.USER]),
rateLimit: authnRateLimit,
},
schema: {
body: SwitchPlatformRequest,
},
}
const SignUpRequestOptions = {
config: {
security: securityAccess.public(),
rateLimit: authnRateLimit,
},
schema: {
body: SignUpRequest,
},
}
const CompleteSignUpRequestOptions = {
config: {
security: securityAccess.unscoped([PrincipalType.ONBOARDING]),
rateLimit: authnRateLimit,
},
schema: {
body: CompleteSignUpRequest,
},
}
function clientIp(request: FastifyRequest): string {
return networkUtils.extractClientRealIp(request, system.get(AppSystemProp.CLIENT_REAL_IP_HEADER))
}
const SignInRequestOptions = {
config: {
security: securityAccess.public(),
rateLimit: authnRateLimit,
},
schema: {
body: SignInRequest,
},
}