@seeka-labs/cli-apps 3.8.8 → 3.8.10

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

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

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

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

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

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

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

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

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

@@ -1,18 +0,0 @@
-{
-  "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

@@ -1,28 +0,0 @@
-{
-  "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

@@ -1,24 +0,0 @@
-{
-  "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

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

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

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

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

@@ -1,37 +0,0 @@
-# AI Summary for Klaviyo Events App
-
-## Overview
-
-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 and Klaviyo, handling various webhook events to manage app installations and activity tracking.
-
-## Key Implementation Patterns
-
-1. **Azure Functions**: The app is structured using Azure Functions, providing a serverless architecture that handles HTTP requests for webhooks.
-2. **Webhook Handling**: The app listens for various webhook events from Seeka, such as app installation, uninstallation, and activity acceptance.
-3. **Logging**: Utilizes `winston` for comprehensive logging, including profiling and verbosity levels to track webhook processing.
-4. **State Management**: Manages app installation state using functions like `createOrUpdateInstallation` and `deleteInstallation`.
-5. **Background Jobs**: Implements background job processing for certain activities using a queue system.
-
-## External APIs/Services Integrated
-
-- **Klaviyo**: The app integrates with Klaviyo to push activity events for email marketing.
-- **Azure Functions**: Utilizes Azure's serverless computing to handle HTTP requests and process webhooks.
-
-## Important Data Transformations
-
-- **Webhook Payload Parsing**: The app parses incoming webhook payloads to determine the type of event and processes them accordingly.
-- **Activity Filtering**: Filters activities based on their type (e.g., `TrackingActivityNames.ViewPage`) and queues relevant activities for further processing.
-
-## Notable Code Patterns
-
-- **Webhook Signature Validation**: Implements a security measure to validate webhook signatures using a secret key (`throwOnInvalidWebhookSignature`).
-- **Dynamic Logging**: Uses a child logger pattern to enhance logging with additional context, such as installation information.
-- **Error Handling**: Comprehensive error handling with appropriate HTTP status responses (e.g., 401 for invalid signatures, 422 for unknown installations).
-
-## Reusable Patterns
-
-- **Webhook Signature Validation**: The pattern for validating webhook signatures can be reused in other applications requiring secure webhook processing.
-- **Background Job Triggering**: The method of queuing background jobs for asynchronous processing is a reusable pattern for handling tasks that do not need immediate processing.
-- **State Management**: Functions for managing installation states can be adapted for other applications requiring similar state management logic.
-
-This summary provides a concise understanding of the Klaviyo Events App's purpose, key patterns, integrations, and notable implementations, aiding AI in referencing and utilizing this app's architecture and design.

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

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

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