@seeka-labs/cli-apps 3.7.0 → 3.8.2

package/dist/ai-context/internal/examples/v1/me-and-u-manage/src/lib/me-and-u/index.ts

@@ -0,0 +1,96 @@
+import winston, { Logger } from 'winston';
+import { MeAndUManageApiRegion, MeAndUManageInstallSettings } from '../state/seeka/installations'
+
+import fetch from 'isomorphic-unfetch'
+import { getMeAndUOrders } from './orders';
+import { PersonIdentifiers, separatePersonFullName } from '@seeka-labs/sdk-apps-server';
+
+const apiEndpoints = {
+    [MeAndUManageApiRegion.AP]: 'https://ap1-stable-api.mryum.com/graphql',
+    [MeAndUManageApiRegion.EU]: 'https://eu1-stable-api.mryum.com/graphql',
+    [MeAndUManageApiRegion.US]: 'https://us1-stable-api.mryum.com/graphql',
+}
+
+export async function makeMeAndUGraphQlRequest<TResponse>(installationSettings: MeAndUManageInstallSettings, query: string, variables: unknown): Promise<{ errors: unknown, data: TResponse }> {
+    const endpoint = apiEndpoints[MeAndUManageApiRegion[installationSettings.connection?.meAndUApiRegion || MeAndUManageApiRegion.AP]];
+
+    const body = JSON.stringify({ query, variables });
+
+    const response = await fetch(endpoint, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            authorization: `Bearer ${installationSettings.connection?.meAndUAccessToken}`,
+        },
+        body: body,
+    })
+
+    // TODO: Add retry for network errors and rate limiting
+
+    const text = await response.text();
+
+    return JSON.parse(text);
+}
+
+export async function validateApiConnection(installationSettings: MeAndUManageInstallSettings, logger: Logger): Promise<string | null> {
+    // Check access token
+    if (await getMeAndUOrganisation(installationSettings, logger) == null) return 'Invalid access token';
+
+    const orders = await getMeAndUOrders(installationSettings, { first: 1 }, logger);
+    if (orders === null) return 'Access token does not have access to the orders API';
+
+    return null
+}
+
+export async function getMeAndUOrganisation(installationSettings: MeAndUManageInstallSettings, logger: Logger): Promise<MeAndUOrganisation | null> {
+    try {
+        const response = await makeMeAndUGraphQlRequest<MeAndUOrganisationResponse>(
+            installationSettings,
+            `query {
+                organization {
+                    id
+                    name
+                }
+            }`,
+            {}
+        );
+
+        if (response.errors) {
+            logger.error('Error fetching MeAndU organization', { errors: response.errors });
+            return null;
+        }
+
+        return response.data?.organization;
+    }
+    catch (err) {
+        // TODO: Add error handling
+        logger.error('Error making request to fetch MeAndU organization', { ex: winston.exceptions.getAllInfo(err) });
+        return null
+    }
+}
+
+export interface MeAndUOrganisationResponse {
+    organization: MeAndUOrganisation
+}
+
+export interface MeAndUOrganisation {
+    id: string;
+    name: string;
+}
+
+export interface MeAndUGuest {
+    email: string;
+    id?: string;
+    mobile: string;
+    name: string;
+}
+
+export const meAndUGuestToSeekaPerson = (meAndUGuest: MeAndUGuest): PersonIdentifiers => {
+    const fullName = separatePersonFullName(meAndUGuest.name);
+    return {
+        email: meAndUGuest.email ? [meAndUGuest.email.replace(/'/g, '')] : [],
+        phone: [meAndUGuest.mobile],
+        firstName: [fullName.firstName],
+        lastName: [fullName.lastName]
+    }
+}

package/dist/ai-context/internal/examples/v1/me-and-u-manage/src/lib/me-and-u/menus/index.ts

@@ -0,0 +1,125 @@
+import winston, { Logger } from "winston";
+import { MeAndUManageInstallSettings, SeekaAppInstallState } from "../../state/seeka/installations";
+import { makeMeAndUGraphQlRequest } from "..";
+
+type GetMeAndUMenusVariables = {
+    first?: number;
+    after?: string;
+    sort?: {
+        sortKey: "CREATED_AT" | string
+        direction: "ASC" | "DESC"
+    };
+}
+
+const getMeAndUMenus = async (installationSettings: MeAndUManageInstallSettings, variables: GetMeAndUMenusVariables, logger: Logger): Promise<MeAndUMenusResponse | null> => {
+    try {
+        const response = await makeMeAndUGraphQlRequest<MeAndUMenusResponse>(
+            installationSettings,
+            `query menus ($first: Int, $after: String, $sort: MenuSortArg) {
+                    menus (first: $first, after: $after, sort: $sort) {
+                        edges {
+                            node {
+                                id
+                                name
+                                slug
+                                createdAt
+                            }
+                        }
+                        pageInfo {
+                            endCursor
+                            hasNextPage
+                        }
+                    }
+                }`,
+            variables
+        );
+
+        if (response.errors) {
+            logger.error('Error fetching MeAndU menus', { errors: response.errors });
+            return null;
+        }
+
+        return response.data;
+    }
+    catch (err) {
+        // TODO: Add error handling
+        logger.error('Error making request to fetch MeAndU menus', { ex: winston.exceptions.getAllInfo(err) });
+        return null
+    }
+}
+
+export const findMeAndUMenuBySlug = async (installationSettings: MeAndUManageInstallSettings, slug: string, logger: Logger): Promise<{ menu: MeAndUMenu | null, errorMessage?: string }> => {
+    if (!slug) {
+        return { menu: null, errorMessage: `No venue slug provided` };
+    }
+    const foundMenus: MeAndUMenu[] = [];
+    const lowerSlug = slug.toLowerCase();
+    await getAllMeAndUMenus(installationSettings, null, async (page) => {
+        const menu = page.menus.find(e => e.slug?.toLowerCase() === lowerSlug);
+        if (menu) {
+            foundMenus.push(menu);
+        }
+    }, logger);
+
+    if (foundMenus.length === 0) return { menu: null, errorMessage: `No menu found with slug ${slug}` };
+    if (foundMenus.length > 1) return { menu: null, errorMessage: `Multiple menus found with slug ${slug}` };
+
+    return { menu: foundMenus[0] };
+}
+
+export const getAllMeAndUMenus = async (installationSettings: MeAndUManageInstallSettings, afterPageCursor: string | null, handlePage: (page: { menus: MeAndUMenu[], lastCursor: string, lastCreationDate: string }) => Promise<void>, logger: Logger): Promise<void> => {
+    const pageSize = 25;
+    let cursor = afterPageCursor ? afterPageCursor : null
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        const response = await getMeAndUMenus(installationSettings, {
+            first: pageSize,
+            after: cursor,
+            sort: {
+                sortKey: "CREATED_AT",
+                direction: "ASC"
+            }
+        }, logger);
+        if (response != null) {
+            if (response.menus.edges.length === 0) {
+                break;
+            }
+            await handlePage({
+                menus: [...response.menus.edges.map(edge => edge.node)],
+                lastCursor: response.menus.pageInfo.endCursor,
+                lastCreationDate: response.menus.edges[response.menus.edges.length - 1].node.createdAt
+            })
+
+            cursor = response.menus.pageInfo.endCursor;
+            if (!response.menus.pageInfo.hasNextPage) {
+                break;
+            }
+        }
+        else {
+            // Errored
+            logger.error('Error fetching all MeAndU menus - response was null');
+            break;
+        }
+    }
+}
+
+
+export interface MeAndUMenusResponse {
+    menus: {
+        edges: {
+            node: MeAndUMenu
+        }[]
+        pageInfo: {
+            endCursor: string;
+            hasNextPage: boolean;
+        }
+    }
+
+}
+
+export interface MeAndUMenu {
+    id: string;
+    name: string;
+    slug: string;
+    createdAt: string;
+}

package/dist/ai-context/internal/examples/v1/me-and-u-manage/src/lib/me-and-u/orders/index.ts

@@ -0,0 +1,264 @@
+import winston, { Logger } from "winston";
+import { MeAndUManageInstallSettings, SeekaAppInstallState, createOrUpdateInstallation } from "../../state/seeka/installations";
+import { MeAndUGuest, makeMeAndUGraphQlRequest, meAndUGuestToSeekaPerson } from "..";
+import { ActivityPayload, CommerceActivityTrackingEventMetadata, CommerceActivityTrackingEventProductMetadata, ECommerceContentType, PersonIdentifiers, SeekaAppHelper, TrackingActivityNames, TrackingEventSourceOriginType } from "@seeka-labs/sdk-apps-server";
+
+import * as packageJson from '../../../../package.json';
+
+type GetMeAndUOrdersVariables = {
+    first?: number;
+    after?: string;
+    sort?: {
+        sortKey: "CREATED_AT" | string
+        direction: "ASC" | "DESC"
+    };
+    filter?: {
+        createdAt: {
+            gt?: string; // Format "2024-02-20T05:30:05.464Z"
+        },
+        menu: {
+            equals: string
+        }
+    };
+}
+
+const fireSeekaOrderEvents = async (installation: SeekaAppInstallState, batch: { activity: ActivityPayload, profile: PersonIdentifiers }[], logger: Logger): Promise<void> => {
+    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: packageJson.name, version: packageJson.version }, installation.installationState.grantedPermissions, logger);
+
+    await helper.api.trackActivityBatch(batch, {
+        origin: TrackingEventSourceOriginType.PhysicalStore
+    })
+}
+
+export const handleMeAndUOrderPage = async (installation: SeekaAppInstallState, page: { orders: MeAndUOrder[], lastCursor: string, lastCreationDate: string }, logger: Logger): Promise<void> => {
+    logger.debug('Processing MeAndU order page', { installationId: installation.applicationInstallId, count: page.orders.length });
+
+    // Filter orders
+    const filteredMeAndUOrders = page.orders.filter(e => e.status === 'COMPLETED')
+        .map(e => {
+            return {
+                ...e,
+                lineItems: (e.lineItems || []).filter(e => e.kind === 'AFFIRMATION' && ['MENU_ITEM', 'UPSELL_ITEM', 'VIRTUAL_ITEM', 'SPECIAL_ITEM', 'COMBO_ITEM'].includes(e.type))
+            }
+        })
+        .filter(e => e.lineItems.length > 0);
+    logger.debug('Processing MeAndU filtered orders', { installationId: installation.applicationInstallId, count: filteredMeAndUOrders.length });
+
+    // Transform orders to Seeka orders
+    const seekaOrders = filteredMeAndUOrders.map(e => meAndUOrderToSeekaOrderActivity(e, installation)).filter(e => Boolean(e));
+
+    // Fire off Seeka events
+    if (seekaOrders.length > 0) {
+        logger.verbose('Firing off Seeka order events', { installationId: installation.applicationInstallId, count: seekaOrders.length });
+        await fireSeekaOrderEvents(installation, seekaOrders, logger);
+    }
+    else {
+        logger.verbose('No Seeka order events to fire', { installationId: installation.applicationInstallId });
+    }
+
+    // Update state
+    await createOrUpdateInstallation({
+        ...installation,
+        installationState: {
+            ...installation.installationState,
+            ordersRetrievedUpToCreationDate: page.lastCreationDate ? page.lastCreationDate : installation.installationState.ordersRetrievedUpToCreationDate
+        }
+    }, logger);
+}
+
+export const getMeAndUOrders = async (installationSettings: MeAndUManageInstallSettings, variables: GetMeAndUOrdersVariables, logger: Logger): Promise<MeAndUOrderResponse | null> => {
+    try {
+        const response = await makeMeAndUGraphQlRequest<MeAndUOrderResponse>(
+            installationSettings,
+            `query orders ($first: Int, $after: String, $sort: OrderSortArgs, $filter: OrderFilter) {
+                    orders (first: $first, after: $after, sort: $sort, filter: $filter) {
+                        edges {
+                            node {
+                                createdAt
+                                currency
+                                guest {
+                                    email
+                                    id
+                                    mobile
+                                    name
+                                }
+                                id
+                                lineItems {
+                                    externalPosId
+                                    externalPosGroupId 
+                                    category
+                                    kind #must be AFFIRMATION
+                                    name
+                                    priceInCents
+                                    quantity
+                                    type # must be MENU_ITEM OR UPSELL_ITEM OR VIRTUAL_ITEM OR SPECIAL_ITEM OR COMBO_ITEM
+                                }
+                                paymentProcessor
+                                paymentTransactionId
+                                status # must be COMPLETED
+                                totalInCents
+                                totalTaxInCents
+                            }
+                        }
+                        pageInfo {
+                            endCursor
+                            hasNextPage
+                        }
+                    }
+                }`,
+            variables
+        );
+
+        if (response.errors) {
+            logger.error('Error fetching MeAndU orders', { errors: response.errors, variables });
+            return null;
+        }
+
+        return response.data;
+    }
+    catch (err) {
+        // TODO: Add error handling
+        logger.error('Error making request to fetch MeAndU orders', { ex: winston.exceptions.getAllInfo(err) });
+        return null
+    }
+}
+
+export const getAllMeAndUOrders = async (installation: SeekaAppInstallState, handlePage: (page: { orders: MeAndUOrder[], lastCursor: string, lastCreationDate: string }) => Promise<void>, logger: Logger): Promise<void> => {
+    // Small page size to work within query cost limits - https://stable-api-docs.mryum.com/docs/overview/usage
+    const pageSize = 10;
+    let cursor: string | null = null
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        const response = await getMeAndUOrders(installation.installationSettings, {
+            first: pageSize,
+            after: cursor,
+            sort: {
+                sortKey: "CREATED_AT",
+                direction: "ASC"
+            },
+            filter: {
+                createdAt: {
+                    gt: installation.installationState.ordersRetrievedUpToCreationDate || installation.installedAt
+                },
+                menu: {
+                    equals: installation.installationState.meAndUMenuId
+                }
+            }
+        }, logger);
+        if (response != null) {
+            if (response.orders.edges.length === 0) {
+                break;
+            }
+            await handlePage({
+                orders: [...response.orders.edges.map(edge => edge.node)],
+                lastCursor: response.orders.pageInfo.endCursor,
+                lastCreationDate: response.orders.edges[response.orders.edges.length - 1].node.createdAt
+            })
+
+            cursor = response.orders.pageInfo.endCursor;
+            if (!response.orders.pageInfo.hasNextPage) {
+                break;
+            }
+        }
+        else {
+            // Errored
+            logger.error('Error fetching all MeAndU orders - response was null');
+            break;
+        }
+    }
+}
+
+export const meAndUOrderToSeekaOrderActivity = (meAndUOrder: MeAndUOrder, installation: SeekaAppInstallState): { activity: ActivityPayload, profile: PersonIdentifiers } => {
+    return {
+        activity: {
+            activityId: 'meandu_order_' + meAndUOrder.id,
+            activityName: TrackingActivityNames.Order,
+            activityNameCustom: 'MeAndUOrder',
+            commerce: meAndUOrderToSeekaOrder(meAndUOrder, installation),
+            time: new Date(meAndUOrder.createdAt)
+        },
+        profile: meAndUGuestToSeekaPerson(meAndUOrder.guest)
+    }
+}
+
+export const meAndUOrderToSeekaOrder = (meAndUOrder: MeAndUOrder, installation: SeekaAppInstallState): CommerceActivityTrackingEventMetadata => {
+    return {
+        orderIdentifier: meAndUOrder.id,
+        paymentMethodName: meAndUOrder.paymentProcessor,
+        customerIdentifier: meAndUOrder.guest.id,
+        sourceChannelName: 'MeAndU',
+        currencyCode: meAndUOrder.currency,
+        totalPrice: meAndUOrder.totalInCents / 100,
+        totalTax: meAndUOrder.totalTaxInCents / 100,
+        products: meAndUOrder.lineItems.map(lineItem => meAndULineItemToSeekaProduct(lineItem, installation))
+    }
+}
+
+const meAndULineItemToSeekaProduct = (lineItem: MeAndUOrderLineItem, installation: SeekaAppInstallState): CommerceActivityTrackingEventProductMetadata => {
+    const product: CommerceActivityTrackingEventProductMetadata = {
+        productIdentifier: lineItem.externalPosGroupId ? lineItem.externalPosGroupId : lineItem.externalPosId,
+        variantIdentifier: lineItem.externalPosGroupId ? lineItem.externalPosId : undefined,
+        productName: lineItem.name,
+        categoryName: lineItem.category,
+        unitPrice: lineItem.priceInCents / 100,
+        type: ECommerceContentType.SingleProduct,
+        quantity: lineItem.quantity,
+        attributes: {}
+    }
+
+    // Process tag mappers
+    const mappers = installation.installationSettings?.menuItemToTagMappers || [];
+    if (mappers.length > 0) {
+        for (const mapper of mappers) {
+            if (lineItem.name && mapper.menuItemNames && mapper.menuItemNames.length > 0 && mapper.mappedToTagName) {
+                if (mapper.menuItemNames.find(e => lineItem.name.toLowerCase().indexOf(e.toLowerCase()) > -1)) {
+                    product.attributes['tag'] = mapper.mappedToTagName;
+                    break;
+                }
+            }
+        }
+    }
+
+    return product;
+}
+
+export interface MeAndUOrderResponse {
+    orders: {
+        edges: {
+            node: MeAndUOrder
+        }[]
+        pageInfo: {
+            endCursor: string;
+            hasNextPage: boolean;
+        }
+    }
+
+}
+
+export interface MeAndUOrder {
+    createdAt: string;
+    currency: string;
+    guest: MeAndUGuest;
+    id: string;
+    lineItems: MeAndUOrderLineItem[];
+    paymentProcessor: string;
+    paymentTransactionId: string;
+    status: 'COMPLETED' | string;
+    totalInCents: number;
+    totalTaxInCents: number;
+}
+
+export interface MeAndUOrderLineItem {
+    externalPosId?: string
+    externalPosGroupId?: string
+    category: string;
+    kind: 'AFFIRMATION' | string;
+    name: string;
+    priceInCents: number;
+    quantity: number;
+    type: 'MENU_ITEM' | 'UPSELL_ITEM' | 'VIRTUAL_ITEM' | 'SPECIAL_ITEM' | 'COMBO_ITEM' | string;
+}

package/dist/ai-context/internal/examples/v1/me-and-u-manage/src/lib/services/index.ts

@@ -0,0 +1,41 @@
+import { connect, disconnect, isConnected } from "../state/redis";
+import winston, { Logger } from "winston";
+import "isomorphic-unfetch";
+
+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.info(`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.info(`Redis disconnected - ${process.env.REDIS_CONNECTION_HOST}`)
+        }
+    }
+    catch (err) {
+        logger.error(`Failed to disconnect from Redis - ${process.env.REDIS_CONNECTION_HOST}`, { ex: winston.exceptions.getAllInfo(err) })
+        throw err;
+    }
+}

package/dist/ai-context/internal/examples/v1/me-and-u-manage/src/lib/state/redis/index.ts

@@ -0,0 +1,65 @@
+import { createClient } from 'redis';
+
+import { logger } from '../../logging';
+import winston from 'winston';
+
+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}`;
+
+const redisClient = createClient({
+    url: redisConn
+})
+    .on('error', err => logger.error('Redis Client ', { ex: winston.exceptions.getAllInfo(err) }));
+
+export const connect = async () => {
+    await redisClient.connect();
+}
+
+export const isConnected = () => {
+    return redisClient.isOpen;
+}
+
+export const disconnect = async () => {
+    await redisClient.disconnect();
+}
+
+const getKeyPrefix = (stateType: string) => `seeka:app:${process.env.SEEKA_APP_ID}:${stateType}`
+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 redisClient.get(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 redisClient.get(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 remove(stateType: string, key: string): Promise<void> {
+    const fullKey = getKey(stateType, key);
+    await redisClient.del(fullKey);
+}

package/dist/ai-context/internal/examples/v1/me-and-u-manage/src/lib/state/seeka/installations.ts

@@ -0,0 +1,78 @@
+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: MeAndUManageInstallSettings;
+    // State relating to the app and installation of the app
+    installationState: MeAndUManageInstallState;
+
+    // When the app was installed
+    installedAt: string;
+}
+
+export interface MeAndUManageInstallState {
+    marketingOptInsRetrievedUpToCreationDate?: string
+    ordersRetrievedUpToCreationDate?: string
+    grantedPermissions?: string[]
+    meAndUMenuId?: string
+}
+
+export enum MeAndUManageApiRegion { 'AP', 'EU', 'US' }
+
+export interface MeAndUManageInstallSettings {
+    connection?: {
+        meAndUAccessToken?: string,
+        meAndUVenueSlug?: string,
+        meAndUApiRegion?: MeAndUManageApiRegion
+    }
+    menuItemToTagMappers?: MeAndUManageMenuItemToTagMapper[]
+}
+
+export interface MeAndUManageMenuItemToTagMapper {
+    menuItemNames: string[]
+    mappedToTagName: 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/v1/me-and-u-manage/tsconfig.json

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