@seeka-labs/cli-apps 3.7.0 → 3.8.2

package/dist/ai-context/internal/examples/v1/nowbookit/.eslintrc.cjs

@@ -0,0 +1,10 @@
+/* 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"
+    }
+};

package/dist/ai-context/internal/examples/v1/nowbookit/README.md

@@ -0,0 +1,82 @@
+# Seeka app example - 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: Ensure to replace DAN-LAPTOP 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://DAN-LAPTOP.local:10000/devstoreaccount1;QueueEndpoint=http://DAN-LAPTOP.local:10001/devstoreaccount1;TableEndpoint=http://DAN-LAPTOP.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 start`
+
+### 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` for your Seeka app webhook URL that you can place in your Seeka app configuration.
+
+#### 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-nowbookit.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
+
+#### Sample functions
+##### Seeka app webhook 
+`src/functions/seekaAppWebhook.ts`
+TODO
+
+##### Queue example 
+`src/functions/queueExample.ts`
+TODO
+
+##### Polling example 
+`src/functions/pollingExample.ts`
+TODO
+
+### Logging
+
+Winston included - TODO
+Seq included - TODO
+
+## 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.
+
+At the point of writing, Netlify and Upstash can be used to deploy your app for free.
+- https://upstash.com/pricing
+- https://www.netlify.com/pricing/
+
+### Gitlab
+TODO
+
+### Azure Function deploy
+- `yarn deploy`
+
+## State management
+Installations and other state is stored in Redis. Another state provider can be used, 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 swap out the connection strings with your Redis instance. 
+- When choosing region - use US East (Ohio) - us-east-* as this is the same Azure region that the Azure functions run from
+
+## 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/v1/nowbookit/_ai-summary.md

@@ -0,0 +1,41 @@
+# AI Summary for Seeka App: Now Book It
+
+## Overview
+The Now Book It app is designed to integrate with restaurant reservation systems to track bookings. It leverages Azure Functions to handle webhooks and background jobs, providing a scalable solution for managing restaurant reservations and related activities.
+
+## Purpose and Functionality
+- **Webhook Handling**: The app processes various webhook events from the Seeka platform, such as app installation, uninstallation, and activity acceptance.
+- **Background Jobs**: Utilizes Azure Storage Queues to manage background job processing, ensuring tasks are executed asynchronously and efficiently.
+- **Scheduled Tasks**: Implements scheduled polling to trigger jobs at regular intervals, facilitating periodic updates and maintenance tasks.
+
+## Key Implementation Patterns
+- **Azure Functions**: The app is structured around serverless functions, enabling event-driven execution with minimal infrastructure management.
+- **Queue-based Job Processing**: Background jobs are triggered via Azure Storage Queues, allowing for decoupled and scalable task execution.
+- **State Management with Redis**: Installation states and other critical data are stored in Redis, providing fast and reliable access to application state.
+
+## External APIs/Services Integrated
+- **Azure Functions**: Core platform for executing serverless functions.
+- **Azure Storage Queues**: Used for managing and processing background jobs.
+- **Redis (Upstash)**: Utilized for state management, offering a cloud-based, scalable Redis solution.
+- **Ngrok**: Facilitates local development by exposing local servers to the internet for testing purposes.
+
+## Important Data Transformations
+- **Webhook Payload Processing**: Incoming webhook payloads are deserialized and validated before being processed, ensuring data integrity and security.
+- **Queue Payload Deserialization**: Queue messages are deserialized to extract job context, enabling precise control over job execution.
+
+## Notable Code Patterns
+- **Webhook Signature Validation**: Ensures the authenticity of incoming webhooks by validating signatures, enhancing security.
+- **Logger Utilization**: Comprehensive logging using Winston and Seq for monitoring and debugging, providing insights into app behavior and performance.
+- **Service Initialization**: Centralized service startup pattern (`startServices`) to ensure all necessary services are initialized before processing requests or jobs.
+
+## Deployment and Development
+- **Azure Deployment**: The app is configured for deployment on Azure Functions, with scripts to automate the build and deployment process.
+- **Local Development**: Supports local development with Docker and Azurite for emulating Azure Storage services, and Ngrok for testing webhooks.
+
+## References
+- [Azure Functions Documentation](https://learn.microsoft.com/en-us/azure/azure-functions/)
+- [Azure Storage Queues Documentation](https://learn.microsoft.com/en-us/azure/storage/queues/)
+- [Upstash Redis](https://upstash.com/)
+- [Ngrok](https://ngrok.com/)
+
+This summary provides a comprehensive understanding of the Now Book It app's architecture and implementation, highlighting key patterns and integrations that can be leveraged for similar applications.

package/dist/ai-context/internal/examples/v1/nowbookit/host.json

@@ -0,0 +1,20 @@
+{
+  "version": "2.0",
+  "logging": {
+    "applicationInsights": {
+      "samplingSettings": {
+        "isEnabled": true,
+        "excludedTypes": "Request"
+      }
+    }
+  },
+  "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/v1/nowbookit/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "seeka-app-nowbookit",
+  "version": "0.1.62",
+  "description": "Seeka app seeka-app-nowbookit",
+  "author": "Seeka company <platform@seeka.co>",
+  "license": "MIT",
+  "main": "dist/src/functions/*.js",
+  "private": true,
+  "engines": {
+    "node": ">=18.14.0"
+  },
+  "scripts": {
+    "lint": "eslint",
+    "build": "tsc",
+    "watch": "tsc -w",
+    "clean": "yarn rimraf dist",
+    "prestart": "yarn clean && yarn build",
+    "start": "func start --port 7072",
+    "tunnel": "node scripts/ngrok.js seeka-app-nowbookit-localdev",
+    "deploy": "yarn clean && yarn build && func azure functionapp publish seeka-app-nowbookit --no-build"
+  },
+  "dependencies": {
+    "@azure/functions": "^4.1.0",
+    "@azure/storage-queue": "^12.16.0",
+    "@datalust/winston-seq": "^2.0.0",
+    "@seeka-labs/sdk-apps-server": "^0.1.45",
+    "axios": "^1.6.7",
+    "lodash-es": "^4.17.21",
+    "openid-client": "^5.6.4",
+    "redis": "^4.6.12",
+    "winston": "^3.11.0"
+  },
+  "devDependencies": {
+    "@types/lodash-es": "^4.17.12",
+    "@types/node": "^18",
+    "@typescript-eslint/eslint-plugin": "^6.19.1",
+    "@typescript-eslint/parser": "^6.19.1",
+    "azure-functions-core-tools": "^4.x",
+    "eslint": "^8",
+    "ngrok": "^5.0.0-beta.2",
+    "rimraf": "^5.0.0",
+    "typescript": "^4.1.6"
+  }
+}

package/dist/ai-context/internal/examples/v1/nowbookit/src/functions/pollingExample.ts

@@ -0,0 +1,37 @@
+import { app, InvocationContext, Timer } from '@azure/functions';
+import { QueueClient } from '@azure/storage-queue';
+
+import { jobNames, queueNames, triggerBackgroundJobWithQueue } from '../lib/jobs';
+import { backgroundJobLogger } from '../lib/logging';
+import { startServices } from '../lib/services';
+import { listInstallations } from '../lib/state/seeka/installations';
+
+// https://learn.microsoft.com/en-us/azure/azure-functions/functions-bindings-timer?tabs=python-v2%2Cisolated-process%2Cnodejs-v4&pivots=programming-language-typescript
+app.timer('pollingExample', {
+    schedule: '0 0 * * * *', // every 1 hour
+    handler: pollingExample
+});
+
+export async function pollingExample(myTimer: Timer, context: InvocationContext): Promise<void> {
+    const logger = backgroundJobLogger(jobNames.pollingExample, undefined, context);
+
+    logger.profile(`job.${jobNames.pollingExample}`)
+    logger.info('Received request to trigger scheduled job');
+
+    await startServices(logger);
+
+    const allInstallations = await listInstallations(logger);
+    logger.verbose(`Triggering background job for ${allInstallations.length} installations`)
+
+    const queueClient = new QueueClient(process.env.AzureWebJobsStorage as string, queueNames.queueItemExampleQueueName);
+    const promises = allInstallations.map(installation => triggerBackgroundJobWithQueue(queueClient, { ...installation, causationId: context.invocationId, correlationId: context.invocationId }, logger))
+
+    try {
+        await Promise.all(promises);
+    }
+    catch (err) {
+        logger.error('Error triggering background jobs', { err })
+    }
+
+    logger.profile(`job.${jobNames.pollingExample}`)
+}

package/dist/ai-context/internal/examples/v1/nowbookit/src/functions/queueExample.ts

@@ -0,0 +1,31 @@
+import { app, InvocationContext } from '@azure/functions';
+
+import { BackgroundJobRequestContext, deserialiseQueuePayload, queueNames } from '../lib/jobs';
+import { backgroundJobLogger } from '../lib/logging';
+import { startServices } from '../lib/services';
+
+app.storageQueue('queueExample', {
+    queueName: queueNames.queueItemExampleQueueName,
+    connection: 'AzureWebJobsStorage',
+    handler: queueExample
+});
+
+export async function queueExample(queueItem: string, context: InvocationContext): Promise<void> {
+    const body = deserialiseQueuePayload<BackgroundJobRequestContext>(queueItem);
+    const logger = backgroundJobLogger(queueNames.queueItemExampleQueueName, body, context);
+    logger.profile(`queue.${queueNames.queueItemExampleQueueName}`)
+
+    await startServices(logger);
+
+    logger.verbose('Received request to trigger background job', { body });
+
+    try {
+        // Execute sync
+        // await executeLongRunningTask(body, logger);
+    }
+    catch (err) {
+        logger.error('Error executing background job', { err })
+    }
+
+    logger.profile(`queue.${queueNames.queueItemExampleQueueName}`)
+}

package/dist/ai-context/internal/examples/v1/nowbookit/src/functions/seekaAppWebhook.ts

@@ -0,0 +1,193 @@
+import { app, HttpRequest, HttpResponseInit, InvocationContext } from '@azure/functions';
+import {
+    PersonIdentifiers, SeekaActivityAcceptedWebhookPayload, SeekaAppInstalledWebhookPayload,
+    SeekaAppInstallSettingsUpdatedWebhookPayload, SeekaAppUninstalledWebhookPayload,
+    SeekaIdentityChangedWebhookPayload, SeekaWebhookCallType, SeekaWebhookPayload,
+    throwOnInvalidWebhookSignature
+} from '@seeka-labs/sdk-apps-server';
+
+import { queueNames, triggerBackgroundJob } from '../lib/jobs';
+import { webhookLogger } from '../lib/logging';
+import { startServices } from '../lib/services';
+import {
+    createOrUpdateInstallation, deleteInstallation, SeekaAppInstallState, tryGetInstallation
+} from '../lib/state/seeka/installations';
+
+import type { Logger } from 'winston';
+
+app.http('seekaAppWebhook', {
+    methods: ['POST'],
+    authLevel: 'anonymous',
+    route: '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;
+
+    const 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" }
+            }
+        }
+    }
+
+    // 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.ActivityAccepted:
+                {
+                    const payload = body as SeekaActivityAcceptedWebhookPayload;
+                    await handleSeekaActivity(payload, logger);
+
+                    break;
+                }
+            case SeekaWebhookCallType.IdentityChanged:
+                {
+                    const payload = body as SeekaIdentityChangedWebhookPayload;
+
+                    break;
+                }
+        }
+    }
+    catch (err) {
+        logger.error('Failed to handle webhook', { error: 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,
+        applicationInstallId: payload.context?.applicationInstallId as string,
+        organisationBrandId: payload.context?.organisationBrandId as string,
+        organisationId: payload.context?.organisationId as string,
+        installationState: {},
+        installedAt: new Date(),
+        installationSettings: payload.content?.installationSettings || {}
+    }, logger)
+
+    await triggerBackgroundJob(queueNames.queueItemExampleQueueName, {
+        ...payload.context,
+        causationId: payload.causationId,
+        correlationId: payload.requestId
+    }, 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,
+        installationSettings: payload.content?.installationSettings || {},
+    }, logger)
+
+    await triggerBackgroundJob(queueNames.queueItemExampleQueueName, {
+        ...payload.context,
+        causationId: payload.causationId,
+        correlationId: payload.requestId
+    }, logger)
+}
+
+const handleSeekaActivity = async (activity: SeekaActivityAcceptedWebhookPayload, logger: Logger) => {
+    // const context = activity.context as SeekaAppWebhookContext;
+    // const helper = SeekaAppHelper.create(process.env['SEEKA_APP_SECRET'] as string, {
+    //     organisationId: context.organisationId as string,
+    //     applicationInstallId: context.applicationInstallId as string,
+    //     applicationId: process.env['SEEKA_APP_ID'] as string,
+    // }, { name, version }, logger);
+
+    // // Append a first name to the identity
+    // await helper.api.mergeIdentity({
+    //     seekaPId: activity.content?.personId,
+    //     firstName: [
+    //         'firstname_' + new Date().getTime()
+    //     ]
+    // }, {
+    //     method: 'toremove',
+    //     origin: TrackingEventSourceOriginType.Server
+    // })
+
+    // // Fire off a tracking event
+    // await helper.api.trackActivity({
+    //     activityName: TrackingActivityNames.Custom,
+    //     activityNameCustom: 'seeka-app-activity-accepted',
+    //     activityId: 'act' + new Date().getTime(),
+    // }, activity.content?.personId as string, {
+    //     method: 'toremove',
+    //     origin: TrackingEventSourceOriginType.Server
+    // })
+}

package/dist/ai-context/internal/examples/v1/nowbookit/src/lib/jobs/index.ts

@@ -0,0 +1,51 @@
+import type { Logger } from 'winston';
+import { QueueClient } from '@azure/storage-queue';
+
+export interface BackgroundJobRequestContext {
+    organisationId?: string;
+    organisationBrandId?: string;
+    applicationInstallId?: string;
+    causationId: string
+    correlationId: string
+}
+
+export const signatureHeaderName = 'x-signature-hmac';
+export const apiKeyHeaderName = 'x-api-key';
+
+export const jobNames = {
+    pollingExample: 'polling-example',
+}
+
+export const queueNames = {
+    queueItemExampleQueueName: 'sample-queue-name'
+}
+
+export const triggerBackgroundJob = async (queueName: string, context: BackgroundJobRequestContext, logger: Logger): Promise<void> => {
+    const queueClient = new QueueClient(process.env.AzureWebJobsStorage as string, queueName);
+    return 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 (queueClient: QueueClient, context: BackgroundJobRequestContext, 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}`);
+    }
+}

package/dist/ai-context/internal/examples/v1/nowbookit/src/lib/logging/index.ts

@@ -0,0 +1,90 @@
+import * as winston from 'winston';
+
+import { InvocationContext } from '@azure/functions';
+import { SeqTransport } from '@datalust/winston-seq';
+
+import * as packageJson from '../../../package.json';
+import { BackgroundJobRequestContext } from '../jobs';
+
+import type {
+    SeekaWebhookPayload, SeekaWebhookPayloadOfSeekaAppWebhookContext
+} from '@seeka-labs/sdk-apps-server';
+
+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,
+        })
+    )
+}
+
+export const logger = winston.createLogger({
+    level: process.env.LOGGING_LEVEL,
+    defaultMeta: {
+        seekaAppId: process.env.SEEKA_APP_ID,
+        Hosting_Provider: 'azure',
+        Release_Version: `v${packageJson.version}`,
+        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}`,
+    },
+    transports: loggerTransports,
+    exitOnError: false,
+});
+
+export const childLogger = (meta: object) => logger.child(meta);
+
+export const webhookLogger = (payload: SeekaWebhookPayload, functionContext: InvocationContext) => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const meta: any = {
+        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 | undefined, functionContext: InvocationContext) => {
+    const meta: object = {
+        jobContext,
+        jobName,
+        AzureFunctions_InvocationId: functionContext.invocationId,
+        CausationId: jobContext?.causationId,
+        CorrelationId: jobContext?.causationId,
+    }
+
+    return childLogger(meta)
+}

package/dist/ai-context/internal/examples/v1/nowbookit/src/lib/services/index.ts

@@ -0,0 +1,40 @@
+import { connect, disconnect, isConnected } from "../state/redis";
+import { Logger } from "winston";
+
+export const startServices = async (logger: Logger) => {
+    logger.debug(`Trying to connect to Redis - ${process.env.REDIS_CONNECTION_HOST}`)
+    try {
+        if (isConnected()) {
+            logger.info(`Redis already connected - ${process.env.REDIS_CONNECTION_HOST}`)
+        }
+        else {
+            logger.profile('service.redis.connect')
+            await connect();
+            logger.profile('service.redis.connect')
+            logger.info(`Redis connected - ${process.env.REDIS_CONNECTION_HOST}`)
+        }
+    }
+    catch (e) {
+        logger.error(`Failed to connect to Redis - ${process.env.REDIS_CONNECTION_HOST}`, { error: e })
+        throw e;
+    }
+}
+
+export const stopServices = async (logger: Logger) => {
+    logger.debug(`Trying to disconnect from Redis - ${process.env.REDIS_CONNECTION_HOST}`)
+    try {
+        if (isConnected() === false) {
+            logger.info(`Redis already disconnected - ${process.env.REDIS_CONNECTION_HOST}`)
+        }
+        else {
+            logger.profile('service.redis.disconnect')
+            await disconnect();
+            logger.profile('service.redis.disconnect')
+            logger.info(`Redis disconnected - ${process.env.REDIS_CONNECTION_HOST}`)
+        }
+    }
+    catch (e) {
+        logger.error(`Failed to disconnect from Redis - ${process.env.REDIS_CONNECTION_HOST}`, { error: e })
+        throw e;
+    }
+}