@seeka-labs/cli-apps 3.8.7 → 3.8.10

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

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

@@ -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<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

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

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

@@ -1,85 +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: 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

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

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

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

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

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