@seeka-labs/cli-apps 3.7.0 → 3.8.2

package/dist/ai-context/internal/examples/v2/navitas/app/server/src/functions/seekaAppWebhook.ts

@@ -0,0 +1,158 @@
+import winston from 'winston';
+
+import { app, HttpRequest, HttpResponseInit, InvocationContext } from '@azure/functions';
+import {
+    SeekaAppInstalledWebhookPayload,
+    SeekaAppInstallSettingsUpdatedWebhookPayload, SeekaAppUninstalledWebhookPayload,
+    SeekaWebhookCallType, SeekaWebhookPayload,
+    throwOnInvalidWebhookSignature
+} from '@seeka-labs/sdk-apps-server';
+
+import { childLogger, webhookLogger } from '../lib/logging';
+import { startServices } from '../lib/services';
+import {
+    createOrUpdateInstallation, deleteInstallation, SeekaAppInstallState, tryGetInstallation
+} from '../lib/state/seeka/installations';
+
+import type { Logger } from 'winston';
+import { getSeekaBrowserPlugin } from '../lib/browser';
+app.http('seekaAppWebhook', {
+    methods: ['POST'],
+    authLevel: 'anonymous',
+    route: 'api/webhook/seeka/app',
+    handler: seekaAppWebhook
+});
+
+export async function seekaAppWebhook(req: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> {
+    const bodyStr = (await req.text()) as string;
+    const body = JSON.parse(bodyStr) as SeekaWebhookPayload;
+
+    let logger = webhookLogger(body, context);
+    logger.profile('http.seeka.webhook.app')
+    logger.verbose('Received webhook from Seeka', { body });
+
+    // Handle probe
+    if (body.type === SeekaWebhookCallType.Probe) {
+        return {
+            status: 204
+        }
+    }
+
+    // Validate webhook
+    try {
+        throwOnInvalidWebhookSignature(process.env.SEEKA_APP_SECRET as string, req.headers, bodyStr);
+        logger.debug('Webhook signature validated', { body });
+    }
+    catch {
+        logger.warn('Webhook signature invalid', { body });
+        return {
+            status: 401,
+            jsonBody: { error: "Webhook call invalid" }
+        }
+    }
+
+    if (body.isTest) {
+        // This is a test webhook call
+        return {
+            status: 204
+        }
+    }
+
+    await startServices(logger);
+
+    // Check if the webhook is for an app we have installed
+    let installation: SeekaAppInstallState | null = null;
+    if (body.type != SeekaWebhookCallType.AppInstalled) {
+        installation = await tryGetInstallation((body as SeekaAppInstalledWebhookPayload).context?.applicationInstallId as string, false, logger);
+        if (installation == null) {
+            logger.warn('Webhook call cannot be processed as the installation ID is not known by this app', { body });
+
+            return {
+                status: 422,
+                jsonBody: { error: "App not installed" }
+            }
+        }
+    }
+    logger = childLogger(null, installation, logger);
+
+    // Do something
+    try {
+        switch (body.type) {
+            case SeekaWebhookCallType.AppInstalled:
+                {
+                    await onInstallation(body as SeekaAppInstalledWebhookPayload, logger);
+                    break;
+                }
+            case SeekaWebhookCallType.AppInstallSettingsUpdated:
+                {
+                    await onInstallationSettingsUpdate(body as SeekaAppInstallSettingsUpdatedWebhookPayload, logger);
+                    break;
+                }
+            case SeekaWebhookCallType.AppUninstalled:
+                {
+                    if (!body.isTest) {
+                        const payload = body as SeekaAppUninstalledWebhookPayload;
+                        await deleteInstallation(payload.context?.applicationInstallId as string, logger)
+                    }
+                    break;
+                }
+            case SeekaWebhookCallType.BrowserSdkPlugin: {
+                const plugin = await getSeekaBrowserPlugin(installation as SeekaAppInstallState, logger);
+
+                logger.profile('http.seeka.webhook.app')
+                return {
+                    status: 200,
+                    body: JSON.stringify(plugin),
+                    headers: {
+                        'Content-Type': 'application/json'
+                    }
+                }
+            }
+        }
+    }
+    catch (err) {
+        logger.error('Failed to handle webhook', { ex: winston.exceptions.getAllInfo(err) });
+        return {
+            status: 500,
+            jsonBody: { error: "Request failed" }
+        }
+    }
+    finally {
+        logger.profile('http.seeka.webhook.app')
+        logger.verbose('Seeka webhook handled');
+    }
+
+    return {
+        status: 204
+    }
+}
+
+const onInstallation = async (payload: SeekaAppInstalledWebhookPayload, logger: Logger) => {
+    if (payload.isTest) return;
+
+    const installation = await createOrUpdateInstallation({
+        ...payload.context,
+        installationState: {
+            grantedPermissions: payload.content?.grantedPermissions || []
+        },
+        applicationInstallId: payload.context?.applicationInstallId as string,
+        organisationBrandId: payload.context?.organisationBrandId as string,
+        organisationId: payload.context?.organisationId as string,
+        installedAt: new Date().toISOString(),
+        installationSettings: payload.content?.installationSettings || {}
+    }, logger)
+}
+
+const onInstallationSettingsUpdate = async (payload: SeekaAppInstallSettingsUpdatedWebhookPayload, logger: Logger) => {
+    if (payload.isTest) return;
+
+    const existingInstallation = await tryGetInstallation(payload.context?.applicationInstallId as string, true, logger) as SeekaAppInstallState;
+    const installation = await createOrUpdateInstallation({
+        ...existingInstallation,
+        installationState: {
+            ...existingInstallation.installationState,
+            grantedPermissions: payload.content?.grantedPermissions || []
+        },
+        installationSettings: payload.content?.installationSettings || {},
+    }, logger)
+}

package/dist/ai-context/internal/examples/v2/navitas/app/server/src/functions/stateChangeQueueHandler.ts

@@ -0,0 +1,42 @@
+import winston from 'winston';
+import { handleStateChange, StateChangeQueueItem } from '../lib/state/navitas/state/state-change';
+
+import { app, InvocationContext } from '@azure/functions';
+
+import { deserialiseQueuePayload, queueNames, sendQueueMessageToPoisonQueue } from '../lib/jobs';
+import { backgroundJobLogger } from '../lib/logging';
+import { startServices } from '../lib/services';
+import { tryGetInstallation } from '../lib/state/seeka/installations';
+
+app.storageQueue('stateChangeQueueHandler', {
+    queueName: queueNames.handleStateChange,
+    connection: 'AzureWebJobsStorage',
+    handler: stateChangeQueueHandler
+});
+
+export async function stateChangeQueueHandler(queueItem: unknown, context: InvocationContext): Promise<void> {
+    const body = typeof queueItem === 'string' ? deserialiseQueuePayload<StateChangeQueueItem>(queueItem) : queueItem as StateChangeQueueItem;
+    const logger = backgroundJobLogger(queueNames.handleStateChange, body, context);
+    logger.profile(`queue.${queueNames.handleStateChange}`)
+
+    await startServices(logger);
+
+    const installation = await tryGetInstallation(body.applicationInstallId as string, true, logger);
+
+    logger.verbose('Received request to handle state change item', { body });
+
+    try {
+        await handleStateChange(body, installation, logger)
+    }
+    catch (err) {
+        logger.error('Error handling state change item', { ex: winston.exceptions.getAllInfo(err) })
+
+        await sendQueueMessageToPoisonQueue(queueNames.handleStateChange, {
+            payload: body.payload,
+            causationId: body.causationId,
+            correlationId: context.invocationId,
+        } as StateChangeQueueItem, logger);
+    }
+
+    logger.profile(`queue.${queueNames.handleStateChange}`)
+}

package/dist/ai-context/internal/examples/v2/navitas/app/server/src/lib/browser/index.ts

@@ -0,0 +1,51 @@
+import { SeekaBrowserSdkPluginWebhookResponse } from '@seeka-labs/sdk-apps-server';
+import fs from 'fs';
+import path from 'path';
+import util from 'util';
+import winston, { Logger } from 'winston';
+import type { INavitasBrowserSdkPluginConfig } from '../models';
+import {
+    SeekaAppInstallState
+} from '../state/seeka/installations';
+
+const fileExistsAsync = util.promisify(fs.exists);
+const readFileAsync = util.promisify(fs.readFile);
+
+export async function getSeekaBrowserPlugin(installation: SeekaAppInstallState, logger: Logger): Promise<SeekaBrowserSdkPluginWebhookResponse> {
+    logger.profile('http.seeka.browser.plugin')
+
+    let content: string | undefined;
+    let init: string | undefined;
+
+    try {
+        logger.verbose('Handling request for browser plugin content');
+        const browserPluginPath = path.resolve('./dist/src/browser/seeka-app-navitas.min.js');
+        if (await fileExistsAsync(browserPluginPath)) {
+            // Content of the script. This should not change per installation it should be the same for all installations            
+            content = await readFileAsync(browserPluginPath, 'utf8');
+
+            // Configuration for the plugin. This can be different per installation
+            const pluginConfig = {
+                appId: process.env.SEEKA_APP_ID,
+                appInstallId: installation.applicationInstallId,
+            } as INavitasBrowserSdkPluginConfig;
+            init = `NavitasConvergeSdkPlugin(${JSON.stringify(pluginConfig)})`;
+        }
+        else {
+            logger.error('Browser plugin content not found', { path: browserPluginPath });
+        }
+    }
+    catch (err) {
+        logger.error('Failed to handle request for browser plugin content', { ex: winston.exceptions.getAllInfo(err) });
+    }
+    finally {
+        logger.profile('http.seeka.browser.plugin')
+        logger.verbose('Request for browser plugin content handled');
+    }
+
+    if (!content || !init) {
+        throw new Error('Failed to handle request for browser plugin content')
+    }
+
+    return { content, init: init }
+}

package/dist/ai-context/internal/examples/v2/navitas/app/server/src/lib/jobs/index.ts

@@ -0,0 +1,73 @@
+import { QueueClient } from '@azure/storage-queue';
+import type { Logger } from 'winston';
+
+export interface BackgroundJobRequestContext<TPayload> {
+    organisationId?: string;
+    organisationBrandId?: string;
+    applicationInstallId?: string;
+    causationId?: string
+    correlationId?: string
+    payload: TPayload
+}
+
+export const signatureHeaderName = 'x-signature-hmac';
+export const apiKeyHeaderName = 'x-api-key';
+
+export const queueNames = {
+    handleSalesforceWebhookPayload: 'navitas-salesforce-inbound-webhook-queue',
+    handleStateChange: 'navitas-state-change-queue'
+}
+
+export const triggerBackgroundJob = async <TPayload>(queueName: string, context: BackgroundJobRequestContext<TPayload>, logger: Logger): Promise<void> => {
+    const queueClient = new QueueClient(process.env.AzureWebJobsStorage as string, queueName);
+    return await triggerBackgroundJobWithQueue(queueClient, context, logger);
+}
+
+const serialiseQueuePayload = (payload: unknown): string => {
+    const jsonString = JSON.stringify(payload)
+    return Buffer.from(jsonString).toString('base64')
+}
+
+export const deserialiseQueuePayload = <TPayload>(payload: string): TPayload => {
+    const jsonString = Buffer.from(payload, 'base64').toString()
+    return JSON.parse(jsonString) as TPayload;
+}
+
+export const triggerBackgroundJobWithQueue = async <TPayload>(queueClient: QueueClient, context: BackgroundJobRequestContext<TPayload>, logger: Logger): Promise<void> => {
+    const body = {
+        ...context
+    }
+    const bodyStr = serialiseQueuePayload(body);
+
+    const response = await queueClient.sendMessage(bodyStr);
+
+    if (response.errorCode) {
+        const { requestId, date, errorCode } = response;
+        logger.error("Failed to trigger background job", { body, requestId, date, errorCode })
+        throw new Error(`Failed to trigger background job: ${response.errorCode}`);
+    }
+    else {
+        logger.info("Background job triggered for " + queueClient.name, { body, messageId: response.messageId, context })
+    }
+}
+
+export const sendQueueMessageToPoisonQueue = async <TPayload>(queueName: string, context: BackgroundJobRequestContext<TPayload>, logger: Logger): Promise<void> => {
+    const body = {
+        ...context
+    }
+    const bodyStr = serialiseQueuePayload(body);
+
+    // https://learn.microsoft.com/en-us/azure/azure-functions/functions-bindings-storage-queue-trigger?tabs=python-v2%2Cisolated-process%2Cnodejs-v4%2Cextensionv5&pivots=programming-language-typescript#poison-messages
+    const queueClient = new QueueClient(process.env.AzureWebJobsStorage as string, `${queueName}-poison`);
+
+    const response = await queueClient.sendMessage(bodyStr, { messageTimeToLive: -1 });
+
+    if (response.errorCode) {
+        const { requestId, date, errorCode } = response;
+        logger.error("Failed to push to poison queue", { body, requestId, date, errorCode })
+        throw new Error(`Failed to push to poison queue: ${response.errorCode}`);
+    }
+    else {
+        logger.verbose("Message pushed to poison queue", { body, messageId: response.messageId, context })
+    }
+}

package/dist/ai-context/internal/examples/v2/navitas/app/server/src/lib/logging/index.ts

@@ -0,0 +1,108 @@
+import * as winston from 'winston';
+
+import { InvocationContext } from '@azure/functions';
+import { SeqTransport } from '@datalust/winston-seq';
+
+import * as packageJson from '../../../package.json';
+
+import type {
+    SeekaWebhookPayload, SeekaWebhookPayloadOfSeekaAppWebhookContext
+} from '@seeka-labs/sdk-apps-server';
+import { BackgroundJobRequestContext } from '../jobs';
+import { SeekaAppInstallState } from '../state/seeka/installations';
+
+const loggerTransports: winston.transport[] = [
+    new winston.transports.Console({
+        level: process.env.LOGGING_LEVEL,
+        format: winston.format.combine(
+            winston.format.errors({ stack: true }),
+            winston.format.cli(),
+            winston.format.splat(),
+        ),
+        handleExceptions: true,
+        handleRejections: true,
+    }),
+]
+if (process.env.LOGGING_SEQ_SERVERURL) {
+    loggerTransports.push(
+        new SeqTransport({
+            level: process.env.LOGGING_LEVEL,
+            serverUrl: process.env.LOGGING_SEQ_SERVERURL,
+            apiKey: process.env.LOGGING_SEQ_APIKEY,
+            onError: ((e) => { console.error('Failed to configure Seq logging transport', e) }),
+            format: winston.format.combine(
+                winston.format.errors({ stack: true }),
+                winston.format.json(),
+            ),
+            handleExceptions: true,
+            handleRejections: true,
+        })
+    )
+}
+
+
+const defaultMeta = {
+    seekaAppId: process.env.SEEKA_APP_ID,
+    Hosting_Provider: 'azure',
+    Release_Version: `v${packageJson.version.split('-')[0]}`,
+    Hosting_Region: process.env.REGION_NAME,
+    Service_Instance_Id: process.env.WEBSITE_ROLE_INSTANCE_ID,
+    AzureFunctions_FunctionName: process.env.WEBSITE_SITE_NAME,
+    Service: `app/${packageJson.name}`,
+};
+
+export const logger = winston.createLogger({
+    level: process.env.LOGGING_LEVEL,
+    defaultMeta: {
+        ...defaultMeta
+    },
+    transports: loggerTransports,
+    exitOnError: false,
+});
+
+export const childLogger = (meta: object | null, installation?: SeekaAppInstallState, l: winston.Logger = logger) => l.child({
+    ...defaultMeta, ...meta, ...(installation ? {
+        seekaAppInstallId: installation.applicationInstallId,
+        seekaAppInstallOrganisationBrandId: installation.organisationBrandId,
+        seekaAppInstallOrganisationId: installation.organisationId
+    } : {})
+});
+
+
+export const webhookLogger = (payload: SeekaWebhookPayload, functionContext: InvocationContext) => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const meta: any = {
+        ...defaultMeta,
+        seekaWebhookType: payload.type,
+        seekaWebhookIsTest: payload.isTest,
+        RequestId: payload.requestId,
+        AzureFunctions_InvocationId: functionContext.invocationId,
+        CausationId: payload.causationId,
+        CorrelationId: payload.causationId,
+    }
+
+    const context = (payload as SeekaWebhookPayloadOfSeekaAppWebhookContext).context;
+    if (context) {
+        meta.seekaAppInstallId = context.applicationInstallId;
+        meta.seekaAppInstallOrganisationBrandId = context.organisationBrandId;
+        meta.seekaAppInstallOrganisationId = context.organisationId;
+    }
+
+    return childLogger(meta)
+}
+
+export const backgroundJobLogger = (jobName: string, jobContext: BackgroundJobRequestContext<any> | undefined, functionContext: InvocationContext) => {
+    const meta: object = {
+        jobContext,
+        jobName,
+        AzureFunctions_InvocationId: functionContext.invocationId,
+        CausationId: jobContext?.causationId,
+        CorrelationId: jobContext?.causationId,
+        seekaAppInstallId: jobContext?.applicationInstallId,
+        seekaAppInstallOrganisationBrandId: jobContext?.organisationBrandId,
+        seekaAppInstallOrganisationId: jobContext?.organisationId,
+        ...defaultMeta
+    }
+
+    return childLogger(meta)
+}

package/dist/ai-context/internal/examples/v2/navitas/app/server/src/lib/models/index.ts

@@ -0,0 +1,4 @@
+export interface INavitasBrowserSdkPluginConfig {
+    appId: string
+    appInstallId: string
+}

package/dist/ai-context/internal/examples/v2/navitas/app/server/src/lib/salesforce/enrolment/forms/index.ts

@@ -0,0 +1,180 @@
+import { ActivityPayload, PersonIdentifiers, PlaceAddress, SeekaAppHelper, TrackingActivityNames, TrackingEventSourceOriginType } from "@seeka-labs/sdk-apps-server";
+import { Logger } from "winston";
+import * as packageJson from '../../../../../package.json';
+import { createOrUpdateJourney, getJourneyIdFromEnrolmentForm, handleContactMerge, tryGetJourney } from "../../../state/navitas/journey";
+import { SeekaAppInstallState } from "../../../state/seeka/installations";
+import { getWhoId, SalesforceEnrolmentFormWebhookPayloadObject } from "../../models";
+
+export const handleSalesforceEnrolmentFormWebhook = async (enrolmentformPayload: SalesforceEnrolmentFormWebhookPayloadObject, installation: SeekaAppInstallState, logger: Logger): Promise<void> => {
+    if (!enrolmentformPayload) {
+        logger.error('No enrolmentform object found in Salesforce webhook payload');
+        return;
+    }
+
+    let thisLogger = logger.child({ 'enrolmentFormId': enrolmentformPayload.Id });
+
+    thisLogger.info('Handling Salesforce EnrolmentForm webhook', { enrolmentformPayload });
+    const enrolmentFormId = enrolmentformPayload.Id;
+    if (!enrolmentFormId) {
+        thisLogger.error('No enrolmentform id found in Salesforce webhook payload');
+        return;
+    }
+    let whoId = getWhoId(enrolmentformPayload.Contact_ID__c || enrolmentformPayload.Lead_Contact_Id__c, enrolmentformPayload.Lead_ID__c, thisLogger);
+    thisLogger = thisLogger.child({ whoId });
+
+    const leadId = enrolmentformPayload.Lead_ID__c;
+    // Create seeka API helper
+    const { name, version } = packageJson;
+    const helper = SeekaAppHelper.create(process.env['SEEKA_APP_SECRET'] as string, {
+        organisationId: installation.organisationId as string,
+        applicationInstallId: installation.applicationInstallId as string,
+        applicationId: process.env['SEEKA_APP_ID'] as string,
+    }, { name, version }, installation.installationState.grantedPermissions, thisLogger);
+
+    let seekaProfileId = enrolmentformPayload.SeekaProfileId__c || null;
+    const seekaProfile = salesforceEnrolmentFormToSeekaProfile(enrolmentformPayload, whoId);
+    if (!seekaProfileId) {
+        thisLogger.warn('No Seeka profile ID found in Salesforce enrolmentform, creating Seeka profile', { enrolmentFormId, enrolmentformPayload });
+        seekaProfileId = await helper.api.mergeIdentity(seekaProfile, {
+            origin: TrackingEventSourceOriginType.Server
+        })
+        thisLogger = thisLogger.child({ Person_PersonId: seekaProfileId });
+        thisLogger.info('Created Seeka profile for Salesforce enrolmentform', { enrolmentFormId, seekaProfileId });
+    }
+    else {
+        thisLogger = thisLogger.child({ Person_PersonId: seekaProfileId });
+
+        seekaProfile.seekaPId = seekaProfileId;
+        await helper.api.mergeIdentity(seekaProfile, {
+            origin: TrackingEventSourceOriginType.Server
+        })
+
+        thisLogger.info('Used existing Seeka profile ID for Salesforce enrolmentform and updated Seeka profile', { enrolmentFormId, seekaProfileId });
+    }
+
+    // Maintain journey
+    const journeyId = getJourneyIdFromEnrolmentForm(enrolmentformPayload, thisLogger);
+    thisLogger = thisLogger.child({ journeyId });
+    let journey = await tryGetJourney(journeyId, false, thisLogger);
+    let created = false;
+    if (!whoId && journey && journey.whoId) {
+        thisLogger.warn('No whoID found on webhook payload but exists on journey')
+        whoId = journey.whoId;
+        thisLogger = thisLogger.child({ whoId });
+    }
+    if (!journey) {
+        // Create journey in state
+        thisLogger.info("Creating journey from enrolment form")
+        journey = await createOrUpdateJourney({
+            journeyId,
+            leadId,
+            lead: undefined,
+            whoId,
+            contactId: enrolmentformPayload.Contact_ID__c,
+            opportunityId: undefined,
+            leadPreviousStage: undefined,
+            leadCurrentStage: undefined,
+            opportunityPreviousStage: undefined,
+            opportunityCurrentStage: undefined,
+            seekaPersonId: [seekaProfileId]
+        }, true, false, thisLogger);
+        created = true;
+    }
+    if (!created) {
+        // Update lead
+        if (journey.whoId && whoId && journey.whoId !== whoId) {
+            thisLogger.warn('Updating WhoId on journey', { prev: journey.whoId, updated: whoId })
+        }
+
+        const oldContactId = journey.contactId;
+        journey = await createOrUpdateJourney({
+            ...journey,
+            whoId: whoId || journey.whoId,
+            contactId: enrolmentformPayload.Contact_ID__c || journey.contactId,
+            seekaPersonId: [...(journey.seekaPersonId || []), seekaProfileId].filter(Boolean)
+        }, true, false, thisLogger);
+
+        await handleContactMerge(oldContactId, enrolmentformPayload.Contact_ID__c, whoId || journey.whoId, 'enrolmentform', enrolmentformPayload.Id, installation, thisLogger)
+    }
+
+    thisLogger = thisLogger.child({ 'Person_PersonId': seekaProfileId, 'Person_BrowserId': seekaProfileId });
+
+    await trackActivityForEnrolmentFormWebhook(enrolmentformPayload, seekaProfileId, whoId, helper, thisLogger)
+}
+
+const trackActivityForEnrolmentFormWebhook = async (enrolmentform: SalesforceEnrolmentFormWebhookPayloadObject, seekaProfileId: string, whoId: string | null, helper: SeekaAppHelper, logger: Logger) => {
+    const payload: ActivityPayload = {
+        activityName: TrackingActivityNames.Lead,
+        lead: {
+            sourceContentName: enrolmentform.Program_Name__c || enrolmentform.Discipline__c
+        },
+        activityId: `enrollmentform-${enrolmentform.Id}`,
+        properties: {
+            whoId,
+            leadId: enrolmentform.Lead_ID__c || enrolmentform.Lead_Contact_Id__c,
+            leadContactId: enrolmentform.Lead_Contact_Id__c,
+            contactId: enrolmentform.Contact_ID__c,
+        }
+    }
+    logger.info('Tracking activity for enrollment form', { payload, Activity_ActivityIdentifier: payload.activityId });
+
+    await helper.api.trackActivityForProfileId(payload, seekaProfileId as string, {
+        origin: TrackingEventSourceOriginType.Server,
+        // loc: sourceUrl || undefined
+    })
+}
+
+const salesforceEnrolmentFormToSeekaProfile = (enrolmentform: SalesforceEnrolmentFormWebhookPayloadObject, whoId: string | null): PersonIdentifiers => {
+    const seekaProfile: PersonIdentifiers = {
+        // firstName: enrolmentform.FirstName ? [enrolmentform.FirstName] : [],
+        // lastName: enrolmentform.LastName ? [enrolmentform.LastName] : [],
+        email: enrolmentform.Form_Email__c ? [enrolmentform.Form_Email__c] : [],
+        phone: [],
+        // facebook: {
+        //     enrolmentform: enrolmentformPayload.enrolmentformSource?.toLowerCase() === 'facebook' && enrolmentformPayload.enrolmentform_Number__c ? [enrolmentformPayload.enrolmentform_Number__c] : []
+        // }
+    };
+    // if (enrolmentform.SO_Account_Phone__c) {
+    //     seekaProfile.phone.push(enrolmentform.SO_Account_Phone__c);
+    // }
+    // if (enrolmentform.SO_Account_Mobile__c && enrolmentform.SO_Account_Mobile__c !== enrolmentform.SO_Account_Phone__c) {
+    //     seekaProfile.phone.push(enrolmentform.SO_Account_Mobile__c);
+    // }
+    const address: PlaceAddress = {};
+    let hasAddress = false;
+    if (enrolmentform.Residential_Address_Counrt__c) {
+        address.country = enrolmentform.Residential_Address_Counrt__c;
+        hasAddress = true;
+    }
+    if (enrolmentform.Residential_Address_State_AUS__c) {
+        address.stateCode = enrolmentform.Residential_Address_State_AUS__c;
+        hasAddress = true;
+    }
+    if (enrolmentform.Residential_Address_Post_Code__c) {
+        address.postcode = enrolmentform.Residential_Address_Post_Code__c;
+        hasAddress = true;
+    }
+    if (hasAddress) {
+        seekaProfile.address = [address];
+    }
+
+    // ip address
+    if (enrolmentform.IP_Address__c) {
+        seekaProfile.ip = [enrolmentform.IP_Address__c];
+    }
+
+    // Name parts
+    if (enrolmentform.Form_First_Name__c) {
+        seekaProfile.firstName = [enrolmentform.Form_First_Name__c];
+    }
+    if (enrolmentform.Form_Last_Name__c) {
+        seekaProfile.lastName = [enrolmentform.Form_Last_Name__c];
+    }
+
+    // External ID
+    if (whoId) {
+        seekaProfile.eid = [whoId];
+    }
+
+    return seekaProfile;
+}

package/dist/ai-context/internal/examples/v2/navitas/app/server/src/lib/salesforce/index.ts

@@ -0,0 +1,47 @@
+import { Logger } from "winston";
+import { SalesforceEnrolmentFormWebhookPayloadObject, SalesforceLeadWebhookPayloadObject, SalesforceOpportunityWebhookPayloadObject, SalesforceWebhookPayloadObject, SalesforceWebhookPayloadQueueItem } from "./models";
+
+import { isArray } from 'lodash';
+import { SeekaAppInstallState } from "../state/seeka/installations";
+import { handleSalesforceEnrolmentFormWebhook } from "./enrolment/forms";
+import { handleSalesforceLeadWebhook } from "./leads";
+import { handleSalesforceOpportunityWebhook } from "./opportunities";
+
+export const handleSalesforceWebhook = async (item: SalesforceWebhookPayloadQueueItem<SalesforceWebhookPayloadObject>, installation: SeekaAppInstallState, logger: Logger): Promise<void> => {
+    const notification = item?.payload.Body?.notifications?.Notification;
+
+    if (!notification) {
+        logger.warn('No notification found in Salesforce webhook payload', { payload: item.payload });
+        return;
+    }
+
+    if (isArray(notification)) {
+        for (const n of notification) {
+            handleNotification(n.sObject, installation, logger);
+        }
+    }
+    else {
+        handleNotification(notification.sObject, installation, logger);
+    }
+}
+
+const handleNotification = async (notification: SalesforceWebhookPayloadObject, installation: SeekaAppInstallState, logger: Logger) => {
+    const objectType = notification?.type;
+
+    switch (objectType) {
+        case 'sf:Lead':
+            await handleSalesforceLeadWebhook(notification as SalesforceLeadWebhookPayloadObject, installation, logger);
+            break;
+        case 'sf:Opportunity':
+            await handleSalesforceOpportunityWebhook(notification as SalesforceOpportunityWebhookPayloadObject, installation, logger);
+            break;
+        case 'sf:Enrolment_Form__c':
+            await handleSalesforceEnrolmentFormWebhook(notification as SalesforceEnrolmentFormWebhookPayloadObject, installation, logger);
+            break;
+        default:
+            logger.warn(`Unhandled Salesforce webhook object type ${objectType}`, { objectType, notification });
+            return;
+    }
+
+    logger.info('Handled Salesforce webhook queue payload', { objectType, notification });
+}