@seeka-labs/cli-apps 1.0.1

package/dist/init-templates/aws-lambda/src/lib/logging/index.ts

@@ -0,0 +1,88 @@
+import { Context } from 'aws-lambda';
+import * as winston from 'winston';
+
+import { SeqTransport } from '@datalust/winston-seq';
+
+import * as packageJson from '../../../package.json';
+
+import type {
+    SeekaWebhookPayload, SeekaWebhookPayloadOfSeekaAppWebhookContext
+} from '@seeka-labs/sdk-apps-server';
+
+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: any) => { 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,
+        })
+    )
+}
+
+let logger: winston.Logger | null = null;
+
+const createLogger = () => winston.createLogger({
+    level: process.env.LOGGING_LEVEL,
+    defaultMeta: {
+        seekaAppId: process.env.SEEKA_APP_ID,
+        Hosting_Provider: 'aws',
+        Release_Version: `v${packageJson.version}`,
+        Hosting_Region: process.env.AWS_REGION,
+        Aws_Xray_TraceId: process.env._X_AMZN_TRACE_ID,
+        Aws_Lambda_FunctionName: process.env.AWS_LAMBDA_FUNCTION_NAME,
+        Service: `app/${packageJson.name}`,
+    },
+    transports: loggerTransports,
+    exitOnError: false,
+});
+
+export const getLogger = () => {
+    if (!logger || logger.closed) {
+        // If the AWS lambda host is reused then the logger will be closed and we need to recreate it
+        logger = createLogger();
+    }
+
+    return logger;
+};
+
+export const childLogger = (meta: object) => getLogger().child(meta);
+
+export const webhookLogger = (payload: SeekaWebhookPayload, functionContext: Context) => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const meta: any = {
+        seekaWebhookType: payload.type,
+        seekaWebhookIsTest: payload.isTest,
+        RequestId: payload.requestId,
+        AwsLambda_RequestId: functionContext.awsRequestId,
+        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)
+}

package/dist/init-templates/aws-lambda/src/lib/services/index.ts

@@ -0,0 +1,41 @@
+import winston, { Logger } from 'winston';
+
+import { connect, disconnect, isConnected } from '../state/redis';
+
+export const startServices = async (logger: Logger) => {
+    logger.debug(`Trying to connect to Redis - ${process.env.REDIS_CONNECTION_HOST}`)
+    try {
+        if (isConnected()) {
+            logger.verbose(`Redis already connected - ${process.env.REDIS_CONNECTION_HOST}`)
+        }
+        else {
+            logger.profile('service.redis.connect')
+            await connect();
+            logger.profile('service.redis.connect')
+            logger.debug(`Redis connected - ${process.env.REDIS_CONNECTION_HOST}`)
+        }
+    }
+    catch (err) {
+        logger.error(`Failed to connect to Redis - ${process.env.REDIS_CONNECTION_HOST}`, { ex: winston.exceptions.getAllInfo(err) })
+        throw err;
+    }
+}
+
+export const stopServices = async (logger: Logger) => {
+    logger.debug(`Trying to disconnect from Redis - ${process.env.REDIS_CONNECTION_HOST}`)
+    try {
+        if (isConnected() === false) {
+            logger.verbose(`Redis already disconnected - ${process.env.REDIS_CONNECTION_HOST}`)
+        }
+        else {
+            logger.profile('service.redis.disconnect')
+            await disconnect();
+            logger.profile('service.redis.disconnect')
+            logger.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/init-templates/aws-lambda/src/lib/state/redis/index.ts

@@ -0,0 +1,64 @@
+import { createClient } from 'redis';
+
+import { getLogger } 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 => getLogger().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/init-templates/aws-lambda/src/lib/state/seeka/installations.ts

@@ -0,0 +1,67 @@
+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: SampleAppInstallSettings;
+    // State relating to the app and installation of the app
+    installationState: SampleAppInstallState;
+
+    // When the app was installed
+    installedAt: string; // new Date().toISOString()
+}
+
+export interface SampleAppInstallState {
+    stateItem1?: string
+    stateItem2?: string
+    grantedPermissions?: string[]
+}
+
+export type SampleAppInstallSettings = { [key: string]: any; } | {
+    myAppInstallSetting1: string | number | undefined;
+    myAppInstallSetting2: string | number | undefined;
+}
+
+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/init-templates/aws-lambda/src/routes/seekaAppWebhook.ts

@@ -0,0 +1,170 @@
+import type { Logger } from 'winston';
+
+import { Context } from 'aws-lambda';
+import { Request, Response } from 'express';
+import winston from 'winston';
+
+import {
+    PersonIdentifiers, SeekaActivityAcceptedWebhookPayload, SeekaAppInstalledWebhookPayload,
+    SeekaAppInstallSettingsUpdatedWebhookPayload, SeekaAppUninstalledWebhookPayload,
+    SeekaIdentityChangedWebhookPayload, SeekaWebhookCallType, SeekaWebhookPayload,
+    throwOnInvalidWebhookSignature
+} from '@seeka-labs/sdk-apps-server';
+
+import { webhookLogger } from '../lib/logging';
+import { startServices } from '../lib/services';
+import {
+    createOrUpdateInstallation, deleteInstallation, SeekaAppInstallState, tryGetInstallation
+} from '../lib/state/seeka/installations';
+
+export async function seekaAppWebhook(req: Request, res: Response, context: Context): Promise<void> {
+    const bodyStr = req.body as string;
+    const body = JSON.parse(bodyStr) as SeekaWebhookPayload;
+
+    const logger = webhookLogger(body, context);
+    logger.profile('http.seeka.webhook.app')
+    logger.verbose('Received webhook from Seeka', { body });
+
+    // Handle probe 
+    if (body.type === SeekaWebhookCallType.Probe) {
+        res.status(204).send();
+        return;
+    }
+
+    // Validate webhook
+    try {
+        throwOnInvalidWebhookSignature(process.env.SEEKA_APP_SECRET as string, req.headers, bodyStr);
+        logger.debug('Webhook signature validated', { body });
+    }
+    catch {
+        logger.warn('Webhook signature invalid', { body });
+        res.status(401).json({ error: "Webhook call invalid" }).send();
+        return;
+    }
+
+    if (body.isTest) {
+        // This is a test webhook call
+        res.status(204).send();
+        return;
+    }
+
+    await startServices(logger);
+
+    // Check if the webhook is for an app we have installed
+    let installation: SeekaAppInstallState | null = null;
+    if (body.type != SeekaWebhookCallType.AppInstalled) {
+        installation = await tryGetInstallation((body as SeekaAppInstalledWebhookPayload).context?.applicationInstallId as string, false, logger);
+        if (installation == null) {
+            logger.warn('Webhook call cannot be processed as the installation ID is not known by this app', { body });
+
+            res.status(422).json({ error: "App not installed" }).send();
+            return;
+        }
+    }
+
+    // Do something
+    try {
+        switch (body.type) {
+            case SeekaWebhookCallType.AppInstalled:
+                {
+                    await onInstallation(body as SeekaAppInstalledWebhookPayload, logger);
+                    break;
+                }
+            case SeekaWebhookCallType.AppInstallSettingsUpdated:
+                {
+                    await onInstallationSettingsUpdate(body as SeekaAppInstallSettingsUpdatedWebhookPayload, logger);
+                    break;
+                }
+            case SeekaWebhookCallType.AppUninstalled:
+                {
+                    if (!body.isTest) {
+                        const payload = body as SeekaAppUninstalledWebhookPayload;
+                        await deleteInstallation(payload.context?.applicationInstallId as string, logger)
+                    }
+                    break;
+                }
+            case SeekaWebhookCallType.ActivityAccepted:
+                {
+                    const payload = body as SeekaActivityAcceptedWebhookPayload;
+                    await handleSeekaActivity(payload, logger);
+
+                    break;
+                }
+            case SeekaWebhookCallType.IdentityChanged:
+                {
+                    const payload = body as SeekaIdentityChangedWebhookPayload;
+                    break;
+                }
+        }
+
+        res.status(204).send();
+    }
+    catch (err) {
+        logger.error('Failed to handle webhook', { ex: winston.exceptions.getAllInfo(err) });
+        res.status(500).json({ error: "Request failed" }).send();
+    }
+    finally {
+        logger.profile('http.seeka.webhook.app')
+        logger.verbose('Seeka webhook handled');
+    }
+}
+
+const onInstallation = async (payload: SeekaAppInstalledWebhookPayload, logger: Logger) => {
+    if (payload.isTest) return;
+
+    const installation = await createOrUpdateInstallation({
+        ...payload.context,
+        installationState: {
+            grantedPermissions: payload.content?.grantedPermissions || []
+        },
+        applicationInstallId: payload.context?.applicationInstallId as string,
+        organisationBrandId: payload.context?.organisationBrandId as string,
+        organisationId: payload.context?.organisationId as string,
+        installedAt: new Date().toISOString(),
+        installationSettings: payload.content?.installationSettings || {}
+    }, logger)
+}
+
+const onInstallationSettingsUpdate = async (payload: SeekaAppInstallSettingsUpdatedWebhookPayload, logger: Logger) => {
+    if (payload.isTest) return;
+
+    const existingInstallation = await tryGetInstallation(payload.context?.applicationInstallId as string, true, logger) as SeekaAppInstallState;
+    const installation = await createOrUpdateInstallation({
+        ...existingInstallation,
+        installationState: {
+            ...existingInstallation.installationState,
+            grantedPermissions: payload.content?.grantedPermissions || []
+        },
+        installationSettings: payload.content?.installationSettings || {},
+    }, logger)
+}
+
+const handleSeekaActivity = async (activity: SeekaActivityAcceptedWebhookPayload, logger: Logger) => {
+    // const context = activity.context as SeekaAppWebhookContext;
+    // const helper = SeekaAppHelper.create(process.env['SEEKA_APP_SECRET'] as string, {
+    //     organisationId: context.organisationId as string,
+    //     applicationInstallId: context.applicationInstallId as string,
+    //     applicationId: process.env['SEEKA_APP_ID'] as string,
+    // }, { name, version }, logger);
+
+    // // Append a first name to the identity
+    // await helper.api.mergeIdentity({
+    //     seekaPId: activity.content?.personId,
+    //     firstName: [
+    //         'firstname_' + new Date().getTime()
+    //     ]
+    // }, {
+    //     method: 'toremove',
+    //     origin: TrackingEventSourceOriginType.Server
+    // })
+
+    // // Fire off a tracking event
+    // await helper.api.trackActivity({
+    //     activityName: TrackingActivityNames.Custom,
+    //     activityNameCustom: 'seeka-app-activity-accepted',
+    //     activityId: 'act' + new Date().getTime(),
+    // }, activity.content?.personId as string, {
+    //     method: 'toremove',
+    //     origin: TrackingEventSourceOriginType.Server
+    // })
+}

package/dist/init-templates/aws-lambda/tsconfig.json

@@ -0,0 +1,31 @@
+{
+  "compilerOptions": {
+    "allowJs": false,
+    "skipLibCheck": true,
+    "strict": true,
+    "esModuleInterop": true,
+    "preserveConstEnums": true,
+    "outDir": "dist",
+    "rootDir": ".",
+    "module": "commonjs",
+    "target": "es6",
+    "inlineSourceMap": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "forceConsistentCasingInFileNames": true,
+    "typeRoots": [
+      "node_modules/@types"
+    ],
+    "types": [
+      "node"
+    ]
+  },
+  "include": [
+    "src/index.ts"
+  ],
+  "exclude": [
+    "node_modules",
+    "dist",
+    "scripts"
+  ]
+}

package/dist/init-templates/azure-function/.eslintrc.cjs

@@ -0,0 +1,10 @@
+/* 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"
+    }
+};

package/dist/init-templates/azure-function/.example.gitignore

@@ -0,0 +1,48 @@
+bin
+obj
+csx
+.vs
+edge
+Publish
+
+*.user
+*.suo
+*.cscfg
+*.Cache
+project.lock.json
+
+/packages
+/TestResults
+
+/tools/NuGet.exe
+/App_Data
+/secrets
+/data
+.secrets
+appsettings.json
+local.settings.json
+
+node_modules
+dist
+
+# Local python packages
+.python_packages/
+
+# Python Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# Azurite artifacts
+__blobstorage__
+__queuestorage__
+__azurite_db*__.json

package/dist/init-templates/azure-function/.funcignore

@@ -0,0 +1,17 @@
+*.js.map
+*.ts
+.git*
+.vscode
+local.settings.json
+test
+scripts/
+src/
+getting_started.md
+node_modules/@types/
+node_modules/azure-functions-core-tools/
+node_modules/typescript/
+node_modules/@typescript-eslint/eslint-plugin/
+node_modules/@typescript-eslint/parser/
+node_modules/eslint/
+node_modules/ngrok/
+node_modules/rimraf/

package/dist/init-templates/azure-function/.gitlab-ci.yml

@@ -0,0 +1,33 @@
+stages:
+  - deploy
+
+variables:
+  AZURE_FUNC_RESOURCE_NAME: seeka-app-example-name
+  CI_DEBUG_TRACE: "true"
+
+workflow:
+  rules:
+    - if: '$CI_PIPELINE_SOURCE == "merge_request_event"'
+      when: never
+    - if: '$CI_COMMIT_BRANCH == "main" && ($CI_PIPELINE_SOURCE == "push" || $CI_PIPELINE_SOURCE == "web")'
+      when: always
+    - if: '$CI_COMMIT_BRANCH == "staging" && ($CI_PIPELINE_SOURCE == "push" || $CI_PIPELINE_SOURCE == "web")'
+      when: always
+
+deploy:
+  stage: deploy
+  image: node:18-bullseye
+  before_script:
+    - echo "installing azure cli"
+    - curl -sL https://aka.ms/InstallAzureCLIDeb | bash
+    - az --version
+    - echo "logging in to azure"
+    - az login --service-principal --username "$AZURE_SERVICEPRINCIPAL_CLIENTID" --password "$AZURE_SERVICEPRINCIPAL_SECRET" --tenant "$AZURE_TENANT_ID"
+    - az account set --subscription "$AZURE_SUBSCRIPTION_ID"
+  script:
+    - echo "deploying azure func $AZURE_FUNC_RESOURCE_NAME to slot $AZURE_FUNC_SLOT from branch $CI_COMMIT_BRANCH"
+    - yarn install --production=false
+    - yarn run clean && yarn run build && yarn func azure functionapp publish $AZURE_FUNC_RESOURCE_NAME --no-build --javascript
+  only:
+    - main
+    - staging

package/dist/init-templates/azure-function/.vscode/extensions.json

@@ -0,0 +1,7 @@
+{
+    "recommendations": [
+        "ms-azuretools.vscode-azurefunctions",
+        "ms-vscode.vscode-node-azure-pack",
+        "dbaeumer.vscode-eslint"
+    ]
+}

package/dist/init-templates/azure-function/.vscode/launch.json

@@ -0,0 +1,13 @@
+{
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "name": "Attach to Node Functions",
+      "type": "node",
+      "request": "attach",
+      "port": 9229,
+      "preLaunchTask": "func: host start",
+      "restart": true
+    }
+  ]
+}

package/dist/init-templates/azure-function/.vscode/settings.json

@@ -0,0 +1,9 @@
+{
+    "azureFunctions.deploySubpath": ".",
+    "azureFunctions.postDeployTask": "yarn install (functions)",
+    "azureFunctions.projectLanguage": "TypeScript",
+    "azureFunctions.projectRuntime": "~4",
+    "debug.internalConsoleOptions": "neverOpen",
+    "azureFunctions.projectLanguageModel": 4,
+    "azureFunctions.preDeployTask": "yarn prune (functions)"
+}

package/dist/init-templates/azure-function/.vscode/tasks.json

@@ -0,0 +1,39 @@
+{
+  "version": "2.0.0",
+  "tasks": [
+    {
+      "type": "func",
+      "label": "func: host start",
+      "command": "host start --port 7072",
+      "problemMatcher": "$func-node-watch",
+      "isBackground": true,
+      "dependsOn": "yarn build (functions)"
+    },
+    {
+      "type": "shell",
+      "label": "yarn build (functions)",
+      "command": "yarn run watch",
+      "dependsOn": "yarn clean (functions)",
+      "problemMatcher": "$tsc-watch",
+      "isBackground": true
+    },
+    {
+      "type": "shell",
+      "label": "yarn install (functions)",
+      "command": "yarn install"
+    },
+    {
+      "type": "shell",
+      "label": "yarn prune (functions)",
+      "command": "yarn prune --production",
+      "dependsOn": "yarn build (functions)",
+      "problemMatcher": []
+    },
+    {
+      "type": "shell",
+      "label": "yarn clean (functions)",
+      "command": "yarn run clean",
+      "dependsOn": "yarn install (functions)"
+    }
+  ]
+}