@churchapps/apihelper 0.5.1 → 0.5.3

package/src/helpers/AwsHelper.ts

@@ -1,129 +0,0 @@
-import { S3Client, GetObjectCommand, PutObjectCommand, DeleteObjectCommand, CopyObjectCommand, ListObjectsV2Command, ListObjectsV2Output } from "@aws-sdk/client-s3";
-import { createPresignedPost } from "@aws-sdk/s3-presigned-post";
-import { EnvironmentBase } from "./EnvironmentBase.js";
-import { SSMClient, GetParameterCommand } from "@aws-sdk/client-ssm";
-
-export class AwsHelper {
-
-  //Pulls from AWS SSM Parameter Store
-  static async readParameter(parameterName: string): Promise<string> {
-    let result = "";
-    try {
-      const ssm = new SSMClient({ region: "us-east-2" });
-      const params = { Name: parameterName, WithDecryption: true };
-      const command = new GetParameterCommand(params);
-      const response = await ssm.send(command);
-      result = response?.Parameter?.Value || "";
-    } catch {
-      result = "";
-    }
-    return result;
-  }
-
-
-  private static _client: S3Client;
-
-  private static getClient(): S3Client {
-    if (!this._client) {
-      this._client = new S3Client({});
-    }
-    return this._client;
-  }
-
-  static async S3PresignedUrl(key: string): Promise<{url: string, fields: Record<string, string>, key: string}> {
-    if (key.startsWith("/")) key = key.substring(1);
-    const { url, fields } = await createPresignedPost(this.getClient(), {
-      Bucket: EnvironmentBase.s3Bucket,
-      Key: key,
-      Conditions: [
-        ["starts-with", "$Content-Type", ""],
-        { acl: "public-read" }
-      ],
-      Expires: 3600 // 1 hour
-    });
-    return { url, fields, key };
-  }
-
-  static async S3Upload(key: string, contentType: string, contents: Buffer): Promise<void> {
-    if (key.startsWith("/")) key = key.substring(1);
-    const command = new PutObjectCommand({
-      Bucket: EnvironmentBase.s3Bucket,
-      Key: key,
-      Body: contents,
-      ACL: "public-read",
-      ContentType: contentType
-    });
-    await this.getClient().send(command);
-  }
-
-  static async S3Remove(key: string): Promise<void> {
-    if (key.startsWith("/")) key = key.substring(1);
-    const command = new DeleteObjectCommand({
-      Bucket: EnvironmentBase.s3Bucket,
-      Key: key
-    });
-    await this.getClient().send(command);
-  }
-
-  static async S3Rename(oldKey: string, newKey: string): Promise<void> {
-    console.log(`Renaming: ${oldKey} to ${newKey}`);
-    await this.S3Copy(oldKey, newKey);
-    await this.S3Remove(oldKey);
-  }
-
-  static S3Move(oldKey: string, newKey: string): Promise<void> {
-    return this.S3Rename(oldKey, newKey);
-  }
-
-  static async S3Copy(oldKey: string, newKey: string): Promise<void> {
-    const command = new CopyObjectCommand({
-      Bucket: EnvironmentBase.s3Bucket,
-      CopySource: `/${EnvironmentBase.s3Bucket}/${oldKey}`,
-      Key: newKey,
-      ACL: "public-read"
-    });
-    await this.getClient().send(command);
-  }
-
-  static async S3List(path: string): Promise<string[]> {
-    return this.S3ListMultiPage(this.getClient(), EnvironmentBase.s3Bucket, path);
-  }
-
-  static async S3ListMultiPage(s3:S3Client, bucket:string, path: string): Promise<string[]> {
-    const result: string[] = [];
-    let continuationToken: string | undefined;
-
-    do {
-      const { Contents, NextContinuationToken } = await this.S3ListManual(s3, bucket, path, continuationToken);
-      result.push(...(Contents?.map((item) => item.Key).filter((key): key is string => key !== undefined) || []));
-      continuationToken = NextContinuationToken;
-    } while (continuationToken);
-
-    return result;
-  }
-
-  private static async S3ListManual(s3:S3Client, bucket:string, path: string, continuationToken?: string): Promise<ListObjectsV2Output> {
-    const command = new ListObjectsV2Command({
-      Bucket: bucket,
-      Prefix: path,
-      MaxKeys: 10000,
-      ContinuationToken: continuationToken
-    });
-    return s3.send(command);
-  }
-
-  static async S3Read(key: string): Promise<string | null> {
-    try {
-      const command = new GetObjectCommand({
-        Bucket: EnvironmentBase.s3Bucket,
-        Key: key
-      });
-      const response = await this.getClient().send(command);
-      return await response.Body?.transformToString();
-    } catch (error) {
-      console.error("Error reading from S3:", error);
-      return null;
-    }
-  }
-
-}

package/src/helpers/BasePermissions.ts

@@ -1,15 +0,0 @@
-export class BasePermissions {
-  static forms = {
-    admin: { contentType: "Forms", action: "Admin" },
-    edit: { contentType: "Forms", action: "Edit" }
-  };
-  static links = {
-    edit: { contentType: "Links", action: "Edit" }
-  };
-  static pages = {
-    edit: { contentType: "Pages", action: "Edit" }
-  };
-  static settings = {
-    edit: { contentType: "Settings", action: "Edit" }
-  };
-}

package/src/helpers/DB.ts

@@ -1,41 +0,0 @@
-import { Pool } from "./Pool.js";
-import { PoolConnection, QueryError } from "mysql2";
-import { LoggingHelper } from "./LoggingHelper.js";
-
-export class DB {
-
-    // wraps in promise
-    static async getConnection() {
-        const promise: Promise<PoolConnection> = new Promise((resolve, reject) => {
-            Pool.current.getConnection((ex: QueryError | null, conn: PoolConnection) => { if (ex) reject(ex); else resolve(conn); });
-        });;
-        const connection: PoolConnection = await promise;
-        return connection;
-    }
-
-    // wraps in promise
-    static async getQuery(connection: PoolConnection, sql: string, params: unknown[]) {
-        const promise: Promise<unknown> = new Promise((resolve, reject) => {
-            connection.query(sql, params, async (ex: QueryError | null, rows: unknown) => {
-                if (ex) { LoggingHelper.getCurrent().error(ex); reject(ex); }
-                else { resolve(rows); }
-            });
-        });
-        const query: unknown = await promise;
-        return query;
-    }
-
-    public static async query(sql: string, params: unknown[]) {
-        let result: unknown = null;
-        const connection = await this.getConnection();
-        try { result = await this.getQuery(connection, sql, params); }
-        catch (ex: unknown) { LoggingHelper.getCurrent().error(ex as Error); }
-        finally { connection.release(); }
-        return result;
-    }
-
-    public static async queryOne(sql: string, params: unknown[]) {
-        const result = await this.query(sql, params) as unknown[];
-        return result?.length > 0 ? result[0] : null;
-    }
-}

package/src/helpers/DBCreator.ts

@@ -1,39 +0,0 @@
-import dotenv from "dotenv";
-import fs from "fs";
-import { DB } from "./DB.js";
-
-export class DBCreator {
-
-  private static tables: { title: string, file: string }[] = [
-    { title: "Links", file: "links.mysql" },
-    { title: "Pages", file: "pages.mysql" },
-    { title: "Settings", file: "settings.mysql" }
-  ]
-
-  public static async init(selectedTables: string[]) {
-    dotenv.config();
-
-    const todo: { title: string, file: string }[] = [];
-    selectedTables.forEach(async st => {
-      this.tables.forEach(async t => {
-        if (t.title === st) todo.push(t);
-      });
-    });
-
-    for (const td of todo) await this.runScript(td.title, "./src/tools/dbScripts/" + td.file, false);
-    return;
-  }
-
-  public static async runScript(title: string, file: string, customDelimeter: boolean) {
-    console.log("Creating '" + title + "'");
-    const sql = fs.readFileSync(file, "utf-8");
-    let del = /;(?=END)\s*$|;(?!\nEND)\s*$/gm;
-    if (customDelimeter) {
-      del = /\$\$$/gm;
-    }
-    const statements = sql.split(del);
-    for (const statement of statements) if (statement.length > 3) await DB.query(statement, []);
-  }
-
-
-}

package/src/helpers/EmailHelper.ts

@@ -1,95 +0,0 @@
-import { SESClient, SendEmailCommand } from '@aws-sdk/client-ses';
-import nodemailer from 'nodemailer'
-// Removed nodemailer-direct-transport due to security vulnerabilities
-import { EnvironmentBase } from './EnvironmentBase.js';
-import { IEmailPayload } from './Interfaces.js';
-import fs from "fs";
-import path from "path";
-
-export class EmailHelper {
-
-  private static getSESClient(): SESClient {
-    return new SESClient({ region: "us-east-2" });
-  }
-
-  public static async sendTemplatedEmail(from: string, to: string, appName: string, appUrl: string, subject: string, contents: string, emailTemplate: "EmailTemplate.html" | "ChurchEmailTemplate.html" = "EmailTemplate.html", replyTo?: string) {
-    if (!appName) appName = "B1";
-    if (!appUrl) appUrl = "https://b1.church";
-
-    const template = EmailHelper.readTemplate(emailTemplate);
-    const emailBody = template
-      .replace("{appLink}", "<a target='_blank' rel='noreferrer noopener' href=\"" + appUrl + "/\">" + appName + "</a>")
-      .replace("{contents}", contents);
-    await EmailHelper.sendEmail({ from, to, subject, body: emailBody, replyTo });
-  }
-
-  public static readTemplate(templateFile?: string) {
-    if (!templateFile) templateFile = "EmailTemplate.html";
-    const filePath = path.join(__dirname, "../../src/tools/templates/" + templateFile);
-    const buffer = fs.readFileSync(filePath);
-    const contents = buffer.toString();
-    return contents;
-  }
-
-  private static async sendSes({ from, to, subject, body, replyTo }: IEmailPayload) {
-    const sesClient = this.getSESClient();
-      const sendCommand  = new SendEmailCommand({
-        Destination: {
-          ToAddresses: [to]
-        },
-        Message: {
-          Body: {
-            Html: {
-              Charset: 'UTF-8',
-              Data: body
-            }
-          },
-          Subject: {
-            Charset: 'UTF-8',
-            Data: subject
-          }
-        },
-        Source: from,
-        ReplyToAddresses: replyTo ? [replyTo] : undefined
-      });
-      await sesClient.send(sendCommand);
-  }
-
-  public static async sendEmail({ from, to, subject, body, replyTo }: IEmailPayload): Promise<void> {
-    try {
-      // Use a safer fallback - streamline transport (for testing/dev) or require proper SMTP config
-      let transporter: nodemailer.Transporter = nodemailer.createTransport({
-        streamTransport: true,
-        newline: 'unix',
-        buffer: true
-      });
-
-      if (EnvironmentBase.mailSystem === 'SES') {
-        await this.sendSes({ from, to, subject, body, replyTo });
-      } else {
-        if (EnvironmentBase.mailSystem === "SMTP") {
-          transporter = nodemailer.createTransport({
-            host: EnvironmentBase.smtpHost,
-            secure: EnvironmentBase.smtpSecure,
-            auth: {
-              user: EnvironmentBase.smtpUser,
-              pass: EnvironmentBase.smtpPass
-            }
-          });
-        }
-
-        if (EnvironmentBase.mailSystem === "") {
-          console.log("****Email server not configured: ");
-          console.log(subject);
-          console.log(body);
-        } else {
-          await transporter.sendMail({ from, to, subject, html: body, replyTo });
-        }
-      }
-      return null;
-    } catch (err) {
-      throw err;
-    }
-  }
-
-}

package/src/helpers/EncryptionHelper.ts

@@ -1,25 +0,0 @@
-import crypto from "crypto";
-import { EnvironmentBase } from "./EnvironmentBase.js";
-
-export class EncryptionHelper {
-  private static algorithm = 'aes-256-ctr';
-
-  static encrypt = (plainValue: string) => {
-    const iv = crypto.randomBytes(16);
-    const cipher = crypto.createCipheriv(EncryptionHelper.algorithm, EnvironmentBase.encryptionKey, iv);
-    const encrypted = Buffer.concat([cipher.update(plainValue), cipher.final()]);
-    return iv.toString('base64') + "|" + encrypted.toString('base64');
-  }
-
-  static decrypt = (encryptedPair: string) => {
-    const parts = encryptedPair.split("|");
-    if (parts.length !== 2) return "";
-    else {
-      const iv = Buffer.from(parts[0], 'base64');
-      const content = Buffer.from(parts[1], 'base64');
-      const decipher = crypto.createDecipheriv(EncryptionHelper.algorithm, EnvironmentBase.encryptionKey, iv);
-      const decrpyted = Buffer.concat([decipher.update(content), decipher.final()]);
-      return decrpyted.toString();
-    }
-  }
-}

package/src/helpers/EnvironmentBase.ts

@@ -1,36 +0,0 @@
-import { AwsHelper } from "./AwsHelper.js";
-
-export class EnvironmentBase {
-  static appEnv: string;
-  static appName: string;
-  static s3Bucket: string;
-  static connectionString: string;
-  static contentRoot: string;
-  static encryptionKey: string;
-  static fileStore: string;
-  static jwtSecret: string;
-
-  static mailSystem: string;
-  static smtpHost: string;
-  static smtpPass: string;
-  static smtpSecure: boolean;
-  static smtpUser: string;
-
-
-  static async populateBase(jsonData: Record<string, unknown>, appName:string, appEnv: string) {
-    EnvironmentBase.appName = jsonData.appName as string;
-    EnvironmentBase.appEnv = jsonData.appEnv as string;
-    EnvironmentBase.connectionString = process.env.CONNECTION_STRING || await AwsHelper.readParameter(`/${appEnv}/${appName}/connectionString`);
-    EnvironmentBase.contentRoot = jsonData.contentRoot as string;
-    EnvironmentBase.encryptionKey = process.env.ENCRYPTION_KEY || await AwsHelper.readParameter(`/${appEnv}/encryptionKey`);
-    EnvironmentBase.fileStore = jsonData.fileStore as string;
-    EnvironmentBase.jwtSecret = process.env.JWT_SECRET || await AwsHelper.readParameter(`/${appEnv}/jwtSecret`);
-    EnvironmentBase.mailSystem = jsonData.mailSystem as string;
-    EnvironmentBase.s3Bucket = jsonData.s3Bucket as string;
-    EnvironmentBase.smtpHost = process.env.SMTP_HOST;
-    EnvironmentBase.smtpPass = process.env.SMTP_PASS;
-    EnvironmentBase.smtpSecure = process.env.SMTP_SECURE === "true";
-    EnvironmentBase.smtpUser = process.env.SMTP_USER;
-  }
-
-}

package/src/helpers/FileStorageHelper.ts

@@ -1,71 +0,0 @@
-import { AwsHelper } from "./AwsHelper.js";
-import fs from "fs";
-import path from "path";
-import { EnvironmentBase } from "./EnvironmentBase.js";
-
-export class FileStorageHelper {
-  private static rootPath = path.resolve("./content") + "/";
-
-  static list = async (filePath: string) => {
-    let result = []
-    switch (EnvironmentBase.fileStore) {
-      case "S3": result = await AwsHelper.S3List(filePath); break;
-      default: result = await FileStorageHelper.listLocal(filePath); break;
-    }
-    return result
-  }
-
-  static move = async (oldKey: string, newKey: string) => {
-    switch (EnvironmentBase.fileStore) {
-      case "S3": await AwsHelper.S3Move(oldKey, newKey); break;
-      default: await FileStorageHelper.moveLocal(oldKey, newKey); break;
-    }
-  }
-
-  static store = async (key: string, contentType: string, contents: Buffer) => {
-    switch (EnvironmentBase.fileStore) {
-      case "S3": await AwsHelper.S3Upload(key, contentType, contents); break;
-      default: await FileStorageHelper.storeLocal(key, contents); break;
-    }
-  }
-
-  static remove = async (key: string) => {
-    switch (EnvironmentBase.fileStore) {
-      case "S3": await AwsHelper.S3Remove(key); break;
-      default: await FileStorageHelper.removeLocal(key); break;
-    }
-  }
-
-  static removeFolder = async (key: string) => {
-    switch (EnvironmentBase.fileStore) {
-      case "S3": break; // no need on s3
-      default: await FileStorageHelper.removeLocalFolder(key); break;
-    }
-  }
-
-  private static storeLocal = async (key: string, contents: Buffer) => {
-    const fileName = FileStorageHelper.rootPath + key;
-    const dirName = path.dirname(fileName);
-    if (!fs.existsSync(dirName)) fs.mkdirSync(dirName, { recursive: true });
-    fs.writeFileSync(fileName, contents);
-  }
-
-  private static moveLocal = async (oldKey: string, newKey: string) => {
-    fs.rename(oldKey, newKey, err => { throw err; });
-  }
-
-  private static removeLocal = async (key: string) => {
-    fs.unlinkSync(FileStorageHelper.rootPath + key);
-  }
-
-  private static removeLocalFolder = async (key: string) => {
-    fs.rmdirSync(FileStorageHelper.rootPath + key);
-  }
-
-  private static listLocal = async (filePath: string) => {
-    const fullPath = FileStorageHelper.rootPath + filePath;
-    if (!fs.existsSync(fullPath)) return [];
-    else return fs.readdirSync(FileStorageHelper.rootPath + filePath);
-  }
-
-}

package/src/helpers/Interfaces.ts

@@ -1,2 +0,0 @@
-export interface IPermission { contentType: string; action: string; apiName?: string }
-export interface IEmailPayload { from: string, to: string, subject: string, body: string, replyTo?: string }

package/src/helpers/LoggingHelper.ts

@@ -1,71 +0,0 @@
-import winston from "winston";
-import WinstonCloudWatch from "winston-cloudwatch";
-//import AWS from "aws-sdk";
-import { EnvironmentBase } from "./EnvironmentBase.js";
-
-export class LoggingHelper {
-  private static _current: LoggingHelper = null;
-  public static getCurrent = () => {
-    if (LoggingHelper._current === null) {
-      LoggingHelper._current = new LoggingHelper();
-      LoggingHelper._current.init("API");
-    }
-    return LoggingHelper._current;
-  }
-
-  private _logger: winston.Logger = null;
-  private wc: WinstonCloudWatch;
-  private pendingMessages = false;
-  private logGroupName = EnvironmentBase.appName + "_" + EnvironmentBase.appEnv;
-  private logDestination = "console";
-
-
-
-  public error(msg: string | object) {
-    throw msg instanceof Error ? msg : new Error(typeof msg === 'string' ? msg : JSON.stringify(msg));
-  }
-
-  public info(msg: string | object) {
-    if (this._logger === null) this.init("API");
-    this.pendingMessages = true;
-    this._logger.info(msg);
-  }
-
-  public log(streamName: string, level: string, msg: string | object) {
-    if (this._logger === null) this.init(streamName);
-    this.pendingMessages = true;
-    if (level === "info") this._logger.info(msg);
-    else this._logger.error(msg);
-  }
-
-
-  private init(streamName: string) {
-    this.pendingMessages = false;
-    //AWS.config.update({ region: "us-east-2" });
-    if (EnvironmentBase.appEnv === "staging") this.logDestination = "cloudwatch";
-    else if (EnvironmentBase.appEnv === "prod") this.logDestination = "cloudwatch";
-
-    if (this.logDestination === "cloudwatch") {
-      this.wc = new WinstonCloudWatch({ logGroupName: this.logGroupName, logStreamName: streamName, name: this.logGroupName + "_" + streamName });
-      this._logger = winston.createLogger({ transports: [this.wc], format: winston.format.json() });
-    } else this._logger = winston.createLogger({ transports: [new winston.transports.Console()], format: winston.format.json() });
-    this._logger.info("Logger initialized");
-  }
-
-  public flush() {
-    const promise = new Promise((resolve) => {
-      if (this.pendingMessages) {
-        if (this.wc) {
-          this.wc.kthxbye(() => {
-            // this._logger = null;
-            this.pendingMessages = false;
-          });
-        }
-        resolve(null);
-      } else resolve(null);
-    });
-    return promise;
-  }
-
-
-}

package/src/helpers/MySqlHelper.ts

@@ -1,5 +0,0 @@
-export class MySqlHelper {
-    static toQuotedAndCommaSeparatedString(values: string[]) {
-        return values.length === 0 ? "" : "'" + values.join("','") + "'";
-    }
-}

package/src/helpers/OmitEmpty.ts

@@ -1,128 +0,0 @@
-// Based on https://www.npmjs.com/package/omit-empty
-// The project appears to be abandoned, but needed modification to allow for empty arrays.
-
-"use strict";
-
-
-interface OmitEmptyOptions {
-    omitZero?: boolean;
-    omitEmptyArray?: boolean;
-    excludedProperties?: string[];
-}
-
-interface RuntimeOptions {
-    omitZero: boolean;
-    omitEmptyArray: boolean;
-    excludedProperties: string[];
-}
-
-export class OmitEmpty {
-    public static omitEmpty(obj: unknown, options: OmitEmptyOptions = {}): unknown {
-        const runtimeOpts = OmitEmpty._buildRuntimeOpts(options);
-
-        const omit = (value: unknown, opts: RuntimeOptions): unknown => {
-            if (Array.isArray(value)) {
-                value = value.map(v => omit(v, opts)).filter(v => !OmitEmpty.isEmpty(v, opts));
-            }
-
-            if (OmitEmpty.getType(value) === "object" && value !== null) {
-                const result: Record<string, unknown> = {};
-                for (const key of Object.keys(value as Record<string, unknown>)) {
-                    if (!opts.excludedProperties.includes(key)) {
-                        const val = omit((value as Record<string, unknown>)[key], opts);
-                        if (val !== void 0) {
-                            result[key] = val;
-                        }
-                    }
-                }
-                value = result;
-            }
-
-            if (!OmitEmpty.isEmpty(value, opts)) {
-                return value;
-            }
-        };
-
-        const res = omit(obj, runtimeOpts);
-        if (res === void 0) {
-            return OmitEmpty.getType(obj) === "object" ? {} : res;
-        }
-        return res;
-    }
-
-
-    private static _buildRuntimeOpts(options: OmitEmptyOptions = {}): RuntimeOptions {
-        return {
-            omitZero: options.omitZero || false,
-            omitEmptyArray: options.omitEmptyArray || false,
-            excludedProperties: options.excludedProperties || []
-        };
-    };
-
-    private static getType(value: unknown): string {
-        if (value === null) return "null";
-        if (value === undefined) return "undefined";
-        if (Array.isArray(value)) return "array";
-        if (value instanceof Date) return "date";
-        if (value instanceof RegExp) return "regexp";
-        if (value instanceof Error) return "error";
-        if (value instanceof Map) return "map";
-        if (value instanceof Set) return "set";
-        if (value instanceof File) return "file";
-        
-        const type = typeof value;
-        if (type === "object") {
-            // Check if it's an arguments object
-            if (Object.prototype.toString.call(value) === '[object Arguments]') {
-                return "arguments";
-            }
-        }
-        return type;
-    }
-
-    private static isEmpty(value: unknown, runtimeOpts: RuntimeOptions): boolean {
-        switch (OmitEmpty.getType(value)) {
-            case "null":
-            case "undefined":
-                return true;
-            case "boolean":
-            case "function":
-            case "date":
-            case "regexp":
-                return false;
-            case "string":
-            case "arguments":
-                return (value as string).length === 0;
-            case "file":
-            case "map":
-            case "set":
-                return (value as { size: number }).size === 0;
-            case "number":
-                return runtimeOpts.omitZero ? value === 0 : false;
-            case "error":
-                return (value as Error).message === "";
-            case "array":
-                if (runtimeOpts.omitEmptyArray) {
-                    for (const ele of (value as unknown[])) {
-                        if (!OmitEmpty.isEmpty(ele, runtimeOpts)) {
-                            return false;
-                        }
-                    }
-                    return true;
-                } else {
-                    return false;
-                }
-            case "object":
-                for (const key of Object.keys(value as Record<string, unknown>)) {
-                    if (!OmitEmpty.isEmpty((value as Record<string, unknown>)[key], runtimeOpts)) {
-                        return false;
-                    }
-                }
-                return true;
-            default: {
-                return true;
-            }
-        }
-    }
-
-}