@seeka-labs/cli-apps 2.2.6 → 3.2.5

package/dist/init-template/app/server-azure-function/package.json

@@ -1,51 +0,0 @@
-{
-  "name": "@seeka-app-example-name/server-azure-function",
-  "version": "2.2.1",
-  "description": "Seeka example app with hosting on Azure serverless functions",
-  "author": "Seeka <platform@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": "<packageManagerRunPrefix> clean && yarn build",
-    "dev": "func start --port 7072",
-    "tunnel": "node scripts/ngrok.js seeka-app-example-name-localdev",
-    "deploy": "yarn func azure functionapp publish seeka-app-example-name --no-build --javascript",
-    "dev:queue:create": "node scripts/dev-queue-setup.js sample-queue-name"
-  },
-  "dependencies": {
-    "@azure/functions": "^4.7.2",
-    "@azure/storage-queue": "^12.26.0",
-    "@datalust/winston-seq": "^2.0.0",
-    "@redis/client": "^5.1.0",
-    "@redis/json": "^5.1.0",
-    "@seeka-labs/sdk-apps-server": "2.0.7-rc.2",
-    "axios": "^1.9.0",
-    "lodash": "^4.17.21",
-    "redis": "^5.1.0",
-    "winston": "^3.17.0"
-  },
-  "devDependencies": {
-    "@jest/globals": "^29.7.0",
-    "@types/jest": "^29.5.14",
-    "@types/lodash": "^4.17.17",
-    "@types/lodash-es": "^4.17.12",
-    "@types/node": "^24",
-    "@typescript-eslint/eslint-plugin": "^8.32.1",
-    "@typescript-eslint/parser": "^8.32.1",
-    "azure-functions-core-tools": "*",
-    "eslint": "^9",
-    "jest": "^29.7.0",
-    "ngrok": "^5.0.0-beta.2",
-    "rimraf": "^6.0.1",
-    "ts-jest": "^29.3.4",
-    "typescript": "^5.8.3"
-  }
-}

package/dist/init-template/app/server-azure-function/src/functions/pollingExample.ts

@@ -1,39 +0,0 @@
-import winston from 'winston';
-
-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.debug('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', { ex: winston.exceptions.getAllInfo(err) })
-    }
-
-    logger.profile(`job.${jobNames.pollingExample}`)
-}

package/dist/init-template/app/server-azure-function/src/functions/queueExample.ts

@@ -1,67 +0,0 @@
-import winston from 'winston';
-
-import { app, InvocationContext } from '@azure/functions';
-
-import { BackgroundJobRequestContext, deserialiseQueuePayload, queueNames, sendQueueMessageToPoisonQueue } from '../lib/jobs';
-import { backgroundJobLogger } from '../lib/logging';
-import { startServices } from '../lib/services';
-import { groupBy } from 'lodash';
-import { SeekaAppInstallState, tryGetInstallation } from '../lib/state/seeka/installations';
-import { SeekaActivityAcceptedWebhookContent } from '@seeka-labs/sdk-apps-server';
-
-app.storageQueue('queueExample', {
-    queueName: queueNames.queueItemExampleQueueName,
-    connection: 'AzureWebJobsStorage',
-    handler: queueExample
-});
-
-export interface MyQueueItem extends BackgroundJobRequestContext {
-    items: SeekaActivityAcceptedWebhookContent[];
-}
-
-export async function queueExample(queueItem: any, context: InvocationContext): Promise<void> {
-    const logger = backgroundJobLogger(queueNames.queueItemExampleQueueName, undefined, context);
-    logger.profile(`queue.${queueNames.queueItemExampleQueueName}`)
-    try {
-        // queueItem can either be a single item or an array of items
-        const payload = deserialiseQueuePayload<MyQueueItem>(queueItem, logger);
-
-        // Group by applicationInstallId
-        const grouped = groupBy(payload, e => e.applicationInstallId);
-
-        logger.verbose('Received queue batch to handle queue message', { batchSize: payload.length });
-
-        // Process each group
-        await startServices(logger);
-        for (const [applicationInstallId, items] of Object.entries(grouped)) {
-            if (items.length === 0) {
-                logger.warn('No items to process for applicationInstallId', { applicationInstallId });
-                continue;
-            }
-            const thisLogger = backgroundJobLogger(queueNames.queueItemExampleQueueName, items[0], context);
-            try {
-                const installation = await tryGetInstallation(applicationInstallId, true, thisLogger) as SeekaAppInstallState;
-
-                // Execute sync
-                // const batchItems = items.flatMap(e => e.items || []).filter(Boolean)
-                // await executeLongRunningTask(batchItems, logger);
-            }
-            catch (err) {
-                thisLogger.error('Error handling queue item to handle queue message', { ex: winston.exceptions.getAllInfo(err) })
-                await sendQueueMessageToPoisonQueue(queueNames.queueItemExampleQueueName, {
-                    ...items[0],
-                    causationId: items[0].causationId,
-                    correlationId: context.invocationId,
-                    rows: items.flatMap(e => e.items || []).filter(Boolean)
-                } as MyQueueItem, thisLogger);
-            }
-        }
-    }
-    catch (err) {
-        logger.error('Error handling queue item to handle queue message', { ex: winston.exceptions.getAllInfo(err) })
-        throw err; // Will retry based on host.json > extensions.queues.maxDequeueCount and then push to poison queue
-    }
-    finally {
-        logger.profile(`queue.${queueNames.queueItemExampleQueueName}`)
-    }
-}

package/dist/init-template/app/server-azure-function/src/functions/seekaAppWebhook.ts

@@ -1,236 +0,0 @@
-import winston from 'winston';
-
-import { app, HttpRequest, HttpResponseInit, InvocationContext } from '@azure/functions';
-import {
-    SeekaActivityAcceptedWebhookPayload, SeekaAppInstalledWebhookPayload,
-    SeekaAppInstallSettingsUpdatedWebhookPayload, SeekaAppUninstalledWebhookPayload,
-    SeekaIdentityChangedWebhookPayload, SeekaWebhookCallType, SeekaWebhookPayload,
-    throwOnInvalidWebhookSignature
-} from '@seeka-labs/sdk-apps-server';
-
-import type { Headers as UndiciHeaders } from 'undici';
-import { getSeekaBrowserPlugin } from '../lib/browser';
-import { queueNames, triggerBackgroundJob } from '../lib/jobs';
-
-import { webhookLogger } from '../lib/logging';
-import { startServices } from '../lib/services';
-import {
-    createOrUpdateInstallation, deleteInstallation, SampleAppInstallSettings, SeekaAppInstallState, tryGetInstallation
-} from '../lib/state/seeka/installations';
-
-import type { Logger } from 'winston';
-import { MyQueueItem } from './queueExample';
-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;
-    if (!bodyStr) {
-        return {
-            status: 400,
-            jsonBody: { error: "Body missing. Ensure body is present and either specify the Content-Length request header OR set Transfer-Encoding request header to 'chunked'" }
-        }
-    }
-    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 as UndiciHeaders, 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
-    let errorMessage: string | null = null;
-    try {
-        switch (body.type) {
-            case SeekaWebhookCallType.AppInstalled:
-                {
-                    errorMessage = await onInstallation(body as SeekaAppInstalledWebhookPayload, logger);
-                    break;
-                }
-            case SeekaWebhookCallType.AppInstallSettingsUpdated:
-                {
-                    errorMessage = 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;
-                }
-            // START: component:browser
-            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'
-                    }
-                }
-            }
-            // END: component:browser
-        }
-    }
-    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');
-    }
-
-    if (errorMessage) {
-        logger.warn('Webhook call failed', { errorMessage });
-        return {
-            status: 400,
-            jsonBody: { error: { message: errorMessage } }
-        }
-    }
-
-    return {
-        status: 204
-    }
-}
-
-const validateInstallationSettings = async (installSettings: SampleAppInstallSettings, logger: Logger): Promise<string | null> => {
-    // Returning an error message string here will block the installation request or settings update request by the user installing the app
-
-
-    return null;
-}
-
-const onInstallation = async (payload: SeekaAppInstalledWebhookPayload, logger: Logger): Promise<string | null> => {
-    if (payload.isTest) return null;
-
-    const errorMessage = await validateInstallationSettings(payload.content?.installationSettings || {}, logger);
-    if (errorMessage) return errorMessage;
-
-    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)
-
-    try {
-        await triggerBackgroundJob(queueNames.queueItemExampleQueueName, {
-            ...payload.context,
-            causationId: payload.causationId,
-            correlationId: payload.requestId
-        }, logger)
-    }
-    catch (err) {
-        await deleteInstallation(installation.applicationInstallId, logger)
-        return 'Failed to complete install';
-    }
-
-    return null;
-}
-
-const onInstallationSettingsUpdate = async (payload: SeekaAppInstallSettingsUpdatedWebhookPayload, logger: Logger): Promise<string | null> => {
-    if (payload.isTest) return null;
-
-    const errorMessage = await validateInstallationSettings(payload.content?.installationSettings || {}, logger);
-    if (errorMessage) return errorMessage;
-
-    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)
-
-    await triggerBackgroundJob(queueNames.queueItemExampleQueueName, {
-        ...payload.context,
-        causationId: payload.causationId,
-        correlationId: payload.requestId
-    }, logger)
-
-    return null;
-}
-
-const handleSeekaActivity = async (activity: SeekaActivityAcceptedWebhookPayload, logger: Logger) => {
-    // Will be handled by queueExample
-    await triggerBackgroundJob(queueNames.queueItemExampleQueueName, {
-        ...activity.context,
-        causationId: activity.causationId,
-        correlationId: activity.requestId,
-        items: [activity]
-    } as MyQueueItem, logger)
-}

package/dist/init-template/app/server-azure-function/src/lib/browser/index.ts

@@ -1,55 +0,0 @@
-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 { ISampleAppBrowserSdkPluginConfig } 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-example-name.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.
-            // Configuration is sent to the browser so NO SENSITIVE CONFIG / SERVER SECRETS SHOULD BE SPECIFIED HERE.
-            const pluginConfig = {
-                myAppInstallSetting1: installation.installationSettings.myAppInstallSetting1,
-                myAppInstallSetting2: installation.installationSettings.myAppInstallSetting2,
-                appId: process.env.SEEKA_APP_ID,
-                appInstallId: installation.applicationInstallId,
-                appUrl: process.env.SELF_HOST_BASEURL
-            } as ISampleAppBrowserSdkPluginConfig;
-            init = `SampleAppConvergeSdkPlugin(${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/init-template/app/server-azure-function/src/lib/jobs/index.ts

@@ -1,96 +0,0 @@
-import { QueueClient } from '@azure/storage-queue';
-import { isArray } from 'lodash';
-import type { Logger } from 'winston';
-import winston from 'winston';
-
-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>(queueItem: any, logger: Logger): TPayload[] => {
-    try {
-        if (typeof queueItem !== 'string') {
-            if (isArray(queueItem)) {
-                return queueItem
-            }
-            return [queueItem]
-        }
-        else {
-            const jsonString = Buffer.from(queueItem, 'base64').toString()
-            const parsed = JSON.parse(jsonString);
-
-            if (isArray(parsed)) {
-                return parsed
-            }
-            return [parsed]
-        }
-    }
-    catch (err) {
-        logger.error('Failed to deserialise queue payload', { ex: winston.exceptions.getAllInfo(err), queueItem });
-        throw new Error(`Failed to deserialise queue payload`);
-    }
-}
-
-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, { messageTimeToLive: -1 });
-
-    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.debug("Background job triggered", { body, messageId: response.messageId, context })
-    }
-}
-
-export const sendQueueMessageToPoisonQueue = async (queueName: string, context: BackgroundJobRequestContext, 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/init-template/app/server-azure-function/src/lib/logging/index.ts

@@ -1,93 +0,0 @@
-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,
-        seekaAppInstallId: jobContext?.applicationInstallId,
-        seekaAppInstallOrganisationBrandId: jobContext?.organisationBrandId,
-        seekaAppInstallOrganisationId: jobContext?.organisationId
-    }
-
-    return childLogger(meta)
-}

package/dist/init-template/app/server-azure-function/src/lib/models/index.ts

@@ -1,7 +0,0 @@
-export interface ISampleAppBrowserSdkPluginConfig {
-    myAppInstallSetting1: string | number | undefined;
-    myAppInstallSetting2: string | number | undefined;
-    appId: string
-    appInstallId: string
-    appUrl: string
-}