@seeka-labs/cli-apps 3.8.8 → 3.8.10

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

@@ -1,117 +0,0 @@
-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

@@ -1,127 +0,0 @@
-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

@@ -1,105 +0,0 @@
-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

@@ -1,21 +0,0 @@
-/* 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

@@ -1,40 +0,0 @@
-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

@@ -1,63 +0,0 @@
-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

@@ -1,61 +0,0 @@
-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

@@ -1,67 +0,0 @@
-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();
-    }
-}