@seeka-labs/cli-apps 3.7.0 → 3.8.2

package/dist/ai-context/internal/examples/v1/ivvy/src/lib/ivvy/api/webhooks.ts

@@ -0,0 +1,117 @@
+import winston, { Logger } from 'winston';
+import { SeekaAppInstallState, createOrUpdateInstallation } from '../../state/seeka/installations';
+import { makeIvvyApiRequest } from './requests';
+import { IvvyWebhookMessagePayload, IvvyWebhookMessagePayloadBody, IvvyWebhookPayload, installationIdQueryParam } from './models/webhooks';
+import { IvvyBooking } from './models/booking'
+import { handleIvvyBooking, handleIvvyInvoice } from '../services'
+import { IvvyInvoice } from './models/invoice';
+
+const getWebhookSubscribePayload = (applicationInstallId: string) => {
+    return {
+        'venuesEndpoint': `${process.env.SELF_URL}/api/webhook/ivvy?${installationIdQueryParam}=${applicationInstallId}`,
+        'paymentsEndpoint': `${process.env.SELF_URL}/api/webhook/ivvy?${installationIdQueryParam}=${applicationInstallId}`
+    };
+}
+
+export const ensureWebhooksSubscribed = async (installation: SeekaAppInstallState, logger: Logger): Promise<void> => {
+    logger.info('Ensuring ivvy webhooks are configured for installation', { installation });
+
+    const body = getWebhookSubscribePayload(installation.applicationInstallId);
+
+    try {
+        await unsubscribeFromWebhooks(installation, logger)
+    }
+    catch (err) {
+        logger.error('Failed to unsubscribe before subscribing from ivvy webhooks', { ex: winston.exceptions.getAllInfo(err) });
+    }
+
+    await makeIvvyApiRequest('account?action=subscribeToNotifications', JSON.stringify(body), 'post', 'application/json', '1.0', installation, logger);
+
+    await createOrUpdateInstallation({
+        ...installation,
+        installationState: {
+            ...installation.installationState,
+            webhookSubscribePayload: body
+        }
+    }, logger);
+
+    logger.verbose('Ivvy webhooks have been configured for installation', { installation });
+}
+
+export const unsubscribeFromWebhooks = async (installation: SeekaAppInstallState, logger: Logger): Promise<void> => {
+    logger.info('Unsubscribing from ivvy webhooks for installation', { installation });
+
+    const body = installation.installationState.webhookSubscribePayload || getWebhookSubscribePayload(installation.applicationInstallId)
+
+    const response = await makeIvvyApiRequest('account?action=unsubscribeFromNotifications', JSON.stringify(body), 'post', 'application/json', '1.0', installation, logger);
+    const responseBody = await response.text();
+
+    logger.verbose('Ivvy webhooks have been unsubscribed for installation', { installation, responseBody });
+}
+
+export const confirmIvvyWebhookSubscription = async (subscribeUrl: string | undefined, logger: Logger) => {
+    // https://developer.ivvy.com/notifications#subscribe
+    if (!subscribeUrl) {
+        throw new Error('SubscribeURL is missing from ivvy webhook payload');
+    }
+    const response = await fetch(subscribeUrl, {
+        method: 'GET'
+    })
+    if (response.status !== 200) {
+        logger.error('Failed to confirm ivvy webhook subscription', { status: response.status, body: response.text(), url: subscribeUrl });
+        throw new Error('Failed to confirm ivvy webhook subscription - status code returned was: ' + response.status);
+    }
+    logger.info("Ivvy webhook subscription confirmed", { url: subscribeUrl, body: await response.text() })
+}
+
+export const handleIvvyInboundWebhook = async (installation: SeekaAppInstallState, body: IvvyWebhookPayload, logger: Logger) => {
+    const payload = JSON.parse(body.Message as string) as IvvyWebhookMessagePayload;
+
+    switch (payload.Subject) {
+        case 'BookingAdded':
+        case 'BookingUpdated':
+            {
+                const payloadBody = JSON.parse(payload.Body) as IvvyWebhookMessagePayloadBody<IvvyBooking>
+                if (!isWebhookForValidVenue(installation, payloadBody.data.venueId, payload.Body, logger)) return;
+
+                await handleIvvyBooking(installation, payloadBody.data, payload.Subject, logger);
+                break;
+            }
+        case 'InvoiceAdded':
+        case 'InvoiceUpdated':
+            {
+                const payloadBody = JSON.parse(payload.Body) as IvvyWebhookMessagePayloadBody<IvvyInvoice>
+                if (!isWebhookForValidVenue(installation, payloadBody.data.venueId, payload.Body, logger)) return;
+
+                await handleIvvyInvoice(installation, payloadBody.data, payload.Subject, logger);
+                break;
+            }
+        default:
+            logger.warn('Unknown ivvy webhook subject', { subject: payload.Subject, body });
+            break;
+    }
+}
+
+const isWebhookForValidVenue = (installation: SeekaAppInstallState, webhookVenueId: number, webhookPayload: string, logger: Logger): boolean => {
+    // If the user installed the app specifying a Ivvy venue ID, make sure the webhook is for that venue
+    let filterByVenueId: string | null = null;
+    if (installation.installationSettings.ivvyVenueId) {
+        filterByVenueId = installation.installationSettings.ivvyVenueId.toString();
+    }
+    if (!filterByVenueId) return true;
+
+    const webhookVenueIdStr = webhookVenueId?.toString();
+
+    if (!webhookVenueIdStr) {
+        logger.warn('Ivvy webhook payload is missing venueId, not handling', { webhookPayload, webhookVenueId, filterByVenueId });
+        return false;
+    }
+    else if (webhookVenueIdStr !== filterByVenueId) {
+        logger.debug('Ivvy webhook payload is for a different venue than the installation, not handling', { webhookPayload, installation, webhookVenueId, filterByVenueId });
+        return false;
+    }
+    else {
+        logger.debug('Ivvy webhook payload is for the same venue as the installation, handling', { installation, webhookVenueId, filterByVenueId });
+        return true;
+    }
+}

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

@@ -0,0 +1,127 @@
+import { Logger } from "winston";
+import { IvvyBooking } from '../api/models/booking'
+import { IvvyInvoice, IvvyInvoiceStatus } from '../api/models/invoice'
+import { SeekaAppInstallState } from "../../state/seeka/installations";
+import { CommerceActivityTrackingEventMetadata, PlaceAddress, SeekaAppHelper, TrackingActivityNames, TrackingEventSourceOriginType } from "@seeka-labs/sdk-apps-server";
+import * as packageJson from '../../../../package.json';
+import { IvvyAddress } from "../api/models/common";
+import { IvvyWebhookMessagePayloadSubject } from "../api/models/webhooks";
+
+import { DateTime } from 'luxon';
+
+export const parseIvvyDate = (dateStr: string): DateTime => {
+    // ivvy format: 2024-03-14 03:29:07 UTC
+    const dateStandardised = dateStr.replace(' UTC', '').replace(' ', 'T');
+    return DateTime.fromISO(dateStandardised);
+}
+
+export const handleIvvyBooking = async (installation: SeekaAppInstallState, booking: IvvyBooking, webhookSubject: IvvyWebhookMessagePayloadSubject, logger: Logger) => {
+    logger.info('Handling ivvy booking', { booking });
+
+    if (webhookSubject === 'BookingAdded') {
+        logger.info('Booking is added, firing custom event', { booking });
+
+        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: packageJson.name, version: packageJson.version }, installation.installationState.grantedPermissions || [], logger);
+
+        const props: {
+            [key: string]: string;
+        } = {};
+
+        const timezone = booking.venueTimezone || booking.accountTimezone;
+        if (timezone && booking.dateEventStart) {
+            props.timezone = timezone;
+            props.bookingStart = booking.dateEventStart;
+            props.bookingEnd = booking.dateEventEnd;
+
+            // Parse date to local timezone
+            props.bookingStartLocal = parseIvvyDate(booking.dateEventStart).setZone(timezone).toISODate() as string;
+            props.bookingEndLocal = parseIvvyDate(booking.dateEventEnd).setZone(timezone).toISODate() as string;
+            logger.debug('Parsed booking dates to local timezone', { props });
+        }
+
+        // Fire off tracking event
+        await helper.api.trackActivityForProfile({
+            activityName: TrackingActivityNames.Custom,
+            activityNameCustom: 'IvvyBookingAdded',
+            activityId: 'IvvyBooking_' + booking.id + '_Created',
+            time: parseIvvyDate(booking.createdDate).toJSDate(),
+            properties: props
+        }, {
+            email: booking.contact.email ? [booking.contact.email] : [],
+            phone: booking.contact.phone ? [booking.contact.phone] : [],
+            firstName: booking.contact.firstName ? [booking.contact.firstName] : [],
+            lastName: booking.contact.lastName ? [booking.contact.lastName] : [],
+        }, {
+            origin: TrackingEventSourceOriginType.Server
+        })
+    }
+}
+
+export const handleIvvyInvoice = async (installation: SeekaAppInstallState, invoice: IvvyInvoice, webhookSubject: IvvyWebhookMessagePayloadSubject, logger: Logger) => {
+    logger.info('Handling ivvy invoice', { invoice });
+
+    if (invoice.currentStatus === IvvyInvoiceStatus.Paid) {
+        logger.info('Invoice is paid, firing order event', { invoice });
+
+        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: packageJson.name, version: packageJson.version }, installation.installationState.grantedPermissions || [], logger);
+
+        // Fire off tracking event
+        await helper.api.trackActivityForProfile(
+            {
+                activityName: TrackingActivityNames.Order,
+                activityId: 'IvvyBooking_' + invoice.bookingId + '_Invoice_' + invoice.id + '_Paid',
+                activityNameCustom: 'IvvyBookingPaid',
+                time: parseIvvyDate(invoice.modifiedDate).toJSDate(),
+                commerce: ivvyInvoiceToSeekaOrder(invoice),
+            }
+            , {
+                email: invoice.contact.email ? [invoice.contact.email] : (invoice.toContactEmail ? [invoice.toContactEmail] : []),
+                phone: invoice.contact.phone ? [invoice.contact.phone] : [],
+                firstName: invoice.contact.firstName ? [invoice.contact.firstName] : [],
+                lastName: invoice.contact.lastName ? [invoice.contact.lastName] : [],
+                address: invoice.toAddress ? [ivvyAddressToSeekaAddress(invoice.toAddress)] : []
+            }, {
+            origin: TrackingEventSourceOriginType.Server
+        })
+    }
+}
+
+const ivvyAddressToSeekaAddress = (address: IvvyAddress): PlaceAddress => {
+    return {
+        locality: address.city,
+        countryCode: address.countryCode,
+        country: address.countryName,
+        addressLine1: address.line1,
+        addressLine2: address.line2,
+        postcode: address.postalCode,
+        state: address.stateName,
+        stateCode: address.stateCode,
+    }
+}
+
+const ivvyInvoiceToSeekaOrder = (invoice: IvvyInvoice): CommerceActivityTrackingEventMetadata => {
+    return {
+        currencyCode: invoice.currency,
+        totalTax: invoice.totalTaxCost,
+        totalPrice: invoice.totalCost,
+        products: (invoice.items || []).map(item => {
+            return {
+                lineItemIdentifier: item.id.toString(),
+                productName: item.description,
+                productIdentifier: item.refId.toString(),
+                variantIdentifier: item.refType.toString(),
+                quantity: item.quantity,
+                unitPrice: item.unitCost,
+                totalTax: item.totalTaxCost,
+            }
+        })
+    }
+}

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

@@ -0,0 +1,105 @@
+import * as winston from 'winston';
+import { SeqTransport } from '@datalust/winston-seq';
+import type {
+    SeekaWebhookPayload, SeekaWebhookPayloadOfSeekaAppWebhookContext
+} from '@seeka-labs/sdk-apps-server';
+
+import * as packageJson from '../../../package.json';
+import { Context } from 'aws-lambda';
+
+let logger: winston.Logger | null = null;
+
+let seqTransport: SeqTransport | null;
+const createLogger = () => {
+    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(),
+                winston.format.json(),
+            ),
+            handleExceptions: true,
+            handleRejections: true,
+        }),
+    ]
+    if (process.env.LOGGING_SEQ_SERVERURL) {
+        seqTransport = 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(),
+            ),
+            requestTimeout: 8000,
+            handleExceptions: true,
+            handleRejections: true,
+        })
+        loggerTransports.push(seqTransport);
+    }
+
+    return winston.createLogger({
+        level: process.env.LOGGING_LEVEL,
+        defaultMeta: {
+            seekaAppId: process.env.SEEKA_APP_ID,
+            Hosting_Provider: 'aws',
+            Release_Version: `v${packageJson.version}`,
+            Hosting_Region: process.env.AWS_REGION,
+            Aws_Xray_TraceId: process.env._X_AMZN_TRACE_ID,
+            Aws_Lambda_FunctionName: process.env.AWS_LAMBDA_FUNCTION_NAME,
+            Service: `app/${packageJson.name}`,
+        },
+        transports: loggerTransports,
+        exitOnError: false,
+    })
+};
+
+export const getLogger = () => {
+    if (!logger || logger.closed) {
+        // If the AWS lambda host is reused then the logger will be closed and we need to recreate it
+        logger = createLogger();
+    }
+
+    return logger;
+};
+
+export const closeLogger = async () => {
+    if (!logger || logger.closed) return;
+
+    await seqTransport?.flush();
+}
+
+export const childLogger = (meta: object) => getLogger().child(meta);
+
+export const webhookLogger = (payload: SeekaWebhookPayload, functionContext: Context) => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const meta: any = {
+        seekaWebhookType: payload.type,
+        seekaWebhookIsTest: payload.isTest,
+        RequestId: payload.requestId,
+        AwsLambda_RequestId: functionContext.awsRequestId,
+        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 functionLogger = (functionContext: Context) => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const meta: any = {
+        AwsLambda_RequestId: functionContext.awsRequestId
+    }
+
+    return childLogger(meta)
+}

package/dist/ai-context/internal/examples/v1/ivvy/src/lib/polyfills/fetch.ts

@@ -0,0 +1,21 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+import fetch, {
+    Blob,
+    blobFrom,
+    blobFromSync,
+    File,
+    fileFrom,
+    fileFromSync,
+    FormData,
+    Headers,
+    Request,
+    Response,
+} from 'node-fetch'
+
+if (!globalThis.fetch) {
+    globalThis.fetch = fetch as any
+    globalThis.Headers = Headers as any
+    globalThis.Request = Request as any
+    globalThis.Response = Response as any
+}

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

@@ -0,0 +1,40 @@
+import { connect, disconnect, isConnected } from "../state/redis";
+import winston, { 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.verbose(`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 (err) {
+        logger.error(`Failed to connect to Redis - ${process.env.REDIS_CONNECTION_HOST}`, { ex: winston.exceptions.getAllInfo(err) })
+        throw err;
+    }
+}
+
+export const stopServices = async (logger: Logger) => {
+    logger.debug(`Trying to disconnect from Redis - ${process.env.REDIS_CONNECTION_HOST}`)
+    try {
+        if (isConnected() === false) {
+            logger.verbose(`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 (err) {
+        logger.error(`Failed to disconnect from Redis - ${process.env.REDIS_CONNECTION_HOST}`, { ex: winston.exceptions.getAllInfo(err) })
+        throw err;
+    }
+}

package/dist/ai-context/internal/examples/v1/ivvy/src/lib/state/redis/index.ts

@@ -0,0 +1,63 @@
+import { createClient } from 'redis';
+import { getLogger } from '../../logging';
+
+const redisProtocol = process.env.REDIS_CONNECTION_TLS === 'true' ? 'rediss://' : 'redis://';
+const redisConn = `${redisProtocol}${process.env.REDIS_CONNECTION_USER}:${process.env.REDIS_CONNECTION_PASSWORD}@${process.env.REDIS_CONNECTION_HOST}:${process.env.REDIS_CONNECTION_PORT}`;
+
+const redisClient = createClient({
+    url: redisConn
+})
+    .on('error', err => getLogger().error('Redis Client ', { error: err }));
+
+export const connect = async () => {
+    await redisClient.connect();
+}
+
+export const isConnected = () => {
+    return redisClient.isOpen;
+}
+
+export const disconnect = async () => {
+    await redisClient.disconnect();
+}
+
+const getKeyPrefix = (stateType: string) => `seeka:app:${process.env.SEEKA_APP_ID}:${stateType}`
+const getKey = (stateType: string, key: string) => `${getKeyPrefix(stateType)}:${key}`
+
+export async function getOrCreate<TState>(stateType: string, key: string, toCreate: TState): Promise<TState> {
+    const fullKey = getKey(stateType, key);
+    const existingStr = await redisClient.get(fullKey);
+    if (existingStr) return JSON.parse(existingStr);
+
+    await redisClient.set(fullKey, JSON.stringify(toCreate));
+
+    return toCreate;
+}
+
+export async function tryGet<TState>(stateType: string, key: string): Promise<TState | null> {
+    const fullKey = getKey(stateType, key);
+    const existingStr = await redisClient.get(fullKey);
+    if (existingStr) return JSON.parse(existingStr);
+
+    return null;
+}
+
+export async function getList<TState>(stateType: string): Promise<TState[]> {
+    const prefix = getKeyPrefix(stateType);
+    const allKeys = await redisClient.keys(`${prefix}:*`);
+    const listStr = await redisClient.mGet(allKeys);
+
+    if (listStr) return listStr.filter(e => Boolean(e)).map(e => JSON.parse(e as string));
+
+    return [];
+}
+
+export async function set<TState>(stateType: string, key: string, toCreate: TState): Promise<void> {
+    const fullKey = getKey(stateType, key);
+    await redisClient.set(fullKey, JSON.stringify(toCreate));
+}
+
+export async function remove(stateType: string, key: string): Promise<void> {
+    const fullKey = getKey(stateType, key);
+    await redisClient.del(fullKey);
+}

package/dist/ai-context/internal/examples/v1/ivvy/src/lib/state/seeka/installations.ts

@@ -0,0 +1,61 @@
+import type { Logger } from 'winston';
+
+import { getList, remove, set, tryGet } from '../../state/redis';
+
+export interface SeekaAppInstallState {
+    /** ID of the organisation that installed the app */
+    organisationId: string;
+    /** ID of the brand that installed the app */
+    organisationBrandId: string;
+    /** ID of the installation of the app */
+    applicationInstallId: string;
+    // Installation settings provided by the user installing the app
+    installationSettings: { [key: string]: string | number | undefined; };
+    // State relating to the app and installation of the app
+    installationState: IvvyAppInstallState;
+
+    // When the app was installed
+    installedAt: string; // new Date().toISOString()
+}
+
+export interface IvvyAppInstallState {
+    webhookSubscribePayload?: unknown
+    grantedPermissions?: string[]
+}
+
+const stateType = 'install'
+
+export const tryGetInstallation = async (applicationInstallId: string, throwWhenNotFound: boolean, logger: Logger): Promise<SeekaAppInstallState | null> => {
+    const installation = await tryGet<SeekaAppInstallState>(stateType, applicationInstallId);
+    if (installation == null && throwWhenNotFound) {
+        throw new Error(`Seeka installation ${applicationInstallId} not found`);
+    }
+
+    return installation;
+}
+
+export const listInstallations = async (logger: Logger): Promise<SeekaAppInstallState[]> => {
+    const installations = await getList<SeekaAppInstallState>(stateType);
+
+    return installations;
+}
+
+
+export const createOrUpdateInstallation = async (state: SeekaAppInstallState, logger: Logger): Promise<SeekaAppInstallState> => {
+    if (!state.installationState) state.installationState = {};
+    if (!state.installedAt) state.installedAt = new Date().toISOString();
+
+    const creating = (await tryGetInstallation(state.applicationInstallId, false, logger)) === null;
+
+    await set(stateType, state.applicationInstallId, state);
+
+    logger.info(creating ? 'Created installation state' : 'Updated installation state', { applicationInstallId: state.applicationInstallId, organisationId: state.organisationId, organisationBrandId: state.organisationBrandId });
+
+    return state;
+}
+
+export const deleteInstallation = async (applicationInstallId: string, logger: Logger): Promise<void> => {
+    await remove(stateType, applicationInstallId);
+
+    logger.info('Deleted installation state', { applicationInstallId });
+}

package/dist/ai-context/internal/examples/v1/ivvy/src/routes/ivvyWebhook.ts

@@ -0,0 +1,67 @@
+import { confirmIvvyWebhookSubscription, handleIvvyInboundWebhook } from '../lib/ivvy/api/webhooks';
+import { IvvyWebhookPayload, installationIdQueryParam } from '../lib/ivvy/api/models/webhooks';
+import { closeLogger, functionLogger } from '../lib/logging';
+import { startServices } from '../lib/services';
+import { Context } from 'aws-lambda';
+import { Request, Response } from 'express';
+import { SeekaAppInstallState, tryGetInstallation } from '../lib/state/seeka/installations';
+import winston from 'winston';
+
+export async function ivvyWebhook(req: Request, res: Response, context: Context): Promise<void> {
+    const body = req.body as IvvyWebhookPayload;
+
+    const logger = functionLogger(context);
+    if (process.env.SEEKA_DEBUG_ENABLED === 'true') {
+        logger.info('Received webhook from ivvy', { type: body.Type, body });
+    }
+    else {
+        logger.verbose('Received webhook from ivvy', { type: body.Type });
+    }
+
+    logger.profile('http.ivvy.webhook')
+
+    try {
+        if (body.Type === 'SubscriptionConfirmation') {
+            await confirmIvvyWebhookSubscription(body.SubscribeURL, logger);
+        }
+        else {
+            await startServices(logger);
+
+            // Check if the webhook is for an app we have installed
+            let installation: SeekaAppInstallState | null = null;
+            const installationId = req.query[installationIdQueryParam] as string | undefined | null;
+            if (!installationId) {
+                logger.error('Webhook call cannot be processed as the installation ID is missing or is not known by this app', { installationId });
+
+                res.status(422).json({ error: "App ID invalid" }).send();
+                await closeLogger();
+                return;
+            }
+            installation = await tryGetInstallation(installationId as string, false, logger);
+            if (installation == null) {
+                logger.warn('Webhook call cannot be processed as the installation ID is not known by this app');
+
+                res.status(422).json({ error: "App not installed" }).send();
+                await closeLogger();
+                return;
+            }
+
+            // Handle webhook
+            await handleIvvyInboundWebhook(installation, body, logger);
+        }
+
+        logger.profile('http.ivvy.webhook')
+        logger.verbose('Ivvy webhook handled');
+        await closeLogger();
+        res.status(204).send();
+    }
+    catch (err) {
+        logger.error('Failed to handle ivvy webhook', { ex: winston.exceptions.getAllInfo(err) });
+
+        logger.profile('http.ivvy.webhook')
+        logger.verbose('Ivvy webhook handled');
+        await closeLogger();
+
+        res.status(500).json({ error: "Request failed" }).send();
+    }
+}