@seeka-labs/cli-apps 3.7.0 → 3.8.2

package/dist/ai-context/internal/examples/v2/google-bigquery/app/server/src/lib/google-big-query/schema/index.ts

@@ -0,0 +1,95 @@
+import $RefParser from "@apidevtools/json-schema-ref-parser";
+import type bigquery from "@google-cloud/bigquery/build/src/types";
+import get from 'lodash/get';
+import set from 'lodash/set';
+import unset from 'lodash/unset';
+import { Logger } from "winston";
+
+const schemaUrl = "https://api.seeka.services/swagger/scaffolding-sdk-developer-apps/swagger.json";
+
+let schemaCache: any | null = null;
+
+const getSchema = async (): Promise<any> => {
+    if (!schemaCache) {
+        schemaCache = await (await fetch(schemaUrl)).json();
+    }
+
+    // console.log('schemaCache', schemaCache);
+
+    return schemaCache;
+}
+
+export const getSchemaByName = async (name: string, logger: Logger): Promise<any> => {
+    const schema = await getSchema();
+
+    const dereferencedSchema = await $RefParser.dereference(schema, { mutateInputSchema: false });
+    logger.verbose('Dereferenced jsonschema', { schema: Object.keys(dereferencedSchema['components']['schemas']) });
+    const schemaByName = dereferencedSchema['components']['schemas'][name];
+    logger.verbose('filtered jsonschema', { schemaByName });
+
+    return schemaByName;
+}
+
+export const sanitiseBigQuerySchema = (schema: bigquery.ITableSchema, fieldsToRemove: string[], logger: Logger, currentPath?: string): bigquery.ITableSchema => {
+    if (Array.isArray(schema.fields)) {
+        schema.fields = schema.fields.filter(field => {
+            const fieldPath = currentPath ? `${currentPath}.${field.name}` : field.name;
+
+            // Check if the field should be removed
+            if (fieldsToRemove.includes(fieldPath)) {
+                logger.verbose('Removed field', { field, fieldPath });
+                return false; // Exclude this field
+            }
+
+            // Change mode to NULLABLE if it's REQUIRED
+            if (field.mode === 'REQUIRED') {
+                field.mode = 'NULLABLE';
+                logger.verbose('Changed mode to NULLABLE', { field, fieldPath });
+            }
+
+            // If the field contains nested fields, handle recursively
+            if (Array.isArray(field.fields)) {
+                sanitiseBigQuerySchema(field, fieldsToRemove, logger, fieldPath);
+            }
+
+            return true; // Include this field
+        });
+    }
+    return schema;
+}
+
+export const sanitiseBigQueryRecord = (payload: any, fieldsToRemove: string[], fieldsToJsonStringify: string[], logger: Logger) => {
+    fieldsToRemove.forEach(field => {
+        if (field.indexOf('[].') > -1) {
+            const arrayFieldParts = field.split('[].');
+            const arrayField = arrayFieldParts[0];
+            const array = get(payload, arrayField);
+            if (array) {
+                for (let i = 0; i < array.length; i++) {
+                    const subField = arrayFieldParts[1];
+                    const subValue = get(array[i], subField);
+                    if (subValue) {
+                        if (unset(array[i], subField)) {
+                            logger.verbose(`Removed field from payload: ${subField}`);
+                        }
+                    }
+                }
+            }
+        }
+        else {
+            if (unset(payload, field)) {
+                logger.verbose(`Removed field from payload: ${field}`);
+            }
+        }
+    });
+
+    fieldsToJsonStringify.forEach(field => {
+        const theVal = get(payload, field);
+        if (theVal) {
+            set(payload, field, JSON.stringify(theVal))
+            logger.verbose(`JSON stringified field from payload: ${field}`);
+        }
+    })
+
+    return payload;
+}

package/dist/ai-context/internal/examples/v2/google-bigquery/app/server/src/lib/google-big-query/utils.ts

@@ -0,0 +1,5 @@
+export const isErrorDueToNoBillingOnProject = (winstonError: any) => {
+    return ((winstonError?.errorMessage as string)?.includes('Billing has not been enabled for this project')) ||
+        (winstonError?.error?.message && typeof winstonError.error.message === 'string' && (winstonError.error.message as string).toLowerCase().includes('billing has not been enabled for this project')) ||
+        (winstonError?.error?.message && typeof winstonError.error.message === 'string' && (winstonError.error.message as string).toLowerCase().includes('streaming insert is not allowed in the free tier'))
+}

package/dist/ai-context/internal/examples/v2/google-bigquery/app/server/src/lib/jobs/index.ts

@@ -0,0 +1,92 @@
+import { QueueClient } from '@azure/storage-queue';
+import isArray from 'lodash/isArray';
+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 queueNames = {
+    pushRowsToBigQueryTable: 'push-rows-to-bigquery'
+}
+
+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.info("Background job triggered", { body, messageId: response.messageId, context })
+    }
+}
+
+export const sendQueueMessageToPoisonQueue = async (queueName: string, context: BackgroundJobRequestContext, ex: any, 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, ex })
+        throw new Error(`Failed to push to poison queue: ${response.errorCode}`);
+    }
+    else {
+        logger.verbose("Message pushed to poison queue", { body, messageId: response.messageId, context, ex })
+    }
+}

package/dist/ai-context/internal/examples/v2/google-bigquery/app/server/src/lib/logging/index.ts

@@ -0,0 +1,108 @@
+
+import type { InvocationContext } from '@azure/functions';
+import { SeqTransport } from '@datalust/winston-seq';
+
+import * as packageJson from '../../../package.json';
+import type { BackgroundJobRequestContext } from '../jobs';
+
+import type {
+    SeekaWebhookPayload, SeekaWebhookPayloadOfSeekaAppWebhookContext
+} from '@seeka-labs/sdk-apps-server';
+import { createLogger, format, Logger, transports } from 'winston';
+import type * as TransportStream from 'winston-transport';
+import { SeekaAppInstallState } from '../state/seeka/installations';
+
+const loggerTransports: TransportStream[] = [
+    new transports.Console({
+        level: process.env.LOGGING_LEVEL,
+        format: format.combine(
+            format.errors({ stack: true }),
+            format.cli(),
+            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: format.combine(
+                format.errors({ stack: true }),
+                format.json(),
+            ),
+            handleExceptions: true,
+            handleRejections: true,
+        }) as unknown as TransportStream
+    )
+}
+
+
+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 = createLogger({
+    level: process.env.LOGGING_LEVEL,
+    defaultMeta: {
+        ...defaultMeta
+    },
+    transports: loggerTransports,
+    exitOnError: false,
+});
+
+export const childLogger = (meta: object | null, installation?: SeekaAppInstallState, l: 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 ?? (jobContext as any)?.payload.applicationInstallId,
+        seekaAppInstallOrganisationBrandId: jobContext?.organisationBrandId,
+        seekaAppInstallOrganisationId: jobContext?.organisationId,
+        ...defaultMeta
+    }
+
+    return childLogger(meta)
+}

package/dist/ai-context/internal/examples/v2/google-bigquery/app/server/src/lib/model.ts

@@ -0,0 +1,6 @@
+import { SeekaActivityBigQueryRecord, SeekaIdentityChangedBigQueryRecord } from './google-big-query/models';
+import type { BackgroundJobRequestContext } from "./jobs";
+
+export interface PushRowsToBigQueryTableQueueItem extends BackgroundJobRequestContext {
+    rows: SeekaActivityBigQueryRecord[] | SeekaIdentityChangedBigQueryRecord[]
+}

package/dist/ai-context/internal/examples/v2/google-bigquery/app/server/src/lib/services/index.ts

@@ -0,0 +1,41 @@
+import { exceptions, 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: 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: exceptions.getAllInfo(err) })
+        throw err;
+    }
+}

package/dist/ai-context/internal/examples/v2/google-bigquery/app/server/src/lib/state/redis/index.ts

@@ -0,0 +1,86 @@
+import { createClient } from 'redis';
+
+import winston from 'winston';
+import { logger } 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}`;
+
+export const createRedisClient = () => {
+    return createClient({
+        url: redisConn,
+        disableClientInfo: true
+    })
+        .on('error', err => logger.error('Redis Client ', { ex: winston.exceptions.getAllInfo(err) }));
+}
+
+const redisClient = createRedisClient()
+
+export const connect = async () => {
+    await redisClient.connect();
+}
+
+export const isConnected = () => {
+    return redisClient.isOpen;
+}
+
+export const disconnect = async () => {
+    await redisClient.destroy();
+}
+
+const getKeyPrefix = (stateType: string) => `seeka:app:${process.env.SEEKA_APP_ID}:${stateType}`
+export 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 getString(redisClient, 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 getString(redisClient, 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 add<TState>(stateType: string, key: string, toCreate: TState): Promise<void> {
+    const fullKey = getKey(stateType, key);
+    await redisClient.sAdd(fullKey, JSON.stringify(toCreate));
+}
+
+export async function remove(stateType: string, key: string): Promise<void> {
+    const fullKey = getKey(stateType, key);
+    await redisClient.del(fullKey);
+}
+
+export async function getString(redisClient: any, key: string): Promise<string> {
+    const result = await redisClient.get(key);
+    if (typeof result === 'string') {
+        return result;
+    }
+    if (result) {
+        return result.toString();
+    }
+    return '';
+}

package/dist/ai-context/internal/examples/v2/google-bigquery/app/server/src/lib/state/seeka/installations.ts

@@ -0,0 +1,70 @@
+import type { Logger } from 'winston';
+
+import { getList, remove, set, tryGet } from '../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: GoogleBigqueryAppInstallSettings
+    // State relating to the app and installation of the app
+    installationState: GoogleBigqueryAppInstallState;
+
+    // When the app was installed
+    installedAt: string; // new Date().toISOString()
+}
+
+export interface GoogleBigqueryAppInstallState {
+    bigQuerySchemaLastMaintainedAt?: string
+    grantedPermissions?: string[]
+}
+
+export type GoogleBigqueryAppInstallSettings = { [key: string]: any; } | {
+    //myAppInstallSetting1: string | number | undefined;
+    //myAppInstallSetting2: string | number | undefined;
+    bigQueryActivityDatasetId: string | undefined;
+    bigQueryActivityTableName: string | undefined;
+    googleProjectId: string | undefined;
+    googleServiceAccountJson: string | undefined;
+}
+
+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/v2/google-bigquery/app/server/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "allowJs": true,
+    "skipLibCheck": true,
+    "strict": false,
+    "esModuleInterop": true,
+    "outDir": "dist",
+    "rootDir": ".",
+    "sourceMap": true,
+    "module": "CommonJS",
+    "target": "ES6",
+    "resolveJsonModule": true,
+    "isolatedModules": false,
+  },
+  "include": [
+    "src/functions/*.ts"
+  ]
+}

package/dist/ai-context/internal/examples/v2/google-bigquery/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "root",
+  "version": "1.2.9",
+  "private": true,
+  "workspaces": [
+    "app/*"
+  ],
+  "scripts": {
+    "build": "yarn workspace @seeka-app-google-bigquery/server run build",
+    "clean": "yarn workspaces foreach --all -pt run clean",
+    "lint": "yarn workspaces foreach --all -pt run lint",
+    "dev": "yarn workspace @seeka-app-google-bigquery/server run dev",
+    "deploy": "yarn workspace @seeka-app-google-bigquery/server run deploy",
+    "tunnel": "yarn workspace @seeka-app-google-bigquery/server run tunnel",
+    "migration:add": "yarn workspace @seeka-app-google-bigquery/server run migration:add",
+    "test:schema": "yarn workspace jsonschema-bigquery-custom run test:seeka",
+    "bump:patch": "yarn git:isclean && yarn workspaces foreach --all version patch --deferred && yarn bump:apply && yarn git:push",
+    "bump:minor": "yarn git:isclean && yarn workspaces foreach --all version minor --deferred && yarn bump:apply && yarn git:push",
+    "bump:major": "yarn git:isclean && yarn workspaces foreach --all version major --deferred && yarn bump:apply && yarn git:push",
+    "bump:apply": "yarn version apply --all",
+    "git:isclean": "bash -c 'if [ -n \"$(git status --porcelain)\" ]; then echo \"✖ Working directory not clean. Commit or stash your changes first.\"; exit 1; fi'",
+    "git:push": "git add -A && git commit -m \"v$(node -p \"require('./package.json').version\")\" && git tag -a v$(node -p \"require('./package.json').version\") -m \"chore(release): v$(node -p \"require('./package.json').version\")\""
+  },
+  "devDependencies": {
+    "azure-functions-core-tools": "^4.x"
+  },
+  "packageManager": "yarn@4.9.1"
+}

package/dist/ai-context/internal/examples/v2/google-bigquery/tsconfig.json

@@ -0,0 +1,24 @@
+{
+  "compilerOptions": {
+    "allowJs": true,
+    "skipLibCheck": true,
+    "strict": false,
+    "esModuleInterop": true,
+    "sourceMap": true,
+    "module": "CommonJS",
+    "target": "ES6",
+    "resolveJsonModule": true,
+    "isolatedModules": false,
+    "baseUrl": ".",
+    "paths": {
+      "@seeka-app-navitas/*": ["app/*/src"]
+    }
+  },
+  "references": [
+    { "path": "app/server" }
+  ],
+  "exclude": [
+    "node_modules",
+    "**/dist"
+  ]
+}

package/dist/ai-context/internal/examples/v2/klaviyo-events/.yarnrc.yml

@@ -0,0 +1,3 @@
+nodeLinker: node-modules
+                          
+nmHoistingLimits: workspaces

package/dist/ai-context/internal/examples/v2/klaviyo-events/README.md

@@ -0,0 +1 @@
+# Klaviyo events app

package/dist/ai-context/internal/examples/v2/klaviyo-events/_ai-summary.md

@@ -0,0 +1,26 @@
+# AI Summary for Klaviyo Events App
+
+## Purpose and Functionality
+The **Klaviyo Events App** is designed to integrate with Klaviyo for pushing activity events to facilitate email marketing automation. It acts as a bridge between Seeka apps and Klaviyo, enabling the automation of marketing tasks based on user activities captured by Seeka.
+
+## Key Implementation Patterns
+- **Azure Functions**: The app is structured as an Azure Function, which provides a serverless environment to handle HTTP requests, specifically webhooks from Seeka.
+- **Webhook Handling**: The app listens for various types of webhook events from Seeka, such as app installations, updates, and activity acceptance, and processes them accordingly.
+- **Logging**: Uses the `winston` library for logging, providing detailed logs for each webhook event processed.
+- **Background Jobs**: Implements a queuing system to handle certain tasks asynchronously, such as processing accepted activities.
+
+## External APIs/Services Integrated
+- **Klaviyo**: The app integrates with Klaviyo to push events for email marketing automation.
+- **Azure Functions**: Utilizes Azure's serverless computing to handle HTTP requests and execute code in response to webhook events.
+
+## Important Data Transformations
+- **Webhook Payload Processing**: The app parses and validates incoming webhook payloads, ensuring they are correctly formatted and signed before processing.
+- **Installation State Management**: Manages the state of app installations, updating or deleting records based on webhook events.
+
+## Notable Code Patterns
+- **Webhook Signature Validation**: Implements a security measure to validate the signature of incoming webhooks, ensuring that only legitimate requests are processed.
+- **Error Handling**: Utilizes try-catch blocks to handle errors gracefully, logging detailed error information and returning appropriate HTTP status codes.
+- **Modular Services**: Uses a modular approach to start services and manage installations, allowing for easy maintenance and scalability.
+- **Conditional Processing**: Differentiates between test and production webhook calls, ensuring that test data does not affect live operations.
+
+This summary provides an overview of the app's purpose, key patterns, integrations, and notable code practices, offering a comprehensive understanding for AI systems analyzing or interacting with the app.

package/dist/ai-context/internal/examples/v2/klaviyo-events/app/server/.eslintrc.cjs

@@ -0,0 +1,11 @@
+/* eslint-env node */
+module.exports = {
+    extends: ['eslint:recommended', 'plugin:@typescript-eslint/recommended'],
+    parser: '@typescript-eslint/parser',
+    plugins: ['@typescript-eslint'],
+    root: true,
+    rules: {
+        "@typescript-eslint/no-unused-vars": "warn",
+        "@typescript-eslint/no-empty-function": "warn",
+    }
+};

package/dist/ai-context/internal/examples/v2/klaviyo-events/app/server/.nvmrc

@@ -0,0 +1 @@
+20