@seeka-labs/cli-apps 3.7.0 → 3.8.2

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

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

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

@@ -0,0 +1,64 @@
+import { createClient } from 'redis';
+
+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}`;
+
+const redisClient = createClient({
+    url: redisConn
+})
+    .on('error', err => logger.error('Redis Client ', { error: 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-connect/src/lib/state/seeka/installations.ts

@@ -0,0 +1,61 @@
+import type { Logger } from 'winston';
+
+import { getList, remove, set, tryGet } from '../../state/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: { [key: string]: string | number | undefined; };
+    // State relating to the app and installation of the app
+    installationState: MeAndUAppInstallState;
+
+    // When the app was installed
+    installedAt: string; // new Date().toISOString()
+}
+
+export interface MeAndUAppInstallState {
+    seekaPersonIdMeAndUFieldId?: string
+    meAndUContactSyncUpToLastCreated?: string
+    grantedPermissions?: 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-connect/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"
+  ]
+}

package/dist/ai-context/internal/examples/v1/me-and-u-manage/.eslintrc.cjs

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

package/dist/ai-context/internal/examples/v1/me-and-u-manage/.nvmrc

@@ -0,0 +1 @@
+v20

package/dist/ai-context/internal/examples/v1/me-and-u-manage/README.md

@@ -0,0 +1,134 @@
+# Seeka app - Me&u - connect / CRM
+
+## What this app does (customer‑facing overview)
+
+This Seeka app connects your Me&u venue to Seeka so your customer data and activity stay in sync automatically. Once installed and configured, the app runs in the background and keeps your CRM up to date without any manual effort.
+
+Key features
+
+- Automatic order sync
+  - Regularly imports new and updated Me&u orders for your venue and makes them available for CRM workflows and reporting in Seeka.
+  - Runs on a schedule in the background (approximately every 15 minutes) and can also be triggered during installation for an initial backfill.
+  - Reliable processing with retries and safe handling for transient errors to help prevent data loss.
+  
+- Marketing consent sync
+  - Retrieves Me&u marketing opt‑ins and updates customer preferences in Seeka so your audience lists stay compliant and current.
+  - Runs on the same background schedule alongside order sync.
+
+- Simple installation and configuration
+  - Install from Seeka, provide your Me&u Access Token and Venue Slug, and the app verifies your connection automatically.
+  - The app detects your venue’s active menu so it can precisely scope the data it syncs.
+
+What gets synced
+
+- Orders: New and updated Me&u orders are ingested and prepared for use in Seeka (e.g., activities, segments, or automations).
+- Marketing opt‑ins: Customer marketing consent collected via Me&u is kept aligned with Seeka contact preferences.
+
+How it works
+
+1. Install the app from Seeka and enter:
+   - Me&u Access Token
+   - Me&u Venue Slug
+2. The app validates your details and connects your venue.
+
+### Credentials required from Me&u (what to ask your account manager)
+
+To enable this app, you will need the following from your Me&u account manager:
+
+- Me&u API access token (Bearer) for the Stable GraphQL API
+  - Must allow read access for: menus, orders, and marketing opt‑ins for your venue/organisation.
+  - This token is supplied to Seeka as the “Me&u Access Token”. It is sent in the HTTP header as: Authorization: Bearer <token>.
+- Region of your Me&u account: AP, EU, or US
+  - The token should be valid for the appropriate regional Stable API endpoint (ap1/eu1/us1).
+- Your venue slug
+  - The app uses your venue/menu slug to scope syncing precisely to your active menu.
+
+Recommended request to send to your Me&u account manager
+
+“Please provide a Stable GraphQL API access token (Bearer) for our venue that grants read access to Menus, Orders, and Marketing Opt‑ins, in the <AP|EU|US> region. Also confirm our venue/menu slug.”
+
+Notes
+
+- The app only requires read‑level access for the endpoints listed above; no write access is needed.
+- If you operate across multiple venues, ensure the token covers the venues you intend to sync, or request separate tokens as needed.
+
+## Development
+
+- See [Configure your environment](https://learn.microsoft.com/en-us/azure/azure-functions/create-first-function-vs-code-typescript?pivots=nodejs-model-v4#configure-your-environment) for dependencies
+- For emulating Azure storage queues, blobs and tables: `docker run --name azurite -p 10000:10000 -p 10001:10001 -p 10002:10002 --detach mcr.microsoft.com/azure-storage/azurite`
+- Set `AzureWebJobsStorage` setting in local.settings.json to `UseDevelopmentStorage=true`
+    - If not using WSL: 
+    `UseDevelopmentStorage=true`
+    - If using WSL: Ensure to replace DAN-LAPTOP with your hostname. Below connection string allows running Azurite on your host machine and lets WSL connect to it
+    `DefaultEndpointsProtocol=http;AccountName=devstoreaccount1;AccountKey=Eby8vdM02xNOcqFlqUwJPLlmEtlCDXJ1OUzFT50uSRZ6IFsuFq2UVErCz4I6tq/K1SZFPTOtr/KBHBeksoGMGw==;BlobEndpoint=http://DAN-LAPTOP.local:10000/devstoreaccount1;QueueEndpoint=http://DAN-LAPTOP.local:10001/devstoreaccount1;TableEndpoint=http://DAN-LAPTOP.local:10002/devstoreaccount1;`
+- Install Azure Storage explorer and create your queues (see `./src/lib/jobs/index.ts` for `queueNames`). Azure Storage explorer can be used to view your queue items.
+- `yarn install`
+- `yarn start`
+
+### Debugging
+Supports VSCode debugging via the debugger and utilisation of breakpoints. 
+This is only tested on Linux but may work on Windows. 
+If using Windows then use WSL with an Ubuntu distro for support of attaching the VS code debugger
+
+#### Live urls
+You can expose your app locally to the internet via Ngrok to test your app before deploying.
+
+##### Setup
+1. Sign up for a Ngrok account
+2. Get your auth token
+3. `yarn ngrok config add-authtoken [auth token here]` replacing `[auth token]` with the auth token retrieved from your Ngrok dashboard
+
+##### Running
+1. `yarn start` OR start debugging in VSCode
+2. In separate terminal window run `yarn tunnel` and observe the log entry that starts with `Live url exposed` for your Seeka app webhook URL that you can place in your Seeka app configuration.
+
+#### Invoking functions
+##### Development environment
+Scheduled / timer function: `curl -i -d '{"input": null}' -H "Content-Type: application/json" -X POST http://localhost:7072/admin/functions/pollForNewMeAndUData`
+
+##### Azure cloud
+Scheduled / timer function: `curl -i -d '{"input": null}' -H "Content-Type: application/json" -H "x-functions-key: <key from azure portal>" -X POST https://seeka-app-meandu-manage.azurewebsites.net/admin/functions/pollForNewMeAndUData`
+
+See [this doc](https://learn.microsoft.com/en-us/azure/azure-functions/functions-manually-run-non-http?tabs=azure-portal#get-the-master-key) on how to get the functions (master) key
+
+#### Sample functions
+##### Seeka app webhook 
+`src/functions/seekaAppWebhook.ts`
+TODO
+
+##### Queue example 
+`src/functions/processNewMeAndUOrders.ts`
+TODO
+
+##### Polling example 
+`src/functions/pollForNewMeAndUData.ts`
+TODO
+
+### Logging
+
+Winston included - TODO
+Seq included - TODO
+
+## Deployment
+This project comes ready to deploy for free to Azure functions with database backed by Redis hosted by Upstash and queues, blobs and tables backed by Azure Storage.
+
+At the point of writing, Netlify and Upstash can be used to deploy your app for free.
+- https://upstash.com/pricing
+- https://www.netlify.com/pricing/
+
+### Gitlab
+TODO
+
+### Azure Function deploy
+- `yarn deploy`
+
+## State management
+Installations and other state is stored in Redis. Another state provider can be used, see `src/lib/state/seeka/installations.ts` for the file that manages the state of the installations.
+
+### Upstash (optional)
+If you dont want to use Upstash for Redis then swap out the connection strings with your Redis instance. 
+- When choosing region - use US East (Ohio) - us-east-* as this is the same Azure region that the Azure functions run from
+
+## References
+- https://learn.microsoft.com/en-us/azure/storage/common/storage-use-azurite
+- https://learn.microsoft.com/en-us/azure/storage/queues/storage-quickstart-queues-nodejs?tabs=connection-string%2Croles-azure-portal%2Cenvironment-variable-windows%2Csign-in-azure-cli

package/dist/ai-context/internal/examples/v1/me-and-u-manage/_ai-summary.md

@@ -0,0 +1,47 @@
+# AI Summary for Seeka App: Me&u Manage
+
+## Overview
+
+**App Name:** Me&u Manage  
+**Purpose:** The Me&u Manage app integrates Me&u venue management with Seeka for seamless order tracking and CRM synchronization. It automates the syncing of orders and marketing consents from Me&u to Seeka, ensuring that customer data and preferences are up-to-date without manual intervention.
+
+## Key Functionality
+
+- **Order Syncing:** Regularly imports new and updated orders from Me&u to Seeka for CRM workflows and reporting.
+- **Marketing Consent Syncing:** Updates customer marketing preferences in Seeka based on Me&u opt-ins.
+- **Automated Background Processing:** Operates on a schedule (every 15 minutes) and supports initial data backfill during installation.
+- **Simple Setup:** Requires Me&u API access token and venue slug for configuration.
+
+## Key Implementation Patterns
+
+- **Azure Functions:** Utilizes Azure Functions for serverless execution of background jobs and webhooks.
+- **Queue Processing:** Employs Azure Storage Queues to handle order and marketing consent processing asynchronously.
+- **Webhook Handling:** Processes webhooks for installation, updates, and uninstallation events.
+- **Scheduled Jobs:** Uses a timer-triggered function to poll for new data and enqueue processing jobs.
+
+## External APIs/Services Integrated
+
+- **Me&u API:** Connects to Me&u's Stable GraphQL API to fetch orders and marketing opt-ins.
+- **Azure Storage:** Uses Azure Storage Queues for managing background job processing.
+- **Ngrok:** Facilitates local development by exposing the app to the internet for testing.
+
+## Important Data Transformations
+
+- **Order and Consent Grouping:** Orders and marketing consents are grouped by `applicationInstallId` for batch processing.
+- **Payload Deserialization:** Queue payloads are deserialized to extract relevant data for processing.
+- **Error Handling and Retries:** Implements retries and error logging to handle transient errors and prevent data loss.
+
+## Notable Code Patterns
+
+- **Webhook Signature Validation:** Ensures webhook authenticity by validating signatures.
+- **Background Job Triggering:** Uses a combination of Azure Functions and Storage Queues to trigger and manage background jobs efficiently.
+- **Logging and Profiling:** Utilizes Winston for structured logging and profiling of function execution.
+- **Environment Configuration:** Supports local development with Docker and Azurite for emulating Azure services.
+
+## Development and Debugging
+
+- **Local Development:** Supports local development with Docker for Azure services emulation and Ngrok for exposing local endpoints.
+- **VSCode Debugging:** Provides support for debugging with breakpoints in VSCode, primarily tested on Linux.
+- **Environment Setup:** Detailed instructions for setting up the development environment, including Azure Storage Explorer for queue management.
+
+This summary provides a comprehensive understanding of the Me&u Manage app's purpose, implementation, and integration patterns, assisting AI in referencing and utilizing this app effectively.

package/dist/ai-context/internal/examples/v1/me-and-u-manage/host.json

@@ -0,0 +1,20 @@
+{
+  "version": "2.0",
+  "logging": {
+    "applicationInsights": {
+      "samplingSettings": {
+        "isEnabled": true,
+        "excludedTypes": "Request"
+      }
+    }
+  },
+  "functionTimeout": "00:10:00",
+  "extensionBundle": {
+    "id": "Microsoft.Azure.Functions.ExtensionBundle",
+    "version": "[4.*, 5.0.0)"
+  },
+  "concurrency": {
+    "dynamicConcurrencyEnabled": true,
+    "snapshotPersistenceEnabled": true
+  }
+}

package/dist/ai-context/internal/examples/v1/me-and-u-manage/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "seeka-app-meandu-manage",
+  "version": "1.0.6",
+  "description": "Seeka app seeka-app-meandu-manage",
+  "author": "WooCommerce testing <dev@seeka.co>",
+  "license": "MIT",
+  "main": "dist/src/functions/*.js",
+  "private": true,
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "lint": "eslint",
+    "build": "tsc",
+    "watch": "tsc -w",
+    "clean": "yarn rimraf dist",
+    "prestart": "yarn clean && yarn build",
+    "start": "func start --port 7072",
+    "tunnel": "node scripts/ngrok.js seeka-app-meandu-manage-localdev",
+    "deploy": "yarn clean && yarn build && func azure functionapp publish seeka-app-meandu-manage --no-build",
+    "dev:queue:create": "node scripts/dev-queue-setup.js process-new-meandu-orders-queue && node scripts/dev-queue-setup.js process-new-meandu-marketingoptin-queue"
+  },
+  "dependencies": {
+    "@azure/functions": "^4.6.1",
+    "@azure/storage-queue": "^12.25.0",
+    "@datalust/winston-seq": "^2.0.0",
+    "@seeka-labs/sdk-apps-server": "^1.1.29",
+    "axios": "^1.7.9",
+    "graphql": "^16.10.0",
+    "isomorphic-unfetch": "^4.0.2",
+    "lodash": "^4.17.21",
+    "redis": "^4.7.0",
+    "winston": "^3.17.0"
+  },
+  "devDependencies": {
+    "@types/lodash": "^4.17.15",
+    "@types/node": "^20",
+    "@typescript-eslint/eslint-plugin": "^8.23.0",
+    "@typescript-eslint/parser": "^8.23.0",
+    "azure-functions-core-tools": "^4.x",
+    "eslint": "^9",
+    "ngrok": "^5.0.0-beta.2",
+    "rimraf": "^6.0.1",
+    "typescript": "^5.7.3"
+  }
+}

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

@@ -0,0 +1,14 @@
+import { app, HttpRequest, HttpResponseInit, InvocationContext } from '@azure/functions';
+
+app.http('healthCheck', {
+    methods: ['GET', 'HEAD'],
+    authLevel: 'anonymous',
+    route: 'health',
+    handler: healthCheck
+});
+
+export async function healthCheck(req: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> {
+    return {
+        status: 200
+    }
+}

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

@@ -0,0 +1,47 @@
+import { app, InvocationContext, Timer } from '@azure/functions';
+import { QueueClient } from '@azure/storage-queue';
+
+import { jobNames, queueNames, triggerBackgroundJobWithQueue } from '../lib/jobs';
+import { backgroundJobLogger } from '../lib/logging';
+import { startServices } from '../lib/services';
+import { listInstallations } from '../lib/state/seeka/installations';
+import winston from 'winston';
+
+// https://learn.microsoft.com/en-us/azure/azure-functions/functions-bindings-timer?tabs=python-v2%2Cisolated-process%2Cnodejs-v4&pivots=programming-language-typescript
+app.timer('pollForNewMeAndUData', {
+    schedule: '0 */15 * * * *', // every 1 hour on the 15th minute
+    handler: pollForNewMeAndUData
+});
+
+export async function pollForNewMeAndUData(myTimer: Timer, context: InvocationContext): Promise<void> {
+    const logger = backgroundJobLogger(jobNames.pollForNewMeAndUData, undefined, context);
+
+    logger.profile(`job.${jobNames.pollForNewMeAndUData}`)
+    logger.info('Received request to trigger scheduled job');
+
+    await startServices(logger);
+
+    const allInstallations = await listInstallations(logger);
+    logger.verbose(`Triggering background job for ${allInstallations.length} installations`)
+
+    const ordersQueueClient = new QueueClient(process.env.AzureWebJobsStorage as string, queueNames.processNewMeAndUOrdersQueueName);
+    const marketingOptInQueueClient = new QueueClient(process.env.AzureWebJobsStorage as string, queueNames.processNewMeAndUMarketingOptInsQueueName);
+    const promises = allInstallations.filter(e => Boolean(e.installationState.meAndUMenuId)).map(installation => {
+        return Promise.all([
+            // Job to trigger job to process new MeAndU marketing opt ins
+            triggerBackgroundJobWithQueue(marketingOptInQueueClient, { ...installation, causationId: context.invocationId, correlationId: context.invocationId }, logger),
+
+            // Job to trigger job to process new MeAndU orders
+            triggerBackgroundJobWithQueue(ordersQueueClient, { ...installation, causationId: context.invocationId, correlationId: context.invocationId }, logger)
+        ]);
+    })
+
+    try {
+        await Promise.all(promises);
+    }
+    catch (err) {
+        logger.error('Error triggering background jobs', { ex: winston.exceptions.getAllInfo(err) })
+    }
+
+    logger.profile(`job.${jobNames.pollForNewMeAndUData}`)
+}

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

@@ -0,0 +1,69 @@
+import { app, InvocationContext } from '@azure/functions';
+
+import { SeekaActivityAcceptedWebhookContent } from '@seeka-labs/sdk-apps-server';
+import { groupBy } from 'lodash';
+import winston from 'winston';
+import { BackgroundJobRequestContext, deserialiseQueuePayload, queueNames, sendQueueMessageToPoisonQueue } from '../lib/jobs';
+import { backgroundJobLogger } from '../lib/logging';
+import { getAllMeAndUMarketingOptIns, handleMeAndUMarketingOptInPage } from '../lib/me-and-u/consent';
+import { startServices } from '../lib/services';
+import { SeekaAppInstallState, tryGetInstallation } from '../lib/state/seeka/installations';
+
+app.storageQueue('processNewMeAndUMarketingOptIns', {
+    queueName: queueNames.processNewMeAndUMarketingOptInsQueueName,
+    connection: 'AzureWebJobsStorage',
+    handler: processNewMeAndUMarketingOptIns
+});
+
+export interface MeAndUMarketingOptInQueueItem extends BackgroundJobRequestContext {
+    items: SeekaActivityAcceptedWebhookContent[];
+}
+
+export async function processNewMeAndUMarketingOptIns(queueItem: unknown, context: InvocationContext): Promise<void> {
+    const logger = backgroundJobLogger(queueNames.processNewMeAndUMarketingOptInsQueueName, undefined, context);
+    logger.profile(`queue.${queueNames.processNewMeAndUMarketingOptInsQueueName}`)
+
+    try {
+        // queueItem can either be a single item or an array of items
+        const payload = deserialiseQueuePayload<MeAndUMarketingOptInQueueItem>(queueItem, logger);
+
+        // Group by applicationInstallId
+        const grouped = groupBy(payload, e => e.applicationInstallId);
+
+        logger.verbose('Received queue batch to handle queue message', { batchSize: payload.length });
+
+        // Process each group
+        await startServices(logger);
+        for (const [applicationInstallId, items] of Object.entries(grouped)) {
+            if (items.length === 0) {
+                logger.warn('No items to process for applicationInstallId', { applicationInstallId });
+                continue;
+            }
+            const thisLogger = backgroundJobLogger(queueNames.processNewMeAndUMarketingOptInsQueueName, items[0], context);
+            try {
+                const installation = await tryGetInstallation(applicationInstallId, true, thisLogger) as SeekaAppInstallState;
+
+                // Get all marketing opt ins and process each page 
+                await getAllMeAndUMarketingOptIns(installation, async (page) => {
+                    await handleMeAndUMarketingOptInPage(installation, page, logger)
+                }, logger)
+            }
+            catch (err) {
+                thisLogger.error('Error handling queue item to handle queue message', { ex: winston.exceptions.getAllInfo(err) })
+                await sendQueueMessageToPoisonQueue(queueNames.processNewMeAndUMarketingOptInsQueueName, {
+                    ...items[0],
+                    causationId: items[0].causationId,
+                    correlationId: context.invocationId,
+                    rows: items.flatMap(e => e.items || []).filter(Boolean)
+                } as MeAndUMarketingOptInQueueItem, thisLogger);
+            }
+        }
+    }
+    catch (err) {
+        logger.error('Error handling queue item to handle queue message', { ex: winston.exceptions.getAllInfo(err) })
+        throw err; // Will retry based on host.json > extensions.queues.maxDequeueCount and then push to poison queue
+    }
+    finally {
+        logger.profile(`queue.${queueNames.processNewMeAndUMarketingOptInsQueueName}`)
+    }
+}

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

@@ -0,0 +1,69 @@
+import { app, InvocationContext } from '@azure/functions';
+
+import { SeekaActivityAcceptedWebhookContent } from '@seeka-labs/sdk-apps-server';
+import { groupBy } from 'lodash';
+import winston from 'winston';
+import { BackgroundJobRequestContext, deserialiseQueuePayload, queueNames, sendQueueMessageToPoisonQueue } from '../lib/jobs';
+import { backgroundJobLogger } from '../lib/logging';
+import { getAllMeAndUOrders, handleMeAndUOrderPage } from '../lib/me-and-u/orders';
+import { startServices } from '../lib/services';
+import { SeekaAppInstallState, tryGetInstallation } from '../lib/state/seeka/installations';
+
+app.storageQueue('processNewMeAndUOrders', {
+    queueName: queueNames.processNewMeAndUOrdersQueueName,
+    connection: 'AzureWebJobsStorage',
+    handler: processNewMeAndUOrders
+});
+
+export interface MeAndUOrderQueueItem extends BackgroundJobRequestContext {
+    items: SeekaActivityAcceptedWebhookContent[];
+}
+
+export async function processNewMeAndUOrders(queueItem: any, context: InvocationContext): Promise<void> {
+    const logger = backgroundJobLogger(queueNames.processNewMeAndUOrdersQueueName, undefined, context);
+    logger.profile(`queue.${queueNames.processNewMeAndUOrdersQueueName}`)
+
+    try {
+        // queueItem can either be a single item or an array of items
+        const payload = deserialiseQueuePayload<MeAndUOrderQueueItem>(queueItem, logger);
+
+        // Group by applicationInstallId
+        const grouped = groupBy(payload, e => e.applicationInstallId);
+
+        logger.verbose('Received queue batch to handle queue message', { batchSize: payload.length });
+
+        // Process each group
+        await startServices(logger);
+        for (const [applicationInstallId, items] of Object.entries(grouped)) {
+            if (items.length === 0) {
+                logger.warn('No items to process for applicationInstallId', { applicationInstallId });
+                continue;
+            }
+            const thisLogger = backgroundJobLogger(queueNames.processNewMeAndUOrdersQueueName, items[0], context);
+            try {
+                const installation = await tryGetInstallation(applicationInstallId, true, thisLogger) as SeekaAppInstallState;
+
+                // Get all orders and process each page 
+                await getAllMeAndUOrders(installation, async (page) => {
+                    await handleMeAndUOrderPage(installation, page, logger)
+                }, logger)
+            }
+            catch (err) {
+                thisLogger.error('Error handling queue item to handle queue message', { ex: winston.exceptions.getAllInfo(err) })
+                await sendQueueMessageToPoisonQueue(queueNames.processNewMeAndUOrdersQueueName, {
+                    ...items[0],
+                    causationId: items[0].causationId,
+                    correlationId: context.invocationId,
+                    rows: items.flatMap(e => e.items || []).filter(Boolean)
+                } as MeAndUOrderQueueItem, thisLogger);
+            }
+        }
+    }
+    catch (err) {
+        logger.error('Error handling queue item to handle queue message', { ex: winston.exceptions.getAllInfo(err) })
+        throw err; // Will retry based on host.json > extensions.queues.maxDequeueCount and then push to poison queue
+    }
+    finally {
+        logger.profile(`queue.${queueNames.processNewMeAndUOrdersQueueName}`)
+    }
+}