@seeka-labs/cli-apps 2.0.7-rc.2 → 2.0.12-alpha.0

package/dist/init-template/app/server-azure-function/src/functions/queueExample.ts

@@ -1,67 +1,67 @@
-import winston from 'winston';
-
-import { app, InvocationContext } from '@azure/functions';
-
-import { BackgroundJobRequestContext, deserialiseQueuePayload, queueNames, sendQueueMessageToPoisonQueue } from '../lib/jobs';
-import { backgroundJobLogger } from '../lib/logging';
-import { startServices } from '../lib/services';
-import { groupBy } from 'lodash';
-import { SeekaAppInstallState, tryGetInstallation } from '../lib/state/seeka/installations';
-import { SeekaActivityAcceptedWebhookContent } from '@seeka-labs/sdk-apps-server';
-
-app.storageQueue('queueExample', {
-    queueName: queueNames.queueItemExampleQueueName,
-    connection: 'AzureWebJobsStorage',
-    handler: queueExample
-});
-
-export interface MyQueueItem extends BackgroundJobRequestContext {
-    items: SeekaActivityAcceptedWebhookContent[];
-}
-
-export async function queueExample(queueItem: any, context: InvocationContext): Promise<void> {
-    const logger = backgroundJobLogger(queueNames.queueItemExampleQueueName, undefined, context);
-    logger.profile(`queue.${queueNames.queueItemExampleQueueName}`)
-    try {
-        // queueItem can either be a single item or an array of items
-        const payload = deserialiseQueuePayload<MyQueueItem>(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.queueItemExampleQueueName, items[0], context);
-            try {
-                const installation = await tryGetInstallation(applicationInstallId, true, thisLogger) as SeekaAppInstallState;
-
-                // Execute sync
-                // const batchItems = items.flatMap(e => e.items || []).filter(Boolean)
-                // await executeLongRunningTask(batchItems, logger);
-            }
-            catch (err) {
-                thisLogger.error('Error handling queue item to handle queue message', { ex: winston.exceptions.getAllInfo(err) })
-                await sendQueueMessageToPoisonQueue(queueNames.queueItemExampleQueueName, {
-                    ...items[0],
-                    causationId: items[0].causationId,
-                    correlationId: context.invocationId,
-                    rows: items.flatMap(e => e.items || []).filter(Boolean)
-                } as MyQueueItem, 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.queueItemExampleQueueName}`)
-    }
+import winston from 'winston';
+
+import { app, InvocationContext } from '@azure/functions';
+
+import { BackgroundJobRequestContext, deserialiseQueuePayload, queueNames, sendQueueMessageToPoisonQueue } from '../lib/jobs';
+import { backgroundJobLogger } from '../lib/logging';
+import { startServices } from '../lib/services';
+import { groupBy } from 'lodash';
+import { SeekaAppInstallState, tryGetInstallation } from '../lib/state/seeka/installations';
+import { SeekaActivityAcceptedWebhookContent } from '@seeka-labs/sdk-apps-server';
+
+app.storageQueue('queueExample', {
+    queueName: queueNames.queueItemExampleQueueName,
+    connection: 'AzureWebJobsStorage',
+    handler: queueExample
+});
+
+export interface MyQueueItem extends BackgroundJobRequestContext {
+    items: SeekaActivityAcceptedWebhookContent[];
+}
+
+export async function queueExample(queueItem: any, context: InvocationContext): Promise<void> {
+    const logger = backgroundJobLogger(queueNames.queueItemExampleQueueName, undefined, context);
+    logger.profile(`queue.${queueNames.queueItemExampleQueueName}`)
+    try {
+        // queueItem can either be a single item or an array of items
+        const payload = deserialiseQueuePayload<MyQueueItem>(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.queueItemExampleQueueName, items[0], context);
+            try {
+                const installation = await tryGetInstallation(applicationInstallId, true, thisLogger) as SeekaAppInstallState;
+
+                // Execute sync
+                // const batchItems = items.flatMap(e => e.items || []).filter(Boolean)
+                // await executeLongRunningTask(batchItems, logger);
+            }
+            catch (err) {
+                thisLogger.error('Error handling queue item to handle queue message', { ex: winston.exceptions.getAllInfo(err) })
+                await sendQueueMessageToPoisonQueue(queueNames.queueItemExampleQueueName, {
+                    ...items[0],
+                    causationId: items[0].causationId,
+                    correlationId: context.invocationId,
+                    rows: items.flatMap(e => e.items || []).filter(Boolean)
+                } as MyQueueItem, 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.queueItemExampleQueueName}`)
+    }
 }

package/dist/init-template/app/server-azure-function/src/lib/jobs/index.ts

@@ -1,96 +1,96 @@
-import { QueueClient } from '@azure/storage-queue';
-import { isArray } from 'lodash';
-import type { Logger } from 'winston';
-import winston from 'winston';
-
-export interface BackgroundJobRequestContext {
-    organisationId?: string;
-    organisationBrandId?: string;
-    applicationInstallId?: string;
-    causationId: string
-    correlationId: string
-}
-
-export const signatureHeaderName = 'x-signature-hmac';
-export const apiKeyHeaderName = 'x-api-key';
-
-export const jobNames = {
-    pollingExample: 'polling-example',
-}
-
-export const queueNames = {
-    queueItemExampleQueueName: 'sample-queue-name'
-}
-
-export const triggerBackgroundJob = async (queueName: string, context: BackgroundJobRequestContext, logger: Logger): Promise<void> => {
-    const queueClient = new QueueClient(process.env.AzureWebJobsStorage as string, queueName);
-    return triggerBackgroundJobWithQueue(queueClient, context, logger);
-}
-
-const serialiseQueuePayload = (payload: unknown): string => {
-    const jsonString = JSON.stringify(payload)
-    return Buffer.from(jsonString).toString('base64')
-}
-
-export const deserialiseQueuePayload = <TPayload>(queueItem: any, logger: Logger): TPayload[] => {
-    try {
-        if (typeof queueItem !== 'string') {
-            if (isArray(queueItem)) {
-                return queueItem
-            }
-            return [queueItem]
-        }
-        else {
-            const jsonString = Buffer.from(queueItem, 'base64').toString()
-            const parsed = JSON.parse(jsonString);
-
-            if (isArray(parsed)) {
-                return parsed
-            }
-            return [parsed]
-        }
-    }
-    catch (err) {
-        logger.error('Failed to deserialise queue payload', { ex: winston.exceptions.getAllInfo(err), queueItem });
-        throw new Error(`Failed to deserialise queue payload`);
-    }
-}
-
-export const triggerBackgroundJobWithQueue = async (queueClient: QueueClient, context: BackgroundJobRequestContext, logger: Logger): Promise<void> => {
-    const body = {
-        ...context
-    }
-    const bodyStr = serialiseQueuePayload(body);
-
-    const response = await queueClient.sendMessage(bodyStr, { messageTimeToLive: -1 });
-
-    if (response.errorCode) {
-        const { requestId, date, errorCode } = response;
-        logger.error("Failed to trigger background job", { body, requestId, date, errorCode })
-        throw new Error(`Failed to trigger background job: ${response.errorCode}`);
-    }
-    else {
-        logger.debug("Background job triggered", { body, messageId: response.messageId, context })
-    }
-}
-
-export const sendQueueMessageToPoisonQueue = async (queueName: string, context: BackgroundJobRequestContext, 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 })
-    }
+import { QueueClient } from '@azure/storage-queue';
+import { isArray } from 'lodash';
+import type { Logger } from 'winston';
+import winston from 'winston';
+
+export interface BackgroundJobRequestContext {
+    organisationId?: string;
+    organisationBrandId?: string;
+    applicationInstallId?: string;
+    causationId: string
+    correlationId: string
+}
+
+export const signatureHeaderName = 'x-signature-hmac';
+export const apiKeyHeaderName = 'x-api-key';
+
+export const jobNames = {
+    pollingExample: 'polling-example',
+}
+
+export const queueNames = {
+    queueItemExampleQueueName: 'sample-queue-name'
+}
+
+export const triggerBackgroundJob = async (queueName: string, context: BackgroundJobRequestContext, logger: Logger): Promise<void> => {
+    const queueClient = new QueueClient(process.env.AzureWebJobsStorage as string, queueName);
+    return triggerBackgroundJobWithQueue(queueClient, context, logger);
+}
+
+const serialiseQueuePayload = (payload: unknown): string => {
+    const jsonString = JSON.stringify(payload)
+    return Buffer.from(jsonString).toString('base64')
+}
+
+export const deserialiseQueuePayload = <TPayload>(queueItem: any, logger: Logger): TPayload[] => {
+    try {
+        if (typeof queueItem !== 'string') {
+            if (isArray(queueItem)) {
+                return queueItem
+            }
+            return [queueItem]
+        }
+        else {
+            const jsonString = Buffer.from(queueItem, 'base64').toString()
+            const parsed = JSON.parse(jsonString);
+
+            if (isArray(parsed)) {
+                return parsed
+            }
+            return [parsed]
+        }
+    }
+    catch (err) {
+        logger.error('Failed to deserialise queue payload', { ex: winston.exceptions.getAllInfo(err), queueItem });
+        throw new Error(`Failed to deserialise queue payload`);
+    }
+}
+
+export const triggerBackgroundJobWithQueue = async (queueClient: QueueClient, context: BackgroundJobRequestContext, logger: Logger): Promise<void> => {
+    const body = {
+        ...context
+    }
+    const bodyStr = serialiseQueuePayload(body);
+
+    const response = await queueClient.sendMessage(bodyStr, { messageTimeToLive: -1 });
+
+    if (response.errorCode) {
+        const { requestId, date, errorCode } = response;
+        logger.error("Failed to trigger background job", { body, requestId, date, errorCode })
+        throw new Error(`Failed to trigger background job: ${response.errorCode}`);
+    }
+    else {
+        logger.debug("Background job triggered", { body, messageId: response.messageId, context })
+    }
+}
+
+export const sendQueueMessageToPoisonQueue = async (queueName: string, context: BackgroundJobRequestContext, 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/init-template/app/server-azure-function/src/lib/services/index.ts

@@ -1,41 +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;
-    }
+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/init-template/app/server-azure-function/tsconfig.json

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

package/dist/init-template/package.json

@@ -1,6 +1,6 @@
 {
   "name": "seeka-app-example-name",
-  "version": "2.0.7-rc.2",
+  "version": "2.0.12-alpha.0",
   "private": true,
   "workspaces": [
     "app/*"

package/dist/init-template/tsconfig.json

@@ -1,25 +1,25 @@
-{
-  "compilerOptions": {
-    "allowJs": true,
-    "skipLibCheck": true,
-    "strict": false,
-    "esModuleInterop": true,
-    "sourceMap": true,
-    "module": "CommonJS",
-    "target": "ES6",
-    "resolveJsonModule": true,
-    "isolatedModules": false,
-    "baseUrl": ".",
-    "paths": {
-      "@seeka-app-example-name/*": ["app/*/src"]
-    }
-  },
-  "references": [
-    { "path": "app/server-azure-function" },
-    { "path": "app/browser" }
-  ],
-  "exclude": [
-    "node_modules",
-    "**/dist"
-  ]
-}
+{
+  "compilerOptions": {
+    "allowJs": true,
+    "skipLibCheck": true,
+    "strict": false,
+    "esModuleInterop": true,
+    "sourceMap": true,
+    "module": "CommonJS",
+    "target": "ES6",
+    "resolveJsonModule": true,
+    "isolatedModules": false,
+    "baseUrl": ".",
+    "paths": {
+      "@seeka-app-example-name/*": ["app/*/src"]
+    }
+  },
+  "references": [
+    { "path": "app/server-azure-function" },
+    { "path": "app/browser" }
+  ],
+  "exclude": [
+    "node_modules",
+    "**/dist"
+  ]
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@seeka-labs/cli-apps",
-  "version": "2.0.7-rc.2",
+  "version": "2.0.12-alpha.0",
   "description": "Seeka - Apps CLI",
   "author": "SEEKA <platform@seeka.co>",
   "license": "MIT",
@@ -40,11 +40,12 @@
     "commander": "^14.0.0",
     "cross-spawn": "^7.0.6",
     "esbuild": "^0.25.5",
+    "glob": "^11.0.3",
     "jest": "^29.7.0",
     "ts-jest": "^29.3.4",
     "typescript": "^5.8.3"
   },
-  "gitHead": "3090cdc0329c28d427d15343ac3b2b486b5d5627",
+  "gitHead": "d56ee893384c9ebd99494844b5740de0f256789e",
   "dependencies": {
     "lodash-es": "^4.17.21",
     "source-map-support": "^0.5.21"

package/dist/init-template/.yarnrc.yml

@@ -1,8 +0,0 @@
-nodeLinker: node-modules
-                          
-nmHoistingLimits: workspaces
-
-npmScopes: 
-  seeka-labs: 
-    npmRegistryServer: "https://npm.packages.seeka.services"
-    npmAuthToken: "<<npm_registry_token>>"