@seeka-labs/cli-apps 1.1.38 → 2.0.7-rc.1

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

@@ -1,91 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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

@@ -1,65 +0,0 @@
-import { createClient } from 'redis';
-
-import { logger } from '@/lib/logging';
-import winston from 'winston';
-
-const redisProtocol = process.env.REDIS_CONNECTION_TLS === 'true' ? 'rediss://' : 'redis://';
-const redisConn = `${redisProtocol}${process.env.REDIS_CONNECTION_USER}:${process.env.REDIS_CONNECTION_PASSWORD}@${process.env.REDIS_CONNECTION_HOST}:${process.env.REDIS_CONNECTION_PORT}`;
-
-const redisClient = createClient({
-    url: redisConn
-})
-    .on('error', (err: any) => logger.error('Redis Client ', { ex: winston.exceptions.getAllInfo(err) }));
-
-export const connect = async () => {
-    await redisClient.connect();
-}
-
-export const isConnected = () => {
-    return redisClient.isOpen;
-}
-
-export const disconnect = async () => {
-    await redisClient.disconnect();
-}
-
-const getKeyPrefix = (stateType: string) => `seeka:app:${process.env.SEEKA_APP_ID}:${stateType}`
-const getKey = (stateType: string, key: string) => `${getKeyPrefix(stateType)}:${key}`
-
-export async function getOrCreate<TState>(stateType: string, key: string, toCreate: TState): Promise<TState> {
-    const fullKey = getKey(stateType, key);
-    const existingStr = await redisClient.get(fullKey);
-    if (existingStr) return JSON.parse(existingStr);
-
-    await redisClient.set(fullKey, JSON.stringify(toCreate));
-
-    return toCreate;
-}
-
-export async function tryGet<TState>(stateType: string, key: string): Promise<TState | null> {
-    const fullKey = getKey(stateType, key);
-    const existingStr = await redisClient.get(fullKey);
-    if (existingStr) return JSON.parse(existingStr);
-
-    return null;
-}
-
-export async function getList<TState>(stateType: string): Promise<TState[]> {
-    const prefix = getKeyPrefix(stateType);
-    const allKeys = await redisClient.keys(`${prefix}:*`);
-    const listStr = await redisClient.mGet(allKeys);
-
-    if (listStr) return listStr.filter(e => Boolean(e)).map(e => JSON.parse(e as string));
-
-    return [];
-}
-
-export async function set<TState>(stateType: string, key: string, toCreate: TState): Promise<void> {
-    const fullKey = getKey(stateType, key);
-    await redisClient.set(fullKey, JSON.stringify(toCreate));
-}
-
-export async function remove(stateType: string, key: string): Promise<void> {
-    const fullKey = getKey(stateType, key);
-    await redisClient.del(fullKey);
-}

package/dist/init-templates/netlify-function/src/lib/state/seeka/installations.ts

@@ -1,67 +0,0 @@
-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

@@ -1,25 +0,0 @@
-{
-  "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"
-  ]
-}