@seeka-labs/cli-apps 1.0.1

package/dist/init-templates/netlify-function/src/api/seeka-app-webhook/index.ts

@@ -0,0 +1,185 @@
+
+import type { Logger } from 'winston';
+
+import winston from 'winston';
+
+import { jobNames, triggerBackgroundJob } from '@/lib/jobs';
+import { webhookLogger } from '@/lib/logging';
+import { startServices, stopServices } from '@/lib/services';
+import {
+    createOrUpdateInstallation, deleteInstallation, SeekaAppInstallState, tryGetInstallation
+} from '@/lib/state/seeka/installations';
+import {
+    PersonIdentifiers, SeekaActivityAcceptedWebhookPayload, SeekaAppInstalledWebhookPayload,
+    SeekaAppInstallSettingsUpdatedWebhookPayload, SeekaAppUninstalledWebhookPayload,
+    SeekaIdentityChangedWebhookPayload, SeekaWebhookCallType, SeekaWebhookPayload,
+    throwOnInvalidWebhookSignature
+} from '@seeka-labs/sdk-apps-server';
+
+import type { Config, Context } from "@netlify/functions"
+export const config: Config = {
+    path: "/api/webhook/seeka/app",
+    method: "POST"
+};
+
+export default async (req: Request, context: Context) => {
+    const bodyStr = (await req.text()) 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) {
+        return new Response(undefined, { status: 204 })
+    }
+
+    // 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 });
+        return new Response(JSON.stringify({ error: "Webhook call invalid" }), { status: 401 })
+    }
+
+    if (body.isTest) {
+        // This is a test webhook call
+        return new Response(undefined, { status: 204 })
+    }
+
+    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 });
+
+            // Close db connections
+            await stopServices(logger);
+
+            return new Response(JSON.stringify({ error: "App not installed" }), { status: 422 })
+        }
+    }
+
+    // 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) // TODO: remove cast
+                    }
+                    break;
+                }
+            case SeekaWebhookCallType.ActivityAccepted:
+                {
+                    const payload = body as SeekaActivityAcceptedWebhookPayload;
+                    await handleSeekaActivity(payload, logger);
+
+                    break;
+                }
+            case SeekaWebhookCallType.IdentityChanged:
+                {
+                    const payload = body as SeekaIdentityChangedWebhookPayload;
+                    logger.debug('Identity changed', { payload });
+
+                    break;
+                }
+        }
+    }
+    catch (err) {
+        logger.error('Failed to handle webhook', { ex: winston.exceptions.getAllInfo(err) });
+        return new Response(JSON.stringify({ error: "Request failed" }), { status: 500 })
+    }
+    finally {
+        // Close db connections
+        await stopServices(logger);
+        logger.profile('http.seeka.webhook.app')
+        logger.verbose('Seeka webhook handled');
+    }
+
+    return new Response(undefined, { status: 204 })
+}
+
+
+const onInstallation = async (payload: SeekaAppInstalledWebhookPayload, logger: Logger) => {
+    if (payload.isTest) return;
+
+    const installation = await createOrUpdateInstallation({
+        ...payload.context,
+        installationState: {
+            grantedPermissions: payload.content?.grantedPermissions || []
+        },
+        installationSettings: payload.content?.installationSettings || {}
+    } as any, logger) // TODO: remove any
+
+    // Trigger a sync for the installation
+    await triggerBackgroundJob(jobNames.exampleBackgroundJob, {
+        ...payload.context
+    }, 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;
+
+    // Update settings
+    const installation = await createOrUpdateInstallation({
+        ...payload.context,
+        ...existingInstallation,
+        installationState: {
+            ...existingInstallation.installationState,
+            grantedPermissions: payload.content?.grantedPermissions || []
+        },
+        installationSettings: payload.content?.installationSettings || {}
+    } as any, logger) // TODO: remove any
+
+    logger.info('Settings updated')
+}
+
+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/netlify-function/src/lib/jobs/index.ts

@@ -0,0 +1,68 @@
+import * as crypto from 'crypto';
+import { trimEnd } from 'lodash-es';
+
+import type { Logger } from 'winston';
+export interface BackgroundJobRequestContext {
+    organisationId?: string;
+    organisationBrandId?: string;
+    applicationInstallId?: string;
+}
+
+export const signatureHeaderName = 'x-signature-hmac';
+export const apiKeyHeaderName = 'x-api-key';
+
+export const jobNames = {
+    exampleBackgroundJob: 'example-job-background',
+    examplePollingScheduledJob: 'polling-example-job-scheduled',
+}
+
+export const validateApiKey = (apiKey: string, logger: Logger) => {
+    if (!apiKey || apiKey != process.env.INBOUND_HTTP_CALL_API_KEY) {
+        logger.error('Failed to validate API key');
+        throw new Error('Invalid API key');
+    }
+
+    logger.verbose('Validated API key')
+}
+
+export const validateSignature = (signature: string, payload: string, logger: Logger) => {
+    const digest = createSignature(payload)
+
+    if (!signature || signature != digest) {
+        logger.error('Invalid webhook signature');
+        throw new Error('Invalid signature');
+    }
+
+    logger.verbose('Validated signature');
+}
+
+export const triggerBackgroundJob = async (jobName: string, context: BackgroundJobRequestContext, logger: Logger): Promise<void> => {
+    const body = {
+        ...context
+    }
+    const bodyStr = JSON.stringify(body);
+
+    const response = await fetch(`${trimEnd(process.env.URL, '/')}/.netlify/functions/${jobName}`, {
+        method: 'POST',
+        body: bodyStr,
+        headers: {
+            [apiKeyHeaderName]: process.env.INBOUND_HTTP_CALL_API_KEY as string,
+            [signatureHeaderName]: createSignature(bodyStr),
+            'Content-Type': 'application/json',
+        },
+    })
+
+    if (!response.ok) {
+        const { status, statusText, url, type, headers } = response;
+        logger.error("Failed to trigger background job", { status, statusText, body: await response.text(), url, type, headers })
+        throw new Error(`Failed to trigger background job: ${response.statusText}`);
+    }
+}
+
+export const createSignature = (payload: string) => {
+    const hmac = crypto.createHmac('sha256', process.env.ENCRYPTION_SECRET as string);
+    hmac.update(payload);
+    const digest = hmac.digest('hex');
+
+    return digest;
+}

package/dist/init-templates/netlify-function/src/lib/logging/index.ts

@@ -0,0 +1,91 @@
+import * as winston from 'winston';
+
+import { BackgroundJobRequestContext } from '@/lib/jobs';
+import { SeqTransport } from '@datalust/winston-seq';
+import { Context } from '@netlify/functions';
+
+import 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.cli(),
+            winston.format.errors({ stack: true }),
+            winston.format.splat(),
+            winston.format.cli()
+        ),
+        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,
+        })
+    )
+}
+
+export const logger = winston.createLogger({
+    level: process.env.LOGGING_LEVEL,
+    defaultMeta: {
+        seekaAppId: process.env.SEEKA_APP_ID,
+        seekaAppPackageName: packageJson.name,
+        seekaAppPackageVersion: packageJson.version,
+        Hosting_Provider: process.env.NETLIFY === 'true' ? 'netlify-aws' : undefined,
+        Release_Version: process.env.COMMIT_REF ? `sha-${process.env.COMMIT_REF}` : undefined,
+        Hosting_Region: process.env.AWS_REGION || undefined
+    },
+    transports: loggerTransports,
+    exitOnError: false,
+});
+
+export const childLogger = (meta: Object) => logger.child(meta);
+
+export const webhookLogger = (payload: SeekaWebhookPayload, functionContext: Context) => {
+    const meta: any = {
+        seekaWebhookType: payload.type,
+        seekaWebhookIsTest: payload.isTest,
+        seekaWebhookRequestId: payload.requestId,
+        seekaWebhookCausationId: payload.causationId,
+        netlifyRequestId: functionContext.requestId,
+        netlifyDeployId: functionContext.deploy.id
+    }
+
+    const context = (payload as SeekaWebhookPayloadOfSeekaAppWebhookContext).context;
+    if (context) {
+        meta.seekaAppInstallId = context.applicationInstallId;
+        meta.seekaAppInstallOrganisationBrandId = context.organisationBrandId;
+        meta.seekaAppInstallOrganisationId = context.organisationId;
+    }
+
+    return childLogger(meta)
+}
+
+export const backgroundJobLogger = (jobName: string, jobContext: BackgroundJobRequestContext | undefined, functionContext: Context) => {
+    const meta: any = {
+        jobContext,
+        jobName,
+        netlifyRequestId: functionContext.requestId,
+        netlifyDeployId: functionContext.deploy.id,
+        seekaAppInstallId: jobContext?.applicationInstallId,
+        seekaAppInstallOrganisationBrandId: jobContext?.organisationBrandId,
+        seekaAppInstallOrganisationId: jobContext?.organisationId
+    }
+
+    return childLogger(meta)
+}

package/dist/init-templates/netlify-function/src/lib/services/index.ts

@@ -0,0 +1,41 @@
+import winston, { Logger } from 'winston';
+
+import { connect, disconnect, isConnected } from '@/lib/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-templates/netlify-function/src/lib/state/redis/index.ts

@@ -0,0 +1,64 @@
+import { createClient } from 'redis';
+
+import { logger } from '@/lib/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/init-templates/netlify-function/src/lib/state/seeka/installations.ts

@@ -0,0 +1,67 @@
+import type { Logger } from 'winston';
+
+import { getList, remove, set, tryGet } from '@/lib/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/netlify-function/tsconfig.json

@@ -0,0 +1,25 @@
+{
+  "compilerOptions": {
+    "allowJs": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "paths": {
+      "@/*": [
+        "./src/*"
+      ]
+    }
+  },
+  "include": [
+    "**/*.ts",
+    "**/*.mts",
+  ],
+  "exclude": [
+    "node_modules"
+  ]
+}

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@seeka-labs/cli-apps",
+  "version": "1.0.1",
+  "description": "Seeka - Apps CLI",
+  "author": "SEEKA <platform@seeka.co>",
+  "license": "MIT",
+  "keywords": [
+    "apps",
+    "seeka",
+    "node",
+    "azure",
+    "aws",
+    "netlify"
+  ],
+  "files": [
+    "dist/"
+  ],
+  "bin": "./dist/index.js",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "test": "cross-env NODE_TLS_REJECT_UNAUTHORIZED=0 jest",
+    "build:ci": "yarn clean && tsc --noEmit && yarn build:templates && esbuild src/index.ts --bundle --minify --platform=node --target=node18 --outfile=dist/index.js",
+    "build": "yarn build:templates && tsc --noEmit && esbuild src/index.ts --bundle --sourcemap --platform=node --target=node18 --outfile=dist/index.js",
+    "build:templates": "node ./scripts/build-templates.js",
+    "watch": "tsc -w",
+    "clean": "yarn rimraf dist",
+    "dev": "yarn run clean && yarn build && node dist/index.js init seeka-app-test1 --template azure-function --email 'dev@seeka.co' --developer Seeka --noDependencies --force --env 'SEEKA_APP_ID=123' 'SEEKA_APP_SECRET=345' --packageManager pnpm"
+  },
+  "devDependencies": {
+    "@jest/globals": "^29.7.0",
+    "@types/cross-spawn": "^6.0.6",
+    "@types/jest": "^29.5.12",
+    "@types/memory-cache": "^0.2.5",
+    "@types/node": "^18.14.0",
+    "commander": "^12.0.0",
+    "cross-env": "^7.0.3",
+    "cross-spawn": "^7.0.3",
+    "esbuild": "^0.20.0",
+    "jest": "^29.7.0",
+    "nodemon": "^3.0.3",
+    "ts-jest": "^29.1.2",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.3.3"
+  },
+  "gitHead": "bd153ede29757d814a114f97953a587b62f0de18"
+}