@seeka-labs/cli-apps 3.7.0 → 3.8.2

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

@@ -0,0 +1,72 @@
+import { QueueClient } from '@azure/storage-queue';
+import type { Logger } from 'winston';
+
+export interface BackgroundJobRequestContext<TPayload> {
+    organisationId?: string;
+    organisationBrandId?: string;
+    applicationInstallId?: string;
+    causationId?: string
+    correlationId?: string
+    payload: TPayload
+}
+
+export const signatureHeaderName = 'x-signature-hmac';
+export const apiKeyHeaderName = 'x-api-key';
+
+export const queueNames = {
+    handleInboundWebhookRequest: 'webhook-request-inbound-webhook-queue',
+}
+
+export const triggerBackgroundJob = async <TPayload>(queueName: string, context: BackgroundJobRequestContext<TPayload>, 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>(payload: string): TPayload => {
+    const jsonString = Buffer.from(payload, 'base64').toString()
+    return JSON.parse(jsonString) as TPayload;
+}
+
+export const triggerBackgroundJobWithQueue = async <TPayload>(queueClient: QueueClient, context: BackgroundJobRequestContext<TPayload>, logger: Logger): Promise<void> => {
+    const body = {
+        ...context
+    }
+    const bodyStr = serialiseQueuePayload(body);
+
+    const response = await queueClient.sendMessage(bodyStr);
+
+    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 for " + queueClient.name, { body, messageId: response.messageId, context })
+    }
+}
+
+export const sendQueueMessageToPoisonQueue = async <TPayload>(queueName: string, context: BackgroundJobRequestContext<TPayload>, 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 })
+        throw new Error(`Failed to push to poison queue: ${response.errorCode}`);
+    }
+    else {
+        logger.verbose("Message pushed to poison queue", { body, messageId: response.messageId, context })
+    }
+}

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

@@ -0,0 +1,106 @@
+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<any> | 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/v2/webhook/app/server/src/lib/services/index.ts

@@ -0,0 +1,41 @@
+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/v2/webhook/app/server/src/lib/state/redis/index.ts

@@ -0,0 +1,102 @@
+import { createClient, RedisClientType } from 'redis';
+
+import * as 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 createNewClient = (): RedisClientType => {
+    const c = createClient({
+        url: redisConn,
+        disableClientInfo: true,
+
+    })
+        .on('error', (err) => logger.error('Redis Client ', { ex: winston.exceptions.getAllInfo(err) }));
+
+    return c as RedisClientType
+}
+
+const redisClient = createNewClient()
+
+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, mode: 'string' | 'json' = 'string'): Promise<TState> {
+    const fullKey = getKey(stateType, key);
+    const existingStr = await getString(redisClient, fullKey);
+    if (existingStr) return JSON.parse(existingStr);
+
+    if (mode === 'json') {
+        await redisClient.json.set(fullKey, '$', toCreate as never);
+    }
+    else {
+        await redisClient.set(fullKey, JSON.stringify(toCreate));
+    }
+
+    return toCreate;
+}
+
+export async function tryGet<TState>(stateType: string, key: string, mode: 'string' | 'json' = 'string'): Promise<TState | null> {
+    const fullKey = getKey(stateType, key);
+
+    if (mode === 'json') {
+        const existing = await redisClient.json.get(fullKey);
+        if (existing) return existing as TState;
+    }
+    else {
+        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, mode: 'string' | 'json' = 'string'): Promise<void> {
+    const fullKey = getKey(stateType, key);
+
+    if (mode === 'json') {
+        await redisClient.json.set(fullKey, '$', toCreate as never);
+    }
+    else {
+        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);
+}
+
+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/webhook/app/server/src/lib/state/seeka/installations.ts

@@ -0,0 +1,85 @@
+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: WebhookAppInstallSettings
+    // State relating to the app and installation of the app
+    installationState: WebhookAppInstallState;
+
+    // When the app was installed
+    installedAt: string; // new Date().toISOString()
+}
+
+export interface WebhookAppInstallState {
+    grantedPermissions?: string[]
+    sampleInstallationState?: string
+}
+
+export type WebhookAppInstallSettings = {
+    trackEventName?: string
+
+    trackEventNamePayloadPath?: string
+
+    profileFirstNamePayloadPath?: string
+    profileLastNamePayloadPath?: string
+    profileEmailPayloadPath?: string
+    profilePhonePayloadPath?: string
+
+    profileAddressLine1PayloadPath?: string
+    profileAddressLine2PayloadPath?: string
+    profileLocalityPayloadPath?: string
+    profileStateNamePayloadPath?: string
+    profileStateCodePayloadPath?: string
+    profileCountryNamePayloadPath?: string
+    profileCountryCodePayloadPath?: string
+
+    profileFacebookLeadIdPayloadPath?: string
+    profileExternalIdPayloadPath?: string
+    profileIdPayloadPath?: string
+    deduplicationIdPayloadPath?: 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/v2/webhook/app/server/src/lib/utils/object.ts

@@ -0,0 +1,7 @@
+import { JSONPath } from "jsonpath-plus"
+
+export const getJsonPathValue = <TResult>(obj: any, jsonPath: string | undefined | null): null | TResult => {
+    if (!obj || !jsonPath) return null
+
+    return JSONPath({ path: jsonPath, json: obj, wrap: false }) || null
+}

package/dist/ai-context/internal/examples/v2/webhook/app/server/src/lib/webhooks/index.ts

@@ -0,0 +1,171 @@
+import { Logger } from "winston";
+import { getJsonPathValue } from './../utils/object';
+import { InboundWebhookPayloadQueueItem } from "./models";
+
+import { ActivityPayload, getActivityName, PersonIdentifiers, PlaceAddress, SeekaAppHelper, TrackingActivityNames, TrackingEventSourceOriginType } from "@seeka-labs/sdk-apps-server";
+import { v4 } from "uuid";
+import * as packageJson from '../../../package.json';
+import { SeekaAppInstallState } from "../state/seeka/installations";
+
+export const handleInboundWebhook = async (item: InboundWebhookPayloadQueueItem<string>, installation: SeekaAppInstallState, logger: Logger): Promise<void> => {
+    logger.info('Handling inbound webhook queue item', { item })
+
+    // Create seeka API helper
+    const { name, version } = packageJson;
+    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, version }, installation.installationState.grantedPermissions, logger);
+
+    const inboundPayload = JSON.parse(item.payload.body)
+
+    let dedupeIdVal = getJsonPathValue<string>(inboundPayload, installation.installationSettings?.deduplicationIdPayloadPath);
+    if (dedupeIdVal && dedupeIdVal.length < 6) {
+        dedupeIdVal = `${installation.applicationInstallId}_${dedupeIdVal}`
+    }
+    if (installation.installationSettings?.deduplicationIdPayloadPath && !dedupeIdVal) {
+        logger.warn('Dedupe ID json path setting provided but no value was found in incoming webhook payload matching to the setting path')
+    }
+    if (!dedupeIdVal) {
+        dedupeIdVal = v4();
+        logger.debug('No deduplication ID found for webhook activity so generating one', { Activity_ActivityIdentifier: dedupeIdVal })
+    }
+    logger = logger.child({ Activity_ActivityIdentifier: dedupeIdVal })
+
+    let profileIdVal = getJsonPathValue<string>(inboundPayload, installation.installationSettings?.profileIdPayloadPath);
+    let profileExternalIdVal = getJsonPathValue<string>(inboundPayload, installation.installationSettings?.profileExternalIdPayloadPath);
+
+    let profileFirstNameVal = getJsonPathValue<string>(inboundPayload, installation.installationSettings?.profileFirstNamePayloadPath);
+    let profileLastNameVal = getJsonPathValue<string>(inboundPayload, installation.installationSettings?.profileLastNamePayloadPath);
+    let profileEmailVal = getJsonPathValue<string>(inboundPayload, installation.installationSettings?.profileEmailPayloadPath);
+    let profilePhoneVal = getJsonPathValue<string>(inboundPayload, installation.installationSettings?.profilePhonePayloadPath);
+    let profileFacebookLeadIdVal = getJsonPathValue<string>(inboundPayload, installation.installationSettings?.profileFacebookLeadIdPayloadPath);
+
+    const address: PlaceAddress = {};
+    const person: PersonIdentifiers = {}
+    let setPerson = false
+    let setAddress = false
+    if (profileIdVal) {
+        person.seekaPId = profileIdVal
+        setPerson = true
+    }
+    if (profileExternalIdVal) {
+        person.eid = [profileExternalIdVal]
+        setPerson = true
+    }
+    if (profileFirstNameVal) {
+        person.firstName = [profileFirstNameVal]
+        setPerson = true
+    }
+    if (profileLastNameVal) {
+        person.lastName = [profileLastNameVal]
+        setPerson = true
+    }
+    if (profileEmailVal) {
+        person.email = [profileEmailVal]
+        setPerson = true
+    }
+    if (profilePhoneVal) {
+        person.phone = [profilePhoneVal]
+        setPerson = true
+    }
+    if (profileFacebookLeadIdVal) {
+        person.facebook = { lead: [profileFacebookLeadIdVal] }
+        setPerson = true
+    }
+
+    // Address fields
+    let profileAddressLine1Val = getJsonPathValue<string>(inboundPayload, installation.installationSettings?.profileAddressLine1PayloadPath);
+    let profileAddressLine2Val = getJsonPathValue<string>(inboundPayload, installation.installationSettings?.profileAddressLine2PayloadPath);
+    let profileAddressStateNameVal = getJsonPathValue<string>(inboundPayload, installation.installationSettings?.profileStateNamePayloadPath);
+    let profileAddressStateCodeVal = getJsonPathValue<string>(inboundPayload, installation.installationSettings?.profileStateCodePayloadPath);
+    let profileAddressLocalityVal = getJsonPathValue<string>(inboundPayload, installation.installationSettings?.profileLocalityPayloadPath);
+    let profileAddressCountryNameVal = getJsonPathValue<string>(inboundPayload, installation.installationSettings?.profileCountryNamePayloadPath);
+    let profileAddressCountryCodeVal = getJsonPathValue<string>(inboundPayload, installation.installationSettings?.profileCountryCodePayloadPath);
+    if (profileAddressLine1Val) {
+        address.addressLine1 = profileAddressLine1Val
+        setAddress = true
+    }
+    if (profileAddressLine2Val) {
+        address.addressLine2 = profileAddressLine2Val
+        setAddress = true
+    }
+    if (profileAddressStateNameVal) {
+        address.state = profileAddressStateNameVal
+        setAddress = true
+    }
+    if (profileAddressStateCodeVal) {
+        address.stateCode = profileAddressStateCodeVal
+        setAddress = true
+    }
+    if (profileAddressLocalityVal) {
+        address.locality = profileAddressLocalityVal
+        setAddress = true
+    }
+    if (profileAddressCountryNameVal) {
+        address.country = profileAddressCountryNameVal
+        setAddress = true
+    }
+    if (profileAddressCountryCodeVal) {
+        address.countryCode = profileAddressCountryCodeVal
+        setAddress = true
+    }
+    if (setAddress) {
+        person.address = [address]
+        setPerson = true
+    }
+
+    let customEventName: string | undefined = undefined;
+    let activityNameInfo: TrackingActivityNames | undefined = undefined;
+    if (installation.installationSettings?.trackEventNamePayloadPath) {
+        let trackEventNameFromPayload = getJsonPathValue<string>(inboundPayload, installation.installationSettings?.trackEventNamePayloadPath);
+        if (trackEventNameFromPayload) {
+            activityNameInfo = getActivityName(trackEventNameFromPayload)
+            customEventName = activityNameInfo === TrackingActivityNames.Custom ? trackEventNameFromPayload : undefined
+        }
+    }
+    if (!activityNameInfo && installation.installationSettings?.trackEventName) {
+        activityNameInfo = getActivityName(installation.installationSettings?.trackEventName)
+        customEventName = activityNameInfo === TrackingActivityNames.Custom ? installation.installationSettings?.trackEventName : undefined
+    }
+
+    if (activityNameInfo) {
+        const activityPayload: ActivityPayload = {
+            activityName: activityNameInfo,
+            activityNameCustom: customEventName,
+            activityId: dedupeIdVal,
+        }
+        logger.info('Tracking activity for webhook', {
+            activityPayload,
+            person,
+            item
+        });
+
+        if (setPerson) {
+            await helper.api.trackActivityForProfile(activityPayload, person, {
+                origin: TrackingEventSourceOriginType.Server,
+                // loc: sourceUrl || undefined
+            })
+        }
+        else {
+            await helper.api.trackActivityForProfileId(activityPayload, profileIdVal, {
+                origin: TrackingEventSourceOriginType.Server,
+                // loc: sourceUrl || undefined
+            })
+        }
+    }
+    else if (setPerson) {
+        logger.info('Merging identity for webhook', {
+            person,
+            item
+        });
+        await helper.api.mergeIdentity(person, {
+            origin: TrackingEventSourceOriginType.Server,
+            // loc: sourceUrl || undefined
+        })
+    }
+    else {
+        logger.warn("Not handling webhook as activity to track not set and no identifiers in request payload")
+    }
+}

package/dist/ai-context/internal/examples/v2/webhook/app/server/src/lib/webhooks/models/index.ts

@@ -0,0 +1,9 @@
+import { BackgroundJobRequestContext } from "../../jobs"
+
+export interface InboundWebhookPayloadQueueItem<TPayloadObject> extends BackgroundJobRequestContext<InboundWebhookPayload<TPayloadObject>> {
+
+}
+
+export interface InboundWebhookPayload<TObject> {
+    body: TObject
+}

package/dist/ai-context/internal/examples/v2/webhook/app/server/tsconfig.json

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

package/dist/ai-context/internal/examples/v2/webhook/app/ui/README.md

@@ -0,0 +1,40 @@
+# Material UI - Create React App example in TypeScript
+
+## How to use
+
+Download the example [or clone the repo](https://github.com/mui/material-ui):
+
+<!-- #default-branch-switch -->
+
+```bash
+curl https://codeload.github.com/mui/material-ui/tar.gz/master | tar -xz --strip=2 material-ui-master/examples/material-ui-cra-ts
+cd material-ui-cra-ts
+```
+
+Install it and run:
+
+```bash
+npm install
+npm start
+```
+
+or:
+
+<!-- #default-branch-switch -->
+
+[![Edit on CodeSandbox](https://codesandbox.io/static/img/play-codesandbox.svg)](https://codesandbox.io/p/sandbox/github/mui/material-ui/tree/master/examples/material-ui-cra-ts)
+
+[![Edit on StackBlitz](https://developer.stackblitz.com/img/open_in_stackblitz.svg)](https://stackblitz.com/github/mui/material-ui/tree/master/examples/material-ui-cra-ts)
+
+## The idea behind the example
+
+This example demonstrates how you can use Material UI with [Create React App](https://github.com/facebookincubator/create-react-app) in [TypeScript](https://github.com/Microsoft/TypeScript).
+It includes `@mui/material` and its peer dependencies, including [Emotion](https://emotion.sh/docs/introduction), the default style engine in Material UI v6.
+If you prefer, you can [use styled-components instead](https://mui.com/material-ui/integrations/interoperability/#styled-components).
+
+## What's next?
+
+<!-- #default-branch-switch -->
+
+You now have a working example project.
+You can head back to the documentation and continue by browsing the [templates](https://mui.com/material-ui/getting-started/templates/) section.