Skip to content

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

6.4 KB
Raw Blame
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,
    },
}