@churchapps/apihelper 0.0.1

package/src/controllers/CustomBaseController.ts

@@ -0,0 +1,74 @@
+import { BaseHttpController } from "inversify-express-utils";
+import express from "express";
+import { LoggingHelper } from "../helpers/LoggingHelper";
+import { AuthenticatedUser, Principal } from "../auth"
+
+export class CustomBaseController extends BaseHttpController {
+
+    public logger: LoggingHelper;
+
+    constructor() {
+        super()
+        this.logger = LoggingHelper.getCurrent();
+    }
+
+    public error(errors: string[]) {
+        return this.json({ errors }, 500);
+    }
+
+    public denyAccess(errors: string[]) {
+        return this.json({ errors }, 401);
+    }
+
+    public authUser(): AuthenticatedUser {
+        if (this.httpContext.user === null) return new AuthenticatedUser(new Principal({}));
+        else return new AuthenticatedUser(this.httpContext.user);
+    }
+
+    public include(req: express.Request, item: string) {
+        let result = false;
+        if (req.query.include !== undefined) {
+            const value: string = req.query.include as string;
+            const items = value.split(",");
+            if (items.indexOf(item) > -1) result = true;
+        }
+        return result;
+    }
+
+    public async actionWrapper(req: express.Request, res: express.Response, fetchFunction: (au: AuthenticatedUser) => any): Promise<any> {
+        try {
+            const result = await fetchFunction(this.authUser());
+            await this.logger.flush();
+            return result;
+        } catch (e:any) {
+            try {
+                this.logger.error(e);
+                await this.logger.flush();
+            } catch (e) {
+                console.log(e);
+            }
+
+            return this.internalServerError(e);
+        }
+    }
+
+    public async actionWrapperAnon(req: express.Request, res: express.Response, fetchFunction: () => any): Promise<any> {
+        try {
+            const result = await fetchFunction();
+            await this.logger.flush();
+            return result;
+        } catch (e:any) {
+            try {
+                this.logger.error(e);
+                await this.logger.flush();
+            } catch (e) {
+                console.log(e);
+            }
+
+            return this.internalServerError(e);
+        }
+    }
+
+
+
+}

package/src/controllers/ErrorController.ts

@@ -0,0 +1,33 @@
+import { controller, httpPost, httpGet, interfaces, requestParam, httpDelete } from "inversify-express-utils";
+import express from "express";
+import { CustomBaseController } from "./CustomBaseController"
+import { ErrorLog } from "../models"
+
+
+@controller("/errors")
+export class ErrorController extends CustomBaseController {
+
+    @httpPost("/")
+    public async save(req: express.Request<{}, {}, ErrorLog[]>, res: express.Response): Promise<any> {
+        // try {
+        /*
+        try {
+            au = this.authUser();
+        } catch (e) {
+            this.logger.log(req.body[0].application, "info", e);
+        }*/
+        req.body.forEach(error => {
+            let fullMessage = error.message;
+            if (error.additionalDetails !== undefined) fullMessage += "\n" + error.additionalDetails;
+            // if (au !== null) fullMessage += "\nUser: " + au.id + " Church: " + au.churchId;
+            this.logger.log(error.application, error.level, fullMessage);
+        });
+        await this.logger.flush();
+        return req.body;
+        // } catch (e) {
+        // console.log(e)
+        // };
+
+    }
+
+}

package/src/controllers/index.ts

@@ -0,0 +1,2 @@
+export { CustomBaseController } from "./CustomBaseController";
+export { ErrorController } from "./ErrorController";

package/src/helpers/AwsHelper.ts

@@ -0,0 +1,108 @@
+import AWS from "aws-sdk"
+import { ByteBuffer } from "aws-sdk/clients/cloudtrail";
+import { EnvironmentBase } from "./EnvironmentBase";
+
+export class AwsHelper {
+
+  private static S3() {
+    return new AWS.S3({ apiVersion: "2006-03-01" });
+  }
+
+  static S3PresignedUrl(key: string): Promise<any> {
+    if (key.indexOf("/") === 0) key = key.substring(1, key.length);
+    return new Promise((resolve, reject) => {
+      const params: AWS.S3.PresignedPost.Params = { Bucket: EnvironmentBase.s3Bucket }
+
+      params.Conditions = [
+        { acl: "public-read" },
+        { bucket: EnvironmentBase.s3Bucket },
+        { key },
+        ["starts-with", "$Content-Type", ""],
+      ];
+
+      params.Expires = 1200;
+      this.S3().createPresignedPost(params, (error: Error, data: any) => {
+        if (error) reject(error);
+        else {
+          data.key = key;
+          resolve(data);
+        }
+      });
+    });
+  }
+
+  static S3Upload(key: string, contentType: string, contents: ByteBuffer): Promise<void> {
+    if (key.indexOf("/") === 0) key = key.substring(1, key.length);
+    return new Promise((resolve, reject) => {
+      const params: AWS.S3.PutObjectRequest = { Bucket: EnvironmentBase.s3Bucket, Key: key, Body: contents, ACL: "public-read", ContentType: contentType }
+      this.S3().upload(params, (error: Error, data: AWS.S3.ManagedUpload.SendData) => {
+        if (error) reject(error);
+        else resolve();
+      });
+    });
+  }
+
+  static S3Move(oldKey: string, newKey: string): Promise<void> {
+    return new Promise((resolve, reject) => {
+      const params: AWS.S3.CopyObjectRequest = { Bucket: EnvironmentBase.s3Bucket, Key: newKey, CopySource: EnvironmentBase.s3Bucket + "/" + oldKey }
+      this.S3().copyObject(params, (error: Error, data: AWS.S3.DeleteObjectOutput) => {
+        if (error) reject(error);
+        else {
+          this.S3Remove(oldKey).then(() => {
+            resolve();
+          })
+        }
+      });
+    });
+  }
+
+  static S3Remove(key: string): Promise<void> {
+    if (key.indexOf("/") === 0) key = key.substring(1, key.length - 1);
+    return new Promise((resolve, reject) => {
+      const params: AWS.S3.PutObjectRequest = { Bucket: EnvironmentBase.s3Bucket, Key: key }
+      this.S3().deleteObject(params, (error: Error, data: AWS.S3.DeleteObjectOutput) => {
+        if (error) reject(error);
+        else resolve();
+      });
+    });
+  }
+
+  static async S3Rename(oldKey: string, newKey: string): Promise<void> {
+    await this.S3Copy(oldKey, newKey);
+    await this.S3Remove(oldKey);
+  }
+
+  static S3Copy(oldKey: string, newKey: string): Promise<void> {
+    return new Promise((resolve, reject) => {
+      const source = "/" + EnvironmentBase.s3Bucket + "/" + oldKey;
+      const params: AWS.S3.CopyObjectRequest = { Bucket: EnvironmentBase.s3Bucket, Key: newKey, CopySource: source, ACL: "public-read" }
+      this.S3().copyObject(params, (error: Error, data: AWS.S3.DeleteObjectOutput) => {
+        if (error) reject(error);
+        else resolve();
+      });
+    });
+  }
+
+  static async S3List(path: string): Promise<string[]> {
+    return new Promise((resolve, reject) => {
+      this.S3().listObjectsV2({ Bucket: EnvironmentBase.s3Bucket, Prefix: path, MaxKeys: 100000 }, (error: Error, data: AWS.S3.ListObjectsV2Output) => {
+        if (error) reject(error);
+        else {
+          const result: string[] = [];
+          data.Contents.forEach(v => { result.push(v.Key) });
+          resolve(result)
+        }
+      });
+    });
+  }
+
+  static async S3Read(key: string): Promise<any> {
+    return new Promise((resolve, reject) => {
+      this.S3().getObject({ Bucket: EnvironmentBase.s3Bucket, Key: key }, (error: Error, data: AWS.S3.GetObjectOutput) => {
+        if (error) resolve(null);
+        else resolve(data.Body.toString());
+      });
+    });
+  }
+
+}

package/src/helpers/BasePermissions.ts

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

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

package/src/helpers/DBCreator.ts

@@ -0,0 +1,39 @@
+import dotenv from "dotenv";
+import fs from "fs-extra";
+import { DB } from "./DB";
+
+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/apiBase/tools/dbScripts/" + td.file, false);
+    return;
+  }
+
+  public static async runScript(title: string, file: string, customDelimeter: boolean) {
+    console.log("Creating '" + title + "'");
+    const sql = await fs.readFile(file, { encoding: "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

@@ -0,0 +1,66 @@
+import AWS from 'aws-sdk'
+import nodemailer from 'nodemailer'
+import directTransport from 'nodemailer-direct-transport'
+import { EnvironmentBase, IEmailPayload } from '.'
+import fs from "fs";
+import path from "path";
+
+export class EmailHelper {
+
+  public static async sendTemplatedEmail(from: string, to: string, appName: string, appUrl: string, subject: string, contents: string, emailTemplate: "EmailTemplate.html" | "ChurchEmailTemplate.html" = "EmailTemplate.html") {
+    if (!appName) appName = "Chums";
+    if (!appUrl) appUrl = "https://chums.org";
+
+    const template = EmailHelper.readTemplate(emailTemplate);
+    const emailBody = template
+      .replace("{appLink}", "<a href=\"" + appUrl + "/\">" + appName + "</a>")
+      .replace("{contents}", contents);
+    await EmailHelper.sendEmail({ from, to, subject, body: emailBody });
+  }
+
+  public static readTemplate(templateFile?: string) {
+    if (!templateFile) templateFile = "EmailTemplate.html";
+    const filePath = path.join(__dirname, "../../templates/" + templateFile);
+    const buffer = fs.readFileSync(filePath);
+    const contents = buffer.toString();
+    return contents;
+  }
+
+  public static sendEmail({ from, to, subject, body }: IEmailPayload) {
+    return new Promise(async (resolve, reject) => {
+      try {
+        let transporter: nodemailer.Transporter = nodemailer.createTransport(directTransport({
+          name: "churchapps.org"
+        }));
+
+        if (EnvironmentBase.mailSystem === 'SES') {
+          AWS.config.update({ region: 'us-east-2' });
+          const ses = new AWS.SES({ apiVersion: '2010-12-01' });
+          transporter = nodemailer.createTransport({ SES: { ses, aws: AWS } })
+        }
+        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 });
+        resolve(null);
+      } catch (err) {
+        reject(err);
+      }
+
+    })
+  }
+
+}

package/src/helpers/EncryptionHelper.ts

@@ -0,0 +1,25 @@
+import crypto from "crypto";
+import { EnvironmentBase } from ".";
+
+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

@@ -0,0 +1,35 @@
+
+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 populateBase(jsonData: any) {
+    EnvironmentBase.appName = jsonData.appName;
+    EnvironmentBase.appEnv = jsonData.appEnv;
+    EnvironmentBase.connectionString = process.env.CONNECTION_STRING;
+    EnvironmentBase.contentRoot = jsonData.contentRoot;
+    EnvironmentBase.encryptionKey = process.env.ENCRYPTION_KEY;
+    EnvironmentBase.fileStore = jsonData.fileStore;
+    EnvironmentBase.jwtSecret = process.env.JWT_SECRET;
+    EnvironmentBase.mailSystem = jsonData.mailSystem;
+    EnvironmentBase.s3Bucket = jsonData.s3Bucket;
+    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

@@ -0,0 +1,71 @@
+import { AwsHelper } from "./AwsHelper";
+import fs from "fs";
+import path from "path";
+import { EnvironmentBase } from ".";
+
+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

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

package/src/helpers/LoggingHelper.ts

@@ -0,0 +1,75 @@
+import winston from "winston";
+import WinstonCloudWatch from "winston-cloudwatch";
+import AWS from "aws-sdk";
+import { EnvironmentBase } from ".";
+
+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) {
+    if (this._logger === null) this.init("API");
+    this.pendingMessages = true;
+    if (EnvironmentBase.appEnv === "dev") console.log(msg);
+    this._logger.error(msg);
+    this._logger.error(new Error().stack.toString());
+  }
+
+  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

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