@seeka-labs/cli-apps 3.8.7 → 3.8.10

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

@@ -1,106 +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 type {
-    SeekaWebhookPayload, SeekaWebhookPayloadOfSeekaAppWebhookContext
-} from '@seeka-labs/sdk-apps-server';
-import { BackgroundJobRequestContext } from '../jobs';
-import { SeekaAppInstallState } from '../state/seeka/installations';
-
-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,
-        })
-    )
-}
-
-const defaultMeta = {
-    seekaAppId: process.env.SEEKA_APP_ID,
-    Hosting_Provider: 'azure',
-    Release_Version: `v${packageJson.version.split('-')[0]}`,
-    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}`,
-};
-
-export const logger = winston.createLogger({
-    level: process.env.LOGGING_LEVEL,
-    defaultMeta: {
-        ...defaultMeta
-    },
-    transports: loggerTransports,
-    exitOnError: false,
-});
-
-export const childLogger = (meta: object | null, installation?: SeekaAppInstallState, l: winston.Logger = logger) => l.child({
-    ...defaultMeta, ...meta, ...(installation ? {
-        seekaAppInstallId: installation.applicationInstallId,
-        seekaAppInstallOrganisationBrandId: installation.organisationBrandId,
-        seekaAppInstallOrganisationId: installation.organisationId
-    } : {})
-});
-
-export const webhookLogger = (payload: SeekaWebhookPayload, functionContext: InvocationContext) => {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const meta: any = {
-        ...defaultMeta,
-        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,
-        ...defaultMeta
-    }
-
-    return childLogger(meta)
-}

package/dist/ai-context/internal/examples/v1/sevenrooms/src/lib/models/index.ts

@@ -1,17 +0,0 @@
-import { TrackingActivityNames } from "@seeka-labs/sdk-apps-server"
-import { SevenRoomsAppInstallEventSettingsTyped } from "../state/seeka/models"
-
-export interface ISevenRoomsBrowserSdkPluginConfig {
-    events: SevenRoomsAppInstallEventSettingsTyped<ActivityNameInfo>
-    // sevenRoomsVenueId: string
-    // sevenRoomsVenueGroupId: string
-    currencyCode: string
-    appId: string
-    appInstallId: string
-    appUrl: string
-}
-
-export interface ActivityNameInfo {
-    standardName: TrackingActivityNames
-    activityName: string
-}

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

@@ -1,41 +0,0 @@
-import winston, { Logger } from 'winston';
-
-import { connect, disconnect, isConnected } from '../state/redis';
-
-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.debug(`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.verbose(`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/sevenrooms/src/lib/sevenrooms/auth/index.ts

@@ -1,70 +0,0 @@
-import fetch from 'node-fetch'
-import { Logger } from 'winston';
-import { SeekaAppInstallState, SevenRoomsAppInstallSettings, createOrUpdateInstallation, tryGetInstallation } from '../../state/seeka/installations';
-import { getSevenRoomsApiHost } from '../models';
-
-export const getSevenRoomsAuthToken = async (installationSettings: SevenRoomsAppInstallSettings, logger: Logger): Promise<SevenRoomsAuthToken> => {
-    const url = `https://${getSevenRoomsApiHost(installationSettings)}/2_4/auth`;
-
-    const details = {
-        'client_id': installationSettings.connection.sevenRoomsClientId,
-        'client_secret': installationSettings.connection.sevenRoomsClientSecret
-    };
-
-    const response = await fetch(url, {
-        method: 'POST',
-        headers: {
-            'Content-Type': 'application/x-www-form-urlencoded'
-        },
-        body: new URLSearchParams(details)
-    })
-
-    if (response.ok) {
-        const data = (await response.json())?.data;
-        return {
-            token: data.token,
-            token_expiration_datetime: data.token_expiration_datetime
-        }
-    }
-    else {
-        logger.error(`Failed to get auth token from SevenRooms: ${response.statusText}`, { res: await response.text(), status: response.status });
-        throw new Error(`Failed to get auth token from SevenRooms: ${response.statusText}`);
-    }
-}
-
-export const getOrCreateSevenRoomsAuthToken = async (installation: SeekaAppInstallState, logger: Logger): Promise<SevenRoomsAuthToken> => {
-    // Check if the token on the install state is still valid
-    if (installation.installationState.sevenRoomsToken) {
-        const now = new Date();
-        const expiration = new Date(installation.installationState.sevenRoomsToken.token_expiration_datetime);
-        if (expiration > now) {
-            logger.verbose('SevenRooms token is still valid');
-            return installation.installationState.sevenRoomsToken;
-        }
-        else {
-            logger.verbose('SevenRooms token has expired, getting new token');
-        }
-    }
-
-    const token = await getSevenRoomsAuthToken(installation.installationSettings, logger);
-
-    // Update the installation with the new token
-    if (token.token != installation.installationState.sevenRoomsToken.token) {
-        installation = await tryGetInstallation(installation.applicationInstallId, true, logger);
-        await createOrUpdateInstallation({
-            ...installation,
-            installationState: {
-                ...installation.installationState,
-                sevenRoomsToken: token
-            }
-        }, logger);
-        logger.verbose('Updated installation state with new SevenRooms token');
-    }
-
-    return token;
-}
-
-export interface SevenRoomsAuthToken {
-    token: string
-    token_expiration_datetime: string
-}

package/dist/ai-context/internal/examples/v1/sevenrooms/src/lib/sevenrooms/charges/index.ts

@@ -1,202 +0,0 @@
-import { Logger } from "winston";
-import { SeekaAppInstallState, SevenRoomsAppInstallSettings } from "../../state/seeka/installations";
-import { SeekaActivityAcceptedWebhookContent, WebsiteEventActivityAppsPayload, matchActivityPipelineFilters } from "@seeka-labs/sdk-apps-server";
-import { SevenRoomsAuthToken, getOrCreateSevenRoomsAuthToken } from "../auth";
-import { getSevenRoomsApiHost } from "../models";
-import { SevenRoomsReservation, findSevenRoomsReservations, getReservationDateByActivity } from "../reservations";
-import { findSevenRoomsClients } from "../clients";
-import { DateTime } from 'luxon';
-
-export const handleChargePushRules = async (activity: SeekaActivityAcceptedWebhookContent, forSevenRoomsClientId: string | undefined, installation: SeekaAppInstallState, logger: Logger) => {
-    const rules = installation.installationSettings?.charges?.pushChargesToSevenRoomsRules || [];
-    if (rules.length === 0) return;
-
-    let thisLogger = logger.child({
-        sevenRoomsClientId: forSevenRoomsClientId,
-        'Person_PersonId': activity.identifiers.seekaPId,
-        'Activity_ActivityName': activity.activity.activityName,
-        'Activity_ActivityNameCustom': activity.activity.activityNameCustom,
-        'Reason': 'ChargePushRules'
-    })
-    thisLogger.verbose('Checking activity against charge push rules', { activity, rules });
-    const matched = matchActivityPipelineFilters(activity, rules, thisLogger);
-    if (matched.length === 0) {
-        thisLogger.verbose('No charge push rules matched activity', { activity, rules });
-        return;
-    }
-
-    const sevenRoomsToken = await getOrCreateSevenRoomsAuthToken(installation, thisLogger);
-    let sevenRoomsClientIds: string[] = [];
-    if (forSevenRoomsClientId) {
-        sevenRoomsClientIds.push(forSevenRoomsClientId);
-    }
-
-    if (sevenRoomsClientIds.length === 0) {
-        thisLogger.debug('No SevenRooms client ID provided to charge rules, trying to find client');
-
-        const externalIds = [activity.identifiers.seekaPId, ...(activity.identifiers.seekaBId ?? [])];
-        const existingClients = await findSevenRoomsClients(activity.identifiers.email, activity.identifiers.phone, externalIds, installation.installationSettings, sevenRoomsToken, thisLogger);
-        if (existingClients.length > 1) {
-            sevenRoomsClientIds = existingClients.map(c => c.id).filter(Boolean);
-            thisLogger = thisLogger.child({ sevenRoomsClientId: sevenRoomsClientIds })
-            thisLogger.warn('Found multiple clients in SevenRooms to allocate charges to', {
-                email: activity.identifiers.email,
-                phone: activity.identifiers.phone,
-                externalIds: externalIds,
-                clients: existingClients,
-            });
-        }
-        else if (existingClients.length === 1) {
-            const existingClient = existingClients[0];
-            sevenRoomsClientIds = [existingClient.id];
-            thisLogger = thisLogger.child({ sevenRoomsClientId: sevenRoomsClientIds })
-            thisLogger.debug('Found single client in SevenRooms to allocate charges to', { client: existingClient, activity });
-        }
-        else {
-            // No client found
-            thisLogger.debug('No client found in SevenRooms to allocate charges to, not creating client as there will be no reservation to assign the charge to');
-            return;
-            // const newClient = seekaIdentityToSevenRoomsClient(activity.identifiers, installation.installationSettings.connection.sevenRoomsVenueId, true, installation.installationSettings.advanced.allowUseOfSevenRoomsExternalId, logger);
-            // if (newClient) {
-            //     const created = await createSevenRoomsClient(newClient, installation.installationSettings, sevenRoomsToken, thisLogger);
-            //     if (created) {
-            //         sevenRoomsClientId = created.client_id;
-            //         thisLogger = thisLogger.child({ sevenRoomsClientId })
-            //     }
-            //     else {
-            //         thisLogger.error('Failed to create client in SevenRooms for client charge push rules', { newClient });
-            //         return;
-            //     }
-            // }
-            // else {
-            //     thisLogger.error('Failed to convert Seeka indentity to SevenRooms client for client charge push rules', { activity });
-            //     return;
-            // }
-        }
-    }
-
-    thisLogger.verbose('Matched charge push rules and SevenRooms client, pushing charges to SevenRooms', { matched });
-
-    // Find reservations
-    const reservationDate = getReservationDateByActivity(activity, thisLogger);
-    const reservationDateLuxon = DateTime.fromJSDate(reservationDate);
-    const fromDate = reservationDateLuxon.minus({ days: 1 });
-    const toDate = reservationDateLuxon.plus({ days: 1 });
-
-    // Find reservations across all clients
-    const matchedReservations: SevenRoomsReservation[] = [];
-    sevenRoomsClientIds.forEach(async (sevenRoomsClientId) => {
-        const reservations = await findSevenRoomsReservations(sevenRoomsClientId, fromDate, toDate, installation.installationSettings, sevenRoomsToken, thisLogger);
-        let reservation: SevenRoomsReservation | undefined;
-        if (!reservations || reservations.length === 0) {
-            thisLogger.warn('No reservations found for activity, not creating charge', { activity, sevenRoomsClientId, reservationDate, fromDate, toDate });
-            return;
-        }
-        else if (reservations.length > 1) {
-            thisLogger.warn('Multiple reservations found for activity, picking earliest booking time for the one to allocate charge to', { reservations, activity, sevenRoomsClientId, reservationDate, fromDate, toDate });
-            reservation = reservations.sort((a, b) => new Date(b.real_datetime_of_slot).getTime() - new Date(a.real_datetime_of_slot).getTime())[0];
-        }
-        else {
-            thisLogger.verbose('Found reservation for activity', { reservation: reservations[0], activity, sevenRoomsClientId, reservationDate, fromDate, toDate });
-            reservation = reservations[0];
-        }
-        if (reservation) {
-            matchedReservations.push(reservation);
-            thisLogger.verbose('Found reservation for activity', { reservation, activity, sevenRoomsClientId, reservationDate, fromDate, toDate });
-        }
-    })
-
-    if (matchedReservations.length === 1) {
-        // Create charge
-        const reservation = matchedReservations[0];
-        const charge = seekaActivityToSevenRoomsCharge(activity.activity, installation, thisLogger);
-        if (charge) {
-            await createSevenRoomsCharge(reservation.id, charge, installation.installationSettings, sevenRoomsToken, thisLogger);
-        }
-    }
-    else if (matchedReservations.length > 1) {
-        thisLogger.warn('Multiple reservations found for activity, not creating charge', { activity, matchedReservations });
-    }
-    else {
-        thisLogger.verbose('No reservations found for activity, not creating charge', { activity, matchedReservations });
-    }
-}
-
-const seekaActivityToSevenRoomsCharge = (activity: WebsiteEventActivityAppsPayload, installation: SeekaAppInstallState, logger: Logger): SevenRoomsChargeCreatePayload | null => {
-    const charge = {
-        venue_id: installation.installationSettings.connection.sevenRoomsVenueId,
-    } as SevenRoomsChargeCreatePayload;
-
-    if (activity.commerce) {
-        if (activity.commerce.totalPrice) {
-            if (activity.commerce.totalLineItemsPrice) {
-                charge.subtotal = activity.commerce.totalLineItemsPrice;
-                charge.total = activity.commerce.totalPrice;
-            }
-            else {
-                charge.subtotal = activity.commerce.totalPrice;
-            }
-
-            if (activity.commerce.totalTax) {
-                charge.tax = activity.commerce.totalTax;
-            }
-
-            if (activity.commerce.orderNumber) {
-                charge.transaction_id = activity.commerce.orderNumber;
-            }
-            else if (activity.commerce.orderIdentifier) {
-                charge.transaction_id = activity.commerce.orderIdentifier;
-            }
-            else if (activity.commerce.checkoutIdentifier) {
-                charge.transaction_id = activity.commerce.checkoutIdentifier;
-            }
-            else {
-                logger.warn('No transaction ID found in activity, using activity ID', { activity });
-                charge.transaction_id = activity.activityId;
-            }
-        }
-    }
-
-    if (!charge.subtotal) {
-        return null;
-    }
-
-    return charge;
-}
-
-const createSevenRoomsCharge = async (reservationId: string, charge: SevenRoomsChargeCreatePayload, installSettings: SevenRoomsAppInstallSettings, sevenRoomsToken: SevenRoomsAuthToken, logger: Logger): Promise<{ invoice_id: string, reference_id: string }> => {
-    const url = `https://${getSevenRoomsApiHost(installSettings)}/2_4/reservations/${reservationId}/add_charge`;
-    const response = await fetch(url, {
-        method: 'POST',
-        headers: {
-            'Authorization': `${sevenRoomsToken.token}`,
-            'Content-Type': 'application/x-www-form-urlencoded'
-        },
-        body: new URLSearchParams(charge as any)
-    });
-
-    if (!response.ok) {
-        const responseText = await response.text() || '';
-        const alreadyRecorded = responseText.includes('You have already recorded this transaction');
-        if (alreadyRecorded) {
-            logger.warn(`Charge already recorded in SevenRooms`, { charge, reservationId, responseText });
-        }
-        else {
-            logger.error(`Failed to create charge in SevenRooms: ${response.statusText}`, { res: await response.text(), status: response.status, charge, url });
-            throw new Error(`Failed to create charge in SevenRooms: ${response.statusText}`);
-        }
-    }
-    else {
-        const result = (await response.json())?.data;
-        logger.info('Created charge in SevenRooms', { charge, reservationId, result });
-        return result;
-    }
-}
-
-interface SevenRoomsChargeCreatePayload {
-    transaction_id: string;
-    venue_id: string;
-    subtotal: number;
-    total: number;
-    tax: number;
-}