@seeka-labs/cli-apps 3.7.0 → 3.8.2

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

@@ -0,0 +1,172 @@
+
+import {
+  ConditionOperator,
+  ConvergeSdk,
+  CrossDomainTrackingDomainRule,
+  IConvergePlugin,
+  PersonIdentifiers
+} from '@seeka-labs/converge';
+
+import type { INavitasBrowserSdkPluginConfig } from '../../../server/src/lib/models';
+
+import { version } from '../../package.json';
+
+const crossDomainTracking = ['student-navitas.studylink.com']
+
+// const checkSdkAndPluginVersion = (expectedVersion: string, sdk: ConvergeSdk, pluginName: string): void => {
+//   let runtimeVersion = sdk.config.runtime.ver as string;
+//   runtimeVersion = runtimeVersion.replace('^', '');
+//   expectedVersion = expectedVersion.replace('^', '');
+
+//   if (expectedVersion !== runtimeVersion) {
+//     sdk.debug.warn(`The expected SDK version of ${expectedVersion} for the ${pluginName} plugin does not match the current installlation runtime of ${runtimeVersion}`);
+//   }
+// }
+
+export class NavitasConvergeSdkPlugin implements IConvergePlugin<INavitasBrowserSdkPluginConfig> {
+  constructor(pluginConfig: INavitasBrowserSdkPluginConfig) {
+    this.type = "seeka-app-navitas";
+    this.name = this.type + "-" + pluginConfig.appInstallId;
+    this.version = version;
+    this.sdk = {} as ConvergeSdk;
+    this.config = pluginConfig;
+  }
+  sdk: ConvergeSdk;
+
+  privacyConfig = {
+    // TODO
+    requiresIabPurposes: []
+  }
+
+  name: string;
+  type: string;
+  version: string;
+  config: INavitasBrowserSdkPluginConfig;
+  previousPersonId: string | undefined | null;
+
+  async init(_params: any): Promise<void> {
+    this.setStudyLinkCustInstId();
+    // checkSdkAndPluginVersion(dependencies['@seeka-labs/converge'], this.sdk, this.name)
+  }
+
+  async getCrossDomainTrackingRules(): Promise<CrossDomainTrackingDomainRule[]> {
+    return crossDomainTracking.map(domain => {
+      return {
+        id: this.type + '-' + domain,
+        sourceHostname: {
+          operator: ConditionOperator.Any,
+        },
+        destinationLink: {
+          operator: ConditionOperator.StartsWith,
+          matchValue: 'https://' + domain
+        }
+      }
+    })
+  }
+
+  async onReady(): Promise<void> {
+    this.prefilPersonIdFormField(this.sdk.identity.getProfile());
+  }
+
+  async onProfileChanged(profile: PersonIdentifiers): Promise<void> {
+    this.prefilPersonIdFormField(profile);
+  }
+
+  async collectIdentifiers(): Promise<PersonIdentifiers | undefined> {
+    const winLocation = this.sdk.dataLayer.window.location();
+    const hostname = winLocation?.hostname;
+    if (!hostname) return undefined;
+
+    const identity: PersonIdentifiers = {};
+    let populated = false;
+
+    if (hostname.includes('studylink.com')) {
+      const email = document.getElementById('email') as HTMLInputElement || document.getElementsByName('username')?.[0] as HTMLInputElement;
+      if (email && email.value) {
+        identity.email = [email.value];
+        populated = true;
+      }
+
+      const firstName = document.getElementById('FirstName') as HTMLInputElement;
+      if (firstName && firstName.value) {
+        identity.firstName = [firstName.value];
+        populated = true;
+      }
+
+      const lastName = document.getElementById('LastName') as HTMLInputElement;
+      if (lastName && lastName.value) {
+        identity.lastName = [lastName.value];
+        populated = true;
+      }
+
+      const phone = document.getElementById('core_f139') as HTMLInputElement;
+      if (phone && phone.value) {
+        identity.phone = [phone.value];
+        populated = true;
+      }
+
+      const nationality = document.getElementById('nationality') as HTMLSelectElement;
+      if (nationality && nationality.value) {
+        if (nationality.selectedIndex) {
+          const selectedOption = nationality.options[nationality.selectedIndex];
+          if (selectedOption) {
+            identity.address = [{
+              country: selectedOption.text
+            }]
+            populated = true;
+          }
+        }
+      }
+    }
+
+    if (populated) return identity;
+    return undefined;
+  }
+
+  // Set navitas_studylink_custInstID session storage so we can persist the 
+  // Query string parameter across the site and across navigations
+  // The navitas_studylink_custInstID session storage variable is used
+  // By GTM to install the correct Seeka instance onto the page
+  // custInstID is in the query string only on the first navigation to the studylink site
+  private setStudyLinkCustInstId() {
+    try {
+      const winLocation = this.sdk.dataLayer.window.location();
+      if (!winLocation) return;
+
+      const hostname = winLocation?.hostname;
+      if (!hostname || !hostname.includes('studylink.com')) {
+        return;
+      }
+
+      const urlParams = new URLSearchParams(winLocation.search);
+      const custInstID = urlParams.get('custInstID');
+      if (custInstID) {
+        const sessStorage = this.sdk.dataLayer.window.sessionStorage();
+        if (sessStorage) {
+          sessStorage.setItem('navitas_studylink_custInstID', custInstID);
+          this.sdk.debug.verbose(`Set navitas_studylink_custInstID to ${custInstID}`);
+        }
+      }
+    }
+    catch (err) {
+      this.sdk.debug.error('Error setting navitas_studylink_custInstID', err);
+    }
+  }
+
+  prefilPersonIdFormField(profile: PersonIdentifiers) {
+    const personId = profile.seekaPId;
+    if (!personId) return;
+    if (!this.previousPersonId || this.previousPersonId !== personId) {
+      this.previousPersonId = personId;
+      document.querySelectorAll('input[title="Seeka Profile ID"], input[name="dummyField12"]').forEach((input) => {
+        const inputElement = input as HTMLInputElement;
+        inputElement.value = personId;
+        this.sdk.debug.verbose(`Prefilled Seeka Profile ID field with value: ${personId}`);
+      });
+    }
+  }
+
+  isLoaded(): boolean {
+    return true;
+  }
+}

package/dist/ai-context/internal/examples/v2/navitas/app/browser/tsconfig.json

@@ -0,0 +1,34 @@
+{
+  "compilerOptions": {
+    "allowJs": false,
+    "target": "ESNext",
+    "module": "ESNext",
+    "resolveJsonModule": true,
+    "moduleResolution": "node",
+    "noEmit": true,
+    "strict": true,
+    "noImplicitAny": false,
+    "strictNullChecks": true,
+    "strictFunctionTypes": true,
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+    "importHelpers": true,
+    "skipLibCheck": true,
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "experimentalDecorators": true,
+    "sourceMap": true,
+    "types": [
+      "node"
+    ],
+    "lib": [
+      "ES6",
+      "DOM"
+    ]
+  },
+  "include": [
+    "src/browser.ts",
+  ]
+}

package/dist/ai-context/internal/examples/v2/navitas/app/server/.eslintrc.cjs

@@ -0,0 +1,11 @@
+/* eslint-env node */
+module.exports = {
+    extends: ['eslint:recommended', 'plugin:@typescript-eslint/recommended'],
+    parser: '@typescript-eslint/parser',
+    plugins: ['@typescript-eslint'],
+    root: true,
+    rules: {
+        "@typescript-eslint/no-unused-vars": "warn",
+        "@typescript-eslint/no-empty-function": "warn",
+    }
+};

package/dist/ai-context/internal/examples/v2/navitas/app/server/.nvmrc

@@ -0,0 +1 @@
+20

package/dist/ai-context/internal/examples/v2/navitas/app/server/README.md

@@ -0,0 +1,104 @@
+# Seeka app - Azure functions
+
+## Development
+
+- See [Configure your environment](https://learn.microsoft.com/en-us/azure/azure-functions/create-first-function-vs-code-typescript?pivots=nodejs-model-v4#configure-your-environment) for dependencies
+- For emulating Azure storage queues, blobs and tables: `docker run --name azurite -p 10000:10000 -p 10001:10001 -p 10002:10002 --detach mcr.microsoft.com/azure-storage/azurite`
+- Set `AzureWebJobsStorage` setting in local.settings.json to `UseDevelopmentStorage=true`
+    - If not using WSL: 
+    `UseDevelopmentStorage=true`
+    - If using WSL, the following may be required to allow your app to reach Azure storage emulator: 
+
+        Replace `MY-MACHINE-NAME` with your hostname. Below connection string allows running Azurite on your host machine and lets WSL connect to it
+        `DefaultEndpointsProtocol=http;AccountName=devstoreaccount1;AccountKey=Eby8vdM02xNOcqFlqUwJPLlmEtlCDXJ1OUzFT50uSRZ6IFsuFq2UVErCz4I6tq/K1SZFPTOtr/KBHBeksoGMGw==;BlobEndpoint=http://MY-MACHINE-NAME.local:10000/devstoreaccount1;QueueEndpoint=http://MY-MACHINE-NAME.local:10001/devstoreaccount1;TableEndpoint=http://MY-MACHINE-NAME.local:10002/devstoreaccount1;`
+- Install Azure Storage explorer and create your queues (see `./src/lib/jobs/index.ts` for `queueNames`). Azure Storage explorer can be used to view your queue items.
+- `yarn install`
+- `yarn dev`
+
+### Debugging
+Supports VSCode debugging via the debugger and utilisation of breakpoints. 
+This is only tested on Linux but may work on Windows. 
+If using Windows then use WSL with an Ubuntu distro for support of attaching the VS code debugger
+
+### Live urls
+You can expose your app locally to the internet via Ngrok to test your app before deploying.
+
+#### Setup
+1. Sign up for a Ngrok account
+2. Get your auth token
+3. `yarn ngrok config add-authtoken [auth token here]` replacing `[auth token]` with the auth token retrieved from your Ngrok dashboard
+
+#### Running
+1. `yarn start` OR start debugging in VSCode
+2. In separate terminal window run `yarn tunnel` and observe the log entry that starts with `Live url exposed`.
+3. Input the URL into your Seeka app configuration as the "Webook URL" via the Seeka UI.
+
+## Included sample functions
+### Seeka app webhook 
+`src/functions/seekaAppWebhook.ts`
+
+Handles inbound webhooks sent from Seeka to your app.
+
+### Queue example 
+`src/functions/queueExample.ts`
+
+Handles taking a message and placing it on an Azure storage queue for later processing. This concept can be used to offload long running operations based on data sent to your app from Seeka and can help to ensure Azure Function time execution limits are respected.
+
+### Polling example 
+`src/functions/pollingExample.ts`
+
+Handles scheduled invoking of a function. This concept can be used to "fan out" long running operations based on data sent to your app from Seeka and can help to ensure Azure Function time execution limits are respected by splitting long running operations into smaller, less time consuming parts.
+
+## Invoking functions
+### Development environment
+Scheduled / timer function: `curl -i -d '{"input": null}' -H "Content-Type: application/json" -X POST http://localhost:7072/admin/functions/pollingExample`
+
+### Azure cloud
+Scheduled / timer function: `curl -i -d '{"input": null}' -H "Content-Type: application/json" -H "x-functions-key: <key from azure portal>" -X POST https://seeka-app-navitas.azurewebsites.net/admin/functions/pollingExample`
+
+See [this doc](https://learn.microsoft.com/en-us/azure/azure-functions/functions-manually-run-non-http?tabs=azure-portal#get-the-master-key) on how to get the functions (master) key
+
+## Logging
+Centralised logging handled by [Winston](https://www.npmjs.com/package/winston). Winston is installed in this template and is also used in the Seeka SDK NPM packages.
+
+[Seq](https://datalust.co/seq) Winston transport is installed in this template (optional).
+
+To configure Seq options, see `_SEQ_` environment variables.
+
+To install Seq on your development machine
+1. Run `docker run --name seq -d --restart=always -e ACCEPT_EULA=Y -p 5341:80 datalust/seq:2024.2`
+2. Update your `LOGGING_SEQ_SERVERURL` environment variable to `http://localhost:5341` or `http://[YOUR MACHINE NAME].local:5341` if using WSL.
+
+If creating an API key for Seq, only permission that is required is `Ingest`.
+
+## State management
+Installations of your app and other state required for your app to function is stored in Redis. Another state provider can be swapped out for Redis, see `src/lib/state/seeka/installations.ts` for the file that manages the state of the installations.
+
+### Upstash (optional)
+If you dont want to use Upstash for Redis then the connection strings in `.env` can be swapped with your Redis instance. 
+
+> If using Upstash then create a database before following the below guide to deploying your AWS lambda function.
+
+> When choosing region - use a region that is closest to the Azure region that your function app is hosted in to reduce latency between the function and the Redis database. 
+
+## Deployment
+This project comes ready to deploy for free to Azure functions with database backed by Redis hosted by Upstash and queues, blobs and tables backed by Azure Storage.
+
+1. Create Azure function app via the portal with below settings
+    - Function app name: seeka-app-navitas
+    - Code or container image: Code
+    - Runtime stack: Node.js
+    - Version: 18 LTS
+    - Region: Closest region to where your upstash "master / write" database is located
+    - Operating system: linux
+    - Hosting: Consumption
+    - Enable public access: On
+2. Set environment variables of the Azure web app - reference local.settings.json "Values" 
+3. `yarn deploy`
+
+### Continuous delivery
+This template includes a GitLab CD pipeline that can be used to trigger deployments of your app when changes are pushed to your Git repository.
+
+## References
+- https://learn.microsoft.com/en-us/azure/storage/common/storage-use-azurite
+- https://learn.microsoft.com/en-us/azure/storage/queues/storage-quickstart-queues-nodejs?tabs=connection-string%2Croles-azure-portal%2Cenvironment-variable-windows%2Csign-in-azure-cli

package/dist/ai-context/internal/examples/v2/navitas/app/server/host.json

@@ -0,0 +1,25 @@
+{
+  "version": "2.0",
+  "logging": {
+    "applicationInsights": {
+      "samplingSettings": {
+        "isEnabled": true,
+        "excludedTypes": "Request"
+      }
+    }
+  },
+  "extensions": {
+    "http": {
+      "routePrefix": ""
+    }
+  },
+  "functionTimeout": "00:10:00",
+  "extensionBundle": {
+    "id": "Microsoft.Azure.Functions.ExtensionBundle",
+    "version": "[4.*, 5.0.0)"
+  },
+  "concurrency": {
+    "dynamicConcurrencyEnabled": true,
+    "snapshotPersistenceEnabled": true
+  }
+}

package/dist/ai-context/internal/examples/v2/navitas/app/server/package.json

@@ -0,0 +1,50 @@
+{
+    "name": "@seeka-app-navitas/server",
+    "version": "2.2.13",
+    "description": "Seeka app seeka-app-navitas",
+    "author": "Navitas <administrator@seeka.co>",
+    "license": "MIT",
+    "main": "dist/src/functions/*.js",
+    "private": true,
+    "engines": {
+        "node": ">=20"
+    },
+    "scripts": {
+        "lint": "eslint",
+        "build": "tsc",
+        "watch": "tsc -w",
+        "clean": "rimraf dist",
+        "prestart": "yarn clean && yarn build",
+        "dev": "func start --port 7072",
+        "tunnel": "node scripts/ngrok.js seeka-app-navitas-localdev",
+        "deploy": "yarn func azure functionapp publish seeka-app-navitas --no-build --javascript",
+        "dev:queue:create": "node scripts/dev-queue-setup.js navitas-salesforce-inbound-webhook-queue && node scripts/dev-queue-setup.js navitas-state-change-queue && node scripts/dev-queue-setup.js navitas-salesforce-inbound-webhook-queue-poison && node scripts/dev-queue-setup.js navitas-state-change-queue-poison"
+    },
+    "dependencies": {
+        "@azure/functions": "^4.8.0",
+        "@azure/storage-queue": "^12.28.0",
+        "@datalust/winston-seq": "^2.0.0",
+        "@google-cloud/bigquery": "^8.1.1",
+        "@redis/client": "^5.8.2",
+        "@redis/json": "^5.8.2",
+        "@seeka-labs-internal/lib-google-bigquery": "2.2.13",
+        "@seeka-labs/sdk-apps-server": "^1.1.39",
+        "axios": "^1.12.2",
+        "lodash": "^4.17.21",
+        "redis": "^5.8.2",
+        "winston": "^3.17.0",
+        "xml2js": "^0.6.2"
+    },
+    "devDependencies": {
+        "@types/lodash": "^4.17.20",
+        "@types/lodash-es": "^4.17.12",
+        "@types/node": "^20",
+        "@types/xml2js": "^0.4.14",
+        "@typescript-eslint/eslint-plugin": "^8.44.0",
+        "@typescript-eslint/parser": "^8.44.0",
+        "eslint": "^9",
+        "ngrok": "^5.0.0-beta.2",
+        "rimraf": "^6.0.1",
+        "typescript": "^5.8.3"
+    }
+}

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

@@ -0,0 +1,14 @@
+import { app, HttpRequest, HttpResponseInit, InvocationContext } from '@azure/functions';
+
+app.http('healthCheck', {
+    methods: ['GET', 'HEAD'],
+    authLevel: 'anonymous',
+    route: 'api/health',
+    handler: healthCheck
+});
+
+export async function healthCheck(req: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> {
+    return {
+        status: 200
+    }
+}

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

@@ -0,0 +1,156 @@
+import winston from 'winston';
+
+import { app, HttpRequest, HttpResponseInit, InvocationContext } from '@azure/functions';
+
+import { childLogger } from '../lib/logging';
+
+import * as xml2js from 'xml2js';
+import { queueNames, triggerBackgroundJob } from '../lib/jobs';
+import { SalesforceWebhookPayload } from '../lib/salesforce/models';
+import { startServices } from '../lib/services';
+import { tryGetInstallation } from '../lib/state/seeka/installations';
+
+app.http('salesforceWebhook', {
+    methods: ['POST', 'GET'],
+    authLevel: 'function',
+    route: 'api/webhook/salesforce',
+    handler: salesforceWebhook
+});
+
+export async function salesforceWebhook(req: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> {
+    let logger = childLogger({ requestId: context.invocationId, url: req.url });
+    let bodyStr: string | null;
+
+    const contentType = req.headers.get('Content-Type')
+    if (!contentType || (contentType != 'text/xml' && contentType != 'text/xml; charset=utf-8' && contentType !== 'application/xml') || req.method !== 'POST') {
+        const errMessage = "Must be a POST request with Content-Type as 'text/xml' or 'application/xml' or 'text/xml; charset=utf-8'";
+        logger.warn('Failed to handle salesforce webhook due to invalid request format', { url: req.url, contentType, headers: req.headers.keys(), reqMethod: req.method });
+
+        return {
+            status: 400,
+            headers: {
+                'Content-Type': 'text/xml'
+            },
+            body: generateSalesforceResponseBody(false, errMessage)
+        }
+    }
+
+    try {
+
+        bodyStr = (await req.text()) as string;
+        if (!bodyStr) {
+            const errMessage = "Body missing. Ensure body is present and either specify the Content-Length request header OR set Transfer-Encoding request header to 'chunked'";
+
+            logger.warn('Failed to handle salesforce webhook - body is missing', { url: req.url, headers: req.headers.keys() });
+
+            return {
+                status: 400,
+                headers: {
+                    'Content-Type': 'text/xml'
+                },
+                body: generateSalesforceResponseBody(false, errMessage)
+            }
+        }
+
+        logger.verbose('Received webhook from Salesforce', { bodyStr });
+        // const body = JSON.parse(bodyStr);
+
+        logger.profile('http.salesforce.webhook')
+
+        // With parser
+        const parser = new xml2js.Parser({
+            trim: true,
+            explicitArray: false,
+            explicitRoot: false,
+            normalize: true,
+            attrNameProcessors: [xml2js.processors.stripPrefix],
+            tagNameProcessors: [xml2js.processors.stripPrefix],
+            valueProcessors: [xml2js.processors.parseBooleans],
+            attrValueProcessors: [xml2js.processors.parseBooleans],
+            mergeAttrs: true,
+            async: true,
+        });
+
+        let payload: SalesforceWebhookPayload<any>;
+        try {
+            payload = (await parser.parseStringPromise(bodyStr)) as SalesforceWebhookPayload<any>;
+            logger.verbose('Parsed webhook from Salesforce', { payload });
+        }
+        catch (err) {
+            const winEx = winston.exceptions.getAllInfo(err)
+            logger.warn('Failed to parse salesforce webhook XML', { ex: winEx, err: !winEx ? err?.toString() : undefined, bodyStr, url: req.url });
+            return {
+                status: 400,
+                headers: {
+                    'Content-Type': 'text/xml'
+                },
+                body: generateSalesforceResponseBody(false, (winEx as any)?.message?.toString().split('at error')[0] || "Invalid XML")
+            }
+        }
+
+        logger = childLogger({ sfPayload: payload }, null, logger);
+
+        await startServices(logger);
+
+        const installationId = req.query.get('appInstallId');
+        const installation = await tryGetInstallation(installationId, true, logger);
+        logger = childLogger({ sfPayload: payload }, installation, logger);
+
+        await triggerBackgroundJob(queueNames.handleSalesforceWebhookPayload, {
+            payload,
+            organisationBrandId: installation.organisationBrandId,
+            organisationId: installation.organisationId,
+            applicationInstallId: installation.applicationInstallId,
+            causationId: context.invocationId,
+            correlationId: context.invocationId
+        }, logger)
+    }
+    catch (err) {
+        const winEx = winston.exceptions.getAllInfo(err)
+        logger.error('Failed to handle salesforce webhook', { ex: winEx, err: !winEx ? err?.toString() : undefined, bodyStr, url: req.url });
+        return {
+            status: 500,
+            headers: {
+                'Content-Type': 'text/xml'
+            },
+            body: generateSalesforceResponseBody(false)
+        }
+    }
+    finally {
+        logger.profile('http.salesforce.webhook')
+        logger.verbose('Salesforce webhook handled');
+    }
+
+    return {
+        status: 200,
+        headers: {
+            'Content-Type': 'text/xml'
+        },
+        body: generateSalesforceResponseBody(true)
+    }
+}
+
+const generateSalesforceResponseBody = (ack: boolean, message?: string) => {
+    return `<?xml version="1.0" encoding="UTF-8"?>
+    <soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+        <soapenv:Body>
+            <notificationsResponse xmlns="http://soap.sforce.com/2005/09/outbound">
+                <Ack>${ack ? 'true' : 'false'}</Ack>
+                ${!ack && message ? `<Message>${escapeXml(message)}</Message>` : ''}
+            </notificationsResponse>
+        </soapenv:Body>
+    </soapenv:Envelope>`;
+}
+
+// Helper to escape XML special characters
+const escapeXml = (unsafe: string) => {
+    return unsafe.replace(/[<>&'"]/g, function (c) {
+        switch (c) {
+            case '<': return '&lt;';
+            case '>': return '&gt;';
+            case '&': return '&amp;';
+            case '\'': return '&apos;';
+            case '"': return '&quot;';
+        }
+    });
+};

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

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