Move packages/apps back

packages/metamigo-common/.eslintrc.js

@@ -0,0 +1,13 @@
+require('@digiresilience/eslint-config-metamigo/patch/modern-module-resolution');
+module.exports = {
+  extends: [
+    "@digiresilience/eslint-config-metamigo/profile/node",
+    "@digiresilience/eslint-config-metamigo/profile/typescript"
+  ],
+  rules: {
+    // TODO: enable this after jest fixes this issue https://github.com/nodejs/node/issues/38343
+    "unicorn/prefer-node-protocol": "off"
+  },
+  parserOptions: { tsconfigRootDir: __dirname }
+};
+

packages/metamigo-common/.gitignore

@@ -0,0 +1,13 @@
+.idea/*
+.nyc_output
+build
+node_modules
+test
+src/*/*.js
+coverage
+*.log
+package-lock.json
+.npmrc
+.yalc
+yalc.lock
+junit.xml

packages/metamigo-common/.npmignore

@@ -0,0 +1,13 @@
+.eslintrc.js
+.editorconfig
+.prettierignore
+.versionrc
+Makefile
+.gitlab-ci.yml
+coverage
+jest*
+tsconfig*
+*.log
+test*
+.yalc
+yalc.lock

packages/metamigo-common/.prettierignore

@@ -0,0 +1,2 @@
+# package.json is formatted by package managers, so we ignore it here
+package.json

packages/metamigo-common/babel.config.json

@@ -0,0 +1,5 @@
+{
+  "presets": [
+    "@digiresilience/babel-preset-metamigo"
+  ]
+}

packages/metamigo-common/config/app-meta.ts

@@ -0,0 +1,31 @@
+import { ConvictSchema } from "./types";
+
+export interface IAppMetaConfig {
+  name: string;
+  version: string;
+  figletFont: string;
+}
+
+export const AppMetaConfig: ConvictSchema<IAppMetaConfig> = {
+  version: {
+    doc: "The current application version",
+    format: String,
+    env: "npm_package_version",
+    default: null,
+    skipGenerate: true,
+  },
+  name: {
+    doc: "Application name",
+    format: String,
+    env: "npm_package_name",
+    default: null,
+    skipGenerate: true,
+  },
+  figletFont: {
+    doc: "The figlet font name used to print the site name on boot",
+    format: String,
+    env: "FIGLET_FONT",
+    default: "Sub-Zero",
+    skipGenerate: true,
+  },
+};

packages/metamigo-common/config/auth.ts

@@ -0,0 +1,23 @@
+import { ConvictSchema } from "./types";
+
+export interface ISessionConfig {
+  sessionMaxAgeSeconds: number;
+  sessionUpdateAgeSeconds: number;
+}
+
+export const SessionConfig: ConvictSchema<ISessionConfig> = {
+  sessionMaxAgeSeconds: {
+    doc: "How long in seconds until an idle session expires and is no longer valid.",
+    format: "positiveInt",
+    default: 30 * 24 * 60 * 60, // 30 days
+    env: "SESSION_MAX_AGE_SECONDS",
+  },
+  sessionUpdateAgeSeconds: {
+    doc: `Throttle how frequently in seconds to write to database to extend a session.
+          Use it to limit write operations. Set to 0 to always update the database.
+          Note: This option is ignored if using JSON Web Tokens`,
+    format: "positiveInt",
+    default: 24 * 60 * 60, // 24 hours
+    env: "SESSION_UPDATE_AGE_SECONDS",
+  },
+};

packages/metamigo-common/config/cors.ts

@@ -0,0 +1,32 @@
+import { ConvictSchema } from "./types";
+
+export interface ICorsConfig {
+  allowedMethods: Array<string>;
+  allowedOrigins: Array<string>;
+  allowedHeaders: Array<string>;
+}
+
+export const CorsConfig: ConvictSchema<ICorsConfig> = {
+  allowedMethods: {
+    doc: "The allowed CORS methods",
+    format: "Array",
+    env: "CORS_ALLOWED_METHODS",
+    default: ["GET", "PUT", "POST", "PATCH", "DELETE", "HEAD", "OPTIONS"],
+  },
+  allowedOrigins: {
+    doc: "The allowed origins",
+    format: "Array",
+    env: "CORS_ALLOWED_ORIGINS",
+    default: [],
+  },
+  allowedHeaders: {
+    doc: "The allowed headers",
+    format: "Array",
+    env: "CORS_ALLOWED_HEADERS",
+    default: [
+      "content-type",
+      "authorization",
+      "cf-access-authenticated-user-email",
+    ],
+  },
+};

packages/metamigo-common/config/formats.ts

@@ -0,0 +1,58 @@
+import * as Joi from "joi";
+import type { Format } from "convict";
+
+const coerceString = (v: any): string => v.toString();
+const validator = (s: any) => (v: any) => Joi.assert(v, s);
+
+const url = Joi.string().uri({
+  scheme: ["http", "https"],
+});
+const ip = Joi.string().ip({ version: ["ipv4", "ipv6"], cidr: "optional" });
+
+/**
+ * Additional configuration value formats for convict.
+ *
+ * You can use these to achieve richer validation for your configuration.
+ */
+export const MetamigoConvictFormats: { [index: string]: Format } = {
+  positiveInt: {
+    name: "positveInt",
+    coerce: (n: string): number => Number.parseInt(n, 10),
+    validate: validator(Joi.number().positive().integer()),
+  },
+  port: {
+    name: "port",
+    coerce: (n: string): number => Number.parseInt(n, 10),
+    validate: validator(Joi.number().port()),
+  },
+  ipaddress: {
+    name: "ipaddress",
+    coerce: coerceString,
+    validate: validator(ip),
+  },
+  url: {
+    name: "url",
+    coerce: coerceString,
+    validate: validator(url),
+  },
+  uri: {
+    name: "uri",
+    coerce: coerceString,
+    validate: validator(Joi.string().uri()),
+  },
+  optionalUri: {
+    name: "uri",
+    coerce: coerceString,
+    validate: validator(Joi.string().uri().allow("")),
+  },
+  email: {
+    name: "email",
+    coerce: coerceString,
+    validate: validator(Joi.string().email()),
+  },
+  uuid: {
+    name: "uuid",
+    coerce: coerceString,
+    validate: validator(Joi.string().guid()),
+  },
+};

packages/metamigo-common/config/generate.ts

@@ -0,0 +1,44 @@
+import convict from "convict";
+
+const visitLeaf = (acc: any, key: any, leaf: any) => {
+  if (leaf.skipGenerate) {
+    return;
+  }
+
+  if (leaf.default === undefined) {
+    acc[key] = undefined;
+  } else {
+    acc[key] = leaf.default;
+  }
+};
+
+const visitNode = (acc: any, node: any, key = "") => {
+  if (node._cvtProperties) {
+    const keys = Object.keys(node._cvtProperties);
+    let subacc: any;
+    if (key === "") {
+      subacc = acc;
+    } else {
+      subacc = {};
+      acc[key] = subacc;
+    }
+
+    keys.forEach((key) => {
+      visitNode(subacc, node._cvtProperties[key], key);
+    });
+    // In the case that the entire sub-tree specified skipGenerate, remove the empty node
+    if (Object.keys(subacc).length === 0) {
+      delete acc[key];
+    }
+  } else {
+    visitLeaf(acc, key, node);
+  }
+};
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const generateConfig = (conf: convict.Config<any>): unknown => {
+  const schema = conf.getSchema();
+  const generated = {};
+  visitNode(generated, schema);
+  return JSON.stringify(generated, undefined, 1);
+};

packages/metamigo-common/config/index.ts

@@ -0,0 +1,142 @@
+import process from "process";
+import convict, { SchemaObj } from "convict";
+import { IServerConfig, ServerConfig } from "./server";
+import { IMetricsConfig, MetricsConfig } from "./metrics-server";
+import { IAppMetaConfig, AppMetaConfig } from "./app-meta";
+import { ICorsConfig, CorsConfig } from "./cors";
+import { ILoggingConfig, LoggingConfig } from "./logging";
+import { ExtendedConvict } from "./types";
+import { MetamigoConvictFormats } from "./formats";
+
+type IEnvConfig = "production" | "development" | "test";
+
+const EnvConfig: SchemaObj<IEnvConfig> = {
+  doc: "The application environment",
+  format: ["production", "development", "test"],
+  default: "development",
+  env: "NODE_ENV",
+};
+
+export const configBaseSchema = {
+  env: EnvConfig,
+  server: ServerConfig,
+  meta: AppMetaConfig,
+  cors: CorsConfig,
+  metrics: MetricsConfig,
+  logging: LoggingConfig,
+};
+
+/**
+ *
+ * The metamigo base configuration object. Use this for easy typed access to your
+ * config.
+ *
+ */
+interface IMetamigoConfig {
+  env: IEnvConfig;
+  server: IServerConfig;
+  meta: IAppMetaConfig;
+  cors: ICorsConfig;
+  metrics: IMetricsConfig;
+  logging: ILoggingConfig;
+  isProd?: boolean;
+  isTest?: boolean;
+  isDev?: boolean;
+  frontend: any;
+  nextAuth: any;
+}
+export type IMetamigoConvict = ExtendedConvict<IMetamigoConfig>;
+
+export type {
+  IServerConfig,
+  IMetricsConfig,
+  IAppMetaConfig,
+  ICorsConfig,
+  ILoggingConfig,
+  IMetamigoConfig,
+};
+
+export * from "./formats";
+export * from "./generate";
+export * from "./print";
+export * from "./types";
+
+/**
+ * Loads your applications configuration from environment variables and configuration files (see METAMIGO_CONFIG).
+ *
+ * @param schema your schema definition
+ * @param override an optional object with config value that will override defaults but not  config files and env vars (see [convict precedence docs](https://github.com/mozilla/node-convict/tree/master/packages/convict#precedence-order ))
+ * @returns the raw convict config object
+ */
+export const loadConfigurationRaw = async <T extends IMetamigoConfig>(
+  schema: convict.Schema<T>,
+  override?: Partial<T>
+): Promise<ExtendedConvict<T>> => {
+  convict.addFormats(MetamigoConvictFormats);
+  const config: ExtendedConvict<T> = convict(schema);
+
+  const env = config.get("env");
+
+  config.isProd = env === "production";
+  config.isTest = env === "test";
+  config.isDev = env === "development";
+
+  try {
+    if (process.env.METAMIGO_CONFIG) {
+      config.loadFile(process.env.METAMIGO_CONFIG);
+    }
+  } catch (error) {
+    const msg = `
+
+
+🚫 Your application's configuration is invalid JSON. 🚫
+
+${error}
+
+`;
+    throw new Error(msg);
+  }
+
+  if (override) {
+    config.load(override);
+  }
+
+  try {
+    config.validate({ allowed: "strict" });
+  } catch (error: any) {
+    const msg = `
+
+
+🚫 Your application's configuration is invalid. 🚫
+
+${error.message}
+
+`;
+    throw new Error(msg);
+  }
+
+  // set our helpers
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const configDirty = config as any;
+
+  configDirty.set("isProd", config.isProd);
+  configDirty.set("isTest", config.isTest);
+  configDirty.set("isDev", config.isDev);
+
+  return config;
+};
+
+/**
+ * Loads your applications configuration from environment variables and configuration files (see METAMIGO_CONFIG).
+ *
+ * @param schema your schema definition
+ * @param override an optional object with config value that will override defaults but not config files and env vars (see [convict precedence docs](https://github.com/mozilla/node-convict/tree/master/packages/convict#precedence-order ))
+ * @returns a vanilla javascript object with the config loaded values
+ */
+export const loadConfiguration = async <T extends IMetamigoConfig>(
+  schema: convict.Schema<T>,
+  override?: Partial<T>
+): Promise<T> => {
+  const c = await loadConfigurationRaw(schema, override);
+  return c.getProperties();
+};

packages/metamigo-common/config/logging.ts

@@ -0,0 +1,90 @@
+import { ConvictSchema } from "./types";
+
+export interface ILoggingConfig {
+  level: string;
+  sql: boolean;
+  redact: string[];
+  ignorePaths: string[];
+  ignoreTags: string[];
+  requestIdHeader: string;
+  logRequestStart: boolean;
+  logRequestComplete: boolean;
+  logRequestPayload: boolean;
+  logRequestQueryParams: boolean;
+  prettyPrint: boolean | "auto";
+}
+
+export const LoggingConfig: ConvictSchema<ILoggingConfig> = {
+  level: {
+    doc: "The logging level",
+    format: ["trace", "debug", "info", "warn", "error"],
+    default: "info",
+    env: "LOG_LEVEL",
+  },
+  sql: {
+    doc: "Whether to log sql statements",
+    format: "Boolean",
+    default: false,
+    env: "LOG_SQL",
+  },
+  redact: {
+    doc: "Pino redaction array. These are always redacted. see https://getpino.io/#/docs/redaction",
+    format: "Array",
+    default: [
+      "req.remoteAddress",
+      "req.headers.authorization",
+      `req.headers["cf-access-jwt-assertion"]`,
+      `req.headers["cf-access-authenticated-user-email"]`,
+      `req.headers["cf-connecting-ip"]`,
+      `req.headers["cf-ipcountry"]`,
+      `req.headers["x-forwarded-for"]`,
+      "req.headers.cookie",
+    ],
+  },
+  ignorePaths: {
+    doc: "Ignore http paths (exact) when logging requests",
+    format: "Array",
+    default: ["/graphql"],
+  },
+  ignoreTags: {
+    doc: "Ignore routes tagged with these tags when logging requests",
+    format: "Array",
+    default: ["status", "swagger", "nolog"],
+  },
+  requestIdHeader: {
+    doc: "The header where the request id lives",
+    format: String,
+    default: "x-request-id",
+    env: "REQUEST_ID_HEADER",
+  },
+  logRequestStart: {
+    doc: "Whether hapi-pino should add a log.info() at the beginning of Hapi requests for the given Request.",
+    format: "Boolean",
+    default: false,
+    env: "LOG_REQUEST_START",
+  },
+  logRequestComplete: {
+    doc: "Whether hapi-pino should add a log.info() at the completion of Hapi requests for the given Request.",
+    format: "Boolean",
+    default: true,
+    env: "LOG_REQUEST_COMPLETE",
+  },
+  logRequestPayload: {
+    doc: "When enabled, add the request payload as payload to the response event log.",
+    format: "Boolean",
+    default: false,
+    env: "LOG_REQUEST_PAYLOAD",
+  },
+  logRequestQueryParams: {
+    doc: "When enabled, add the request query as queryParams to the response event log.",
+    format: "Boolean",
+    default: false,
+    env: "LOG_REQUEST_QUERY_PARAMS",
+  },
+  prettyPrint: {
+    doc: "Pretty print the logs",
+    format: ["auto", true, false],
+    default: "auto",
+    env: "LOG_PRETTY_PRINT",
+  },
+};

packages/metamigo-common/config/metrics-server.ts

@@ -0,0 +1,22 @@
+import { ConvictSchema } from "./types";
+
+export interface IMetricsConfig {
+  address: string;
+  port: number;
+}
+
+export const MetricsConfig: ConvictSchema<IMetricsConfig> = {
+  address: {
+    doc: "The ip address to bind the prometheus metrics to",
+    format: "ipaddress",
+    default: "127.0.0.1",
+    env: "METRICS_ADDRESS",
+  },
+  port: {
+    doc: "The port to bind the prometheus metrics to",
+    format: "port",
+    default: 3002,
+    env: "METRICS_PORT",
+    arg: "port",
+  },
+};

packages/metamigo-common/config/print.ts

@@ -0,0 +1,41 @@
+import chalk from "chalk";
+import convict from "convict";
+
+const visitLeaf = (path: any, key: any, leaf: any) => {
+  if (leaf.skipGenerate) {
+    return;
+  }
+
+  let name = `${path}.${key}`;
+  if (path.length === 0) name = key;
+  console.log(chalk.green(name));
+  console.log(leaf.doc);
+  if (leaf.default === undefined) {
+    console.log(chalk.red("\t required"));
+  } else {
+    console.log(`\tdefault: ${JSON.stringify(leaf.default)}`);
+  }
+
+  console.log(`\tformat: ${leaf.format}`);
+  console.log(`\tenv: ${leaf.env}`);
+};
+
+const visitNode = (path: any, node: any, key = "") => {
+  if (node._cvtProperties) {
+    const keys = Object.keys(node._cvtProperties);
+    const subpath = key === "" ? path : `${key}`;
+
+    keys.forEach((key) => {
+      visitNode(subpath, node._cvtProperties[key], key);
+    });
+    console.log();
+  } else {
+    visitLeaf(path, key, node);
+  }
+};
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const printConfigOptions = (conf: convict.Config<any>): void => {
+  const schema = conf.getSchema();
+  visitNode("", schema);
+};

packages/metamigo-common/config/server.ts

@@ -0,0 +1,21 @@
+import { ConvictSchema } from "./types";
+
+export interface IServerConfig {
+  address: string;
+  port: number;
+}
+
+export const ServerConfig: ConvictSchema<IServerConfig> = {
+  address: {
+    doc: "The IP address to bind the server to",
+    format: "ipaddress",
+    default: "0.0.0.0",
+    env: "SERVER_ADDRESS",
+  },
+  port: {
+    doc: "The port to bind the server to",
+    format: "port",
+    default: 3001,
+    env: "SERVER_PORT",
+  },
+};

packages/metamigo-common/config/types.ts

@@ -0,0 +1,26 @@
+import convict from "convict";
+
+/*
+interface SSMObj {
+  path: string;
+}
+ */
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+interface ConvictSchemaObj<T = any> extends convict.SchemaObj<T> {
+  // ssm?: SSMObj;
+  /**
+   * The config item will be ignored for purposes of config file generation
+   */
+  skipGenerate?: boolean;
+}
+
+export type ConvictSchema<T> = {
+  [P in keyof T]: convict.Schema<T[P]> | ConvictSchemaObj<T[P]>;
+};
+
+export interface ExtendedConvict<T> extends convict.Config<T> {
+  isProd?: boolean;
+  isTest?: boolean;
+  isDev?: boolean;
+}

packages/metamigo-common/controllers/crud-controller.ts

@@ -0,0 +1,295 @@
+/* eslint-disable @typescript-eslint/ban-types,@typescript-eslint/no-explicit-any,max-params */
+import * as Boom from "@hapi/boom";
+import * as Hapi from "@hapi/hapi";
+import { CrudRepository } from "../records/crud-repository";
+import { createResponse } from "../helpers/response";
+import {
+  PgRecordInfo,
+  UnsavedR,
+  SavedR,
+  KeyType,
+} from "../records/record-info";
+
+/**
+ *
+ * A generic controller that handles exposes a [[CrudRepository]] as HTTP
+ * endpoints with full POST, PUT, GET, DELETE semantics.
+ *
+ * The controller yanks the instance of the crud repository out of the request at runtime.
+ * This assumes you're following the pattern exposed with the hapi-pg-promise plugin.
+ *
+ * @typeParam ID The type of the id column
+ * @typeParam T The type of the record
+ */
+export abstract class AbstractCrudController<
+  TUnsavedR,
+  TSavedR extends TUnsavedR & IdKeyT,
+  IdKeyT extends object
+> {
+  /**
+   * @param repoName the key at which the repository for the record can be accessed (that is, request.db[repoName])
+   * @param paramsIdField the placeholder used in the Hapi route for the id of the record
+   * @param dbDecoration the decorated function on the request to use (defaults to request.db())
+   */
+
+  abstract repoName: string;
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-ignore
+  abstract paramsIdField = "id";
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-ignore
+  abstract dbDecoration = "db";
+  abstract recordType: PgRecordInfo<TUnsavedR, TSavedR, IdKeyT>;
+
+  repo(request: Hapi.Request): CrudRepository<TUnsavedR, TSavedR, IdKeyT> {
+    // @ts-expect-error
+    const db = request[this.dbDecoration];
+    if (!db)
+      throw Boom.badImplementation(
+        `CrudController for table ${this.recordType.tableName} could not find request decoration '${this.dbDecoration}'`
+      );
+    const repo = db()[this.repoName];
+    if (!repo)
+      throw Boom.badImplementation(
+        `CrudController for table ${this.recordType.tableName} could not find repository for '${this.dbDecoration}().${this.repoName}'`
+      );
+    return repo;
+  }
+
+  /**
+   * Creates a new record
+   */
+  public create = async (
+    request: Hapi.Request,
+    toolkit: Hapi.ResponseToolkit
+  ): Promise<any> => {
+    try {
+      // would love to know how to get rid of this double cast hack
+      const payload: TSavedR = <TSavedR>(<any>request.payload);
+      const data: TSavedR = await this.repo(request).insert(payload);
+
+      return toolkit.response(
+        createResponse(request, {
+          value: data,
+        })
+      );
+    } catch (error: any) {
+      return toolkit.response(
+        createResponse(request, {
+          boom: Boom.badImplementation(error),
+        })
+      );
+    }
+  };
+
+  /**
+   * Updates a record by ID. This method can accept partial updates.
+   */
+  public updateById = async (
+    request: Hapi.Request,
+    toolkit: Hapi.ResponseToolkit
+  ): Promise<any> => {
+    try {
+      const payload: Partial<TSavedR> = <any>request.payload;
+      const id: IdKeyT = request.params[this.paramsIdField];
+      const updatedRow: TSavedR = await this.repo(request).updateById(
+        id,
+        payload
+      );
+
+      if (!updatedRow) {
+        return toolkit.response(
+          createResponse(request, {
+            boom: Boom.notFound(),
+          })
+        );
+      }
+
+      return toolkit.response(
+        createResponse(request, {
+          value: updatedRow,
+        })
+      );
+    } catch (error: any) {
+      return toolkit.response(
+        createResponse(request, {
+          boom: Boom.badImplementation(error),
+        })
+      );
+    }
+  };
+
+  /**
+   * Return a record given its id.
+   */
+  public getById = async (
+    request: Hapi.Request,
+    toolkit: Hapi.ResponseToolkit
+  ): Promise<any> => {
+    try {
+      const id: IdKeyT = request.params[this.paramsIdField];
+      // @ts-expect-error
+      const row: TSavedR = await this.repo(request).findById(id);
+
+      if (!row) {
+        return toolkit.response(
+          createResponse(request, {
+            boom: Boom.notFound(),
+          })
+        );
+      }
+
+      return toolkit.response(
+        createResponse(request, {
+          value: row,
+        })
+      );
+    } catch (error: any) {
+      return toolkit.response(
+        createResponse(request, {
+          boom: Boom.badImplementation(error),
+        })
+      );
+    }
+  };
+
+  /**
+   * Return all records.
+   */
+  public getAll = async (
+    request: Hapi.Request,
+    toolkit: Hapi.ResponseToolkit
+  ): Promise<any> => {
+    try {
+      const rows: TSavedR[] = await this.repo(request).findAll();
+
+      return toolkit.response(
+        createResponse(request, {
+          value: rows,
+        })
+      );
+    } catch (error: any) {
+      return toolkit.response(
+        createResponse(request, {
+          boom: Boom.badImplementation(error),
+        })
+      );
+    }
+  };
+
+  /**
+   * Delete a record given its id.
+   */
+  public deleteById = async (
+    request: Hapi.Request,
+    toolkit: Hapi.ResponseToolkit
+  ): Promise<any> => {
+    try {
+      const id: IdKeyT = request.params[this.paramsIdField];
+
+      const count = await this.repo(request).removeById(id);
+
+      if (count === 0) {
+        return createResponse(request, { boom: Boom.notFound() });
+      }
+
+      return toolkit.response(
+        createResponse(request, {
+          value: { id },
+        })
+      );
+    } catch (error: any) {
+      return toolkit.response(
+        createResponse(request, {
+          boom: Boom.badImplementation(error),
+        })
+      );
+    }
+  };
+}
+
+// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+export function unboundCrudController<TRecordInfo extends PgRecordInfo>(
+  aRecordType: TRecordInfo
+) {
+  return class CrudController extends AbstractCrudController<
+    UnsavedR<TRecordInfo>,
+    SavedR<TRecordInfo>,
+    KeyType<TRecordInfo>
+  > {
+    public readonly repoName: string;
+    public readonly paramsIdField;
+    public readonly dbDecoration;
+    public readonly recordType = aRecordType;
+
+    constructor(repoName: string, paramsIdField = "id", dbDecoration = "db") {
+      super();
+      this.repoName = repoName;
+      this.paramsIdField = paramsIdField;
+      this.dbDecoration = dbDecoration;
+    }
+  };
+}
+
+// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+export function CrudControllerBase<Rec extends PgRecordInfo>(recordType: Rec) {
+  return unboundCrudController<Rec>(recordType);
+}
+
+export const crudRoutesFor = (
+  name: string,
+  path: string,
+  controller: AbstractCrudController<any, any, any>,
+  idParam: string,
+  validate: Record<string, Hapi.RouteOptionsValidate>
+): Hapi.ServerRoute[] => [
+    {
+      method: "POST",
+      path: `${path}`,
+      options: {
+        handler: controller.create,
+        validate: validate.create,
+        description: `Method that creates a new ${name}.`,
+        tags: ["api", name],
+      },
+    },
+    {
+      method: "PUT",
+      path: `${path}/{${idParam}}`,
+      options: {
+        handler: controller.updateById,
+        validate: validate.updateById,
+        description: `Method that updates a ${name} by its id.`,
+        tags: ["api", name],
+      },
+    },
+    {
+      method: "GET",
+      path: `${path}/{${idParam}}`,
+      options: {
+        handler: controller.getById,
+        validate: validate.getById,
+        description: `Method that gets a ${name} by its id.`,
+        tags: ["api", name],
+      },
+    },
+    {
+      method: "GET",
+      path: `${path}`,
+      options: {
+        handler: controller.getAll,
+        description: `Method that gets all ${name}s.`,
+        tags: ["api", name],
+      },
+    },
+    {
+      method: "DELETE",
+      path: `${path}/{${idParam}}`,
+      options: {
+        handler: controller.deleteById,
+        validate: validate.deleteById,
+        description: `Method that deletes a ${name} by its id.`,
+        tags: ["api", name],
+      },
+    },
+  ];

packages/metamigo-common/controllers/nextauth-adapter.ts

@@ -0,0 +1,185 @@
+/* eslint-disable unicorn/no-null,max-params */
+import { createHash, randomBytes } from "crypto";
+import type { AdapterInstance } from "next-auth/adapters";
+import omit from "lodash/omit";
+import type { IMetamigoRepositories } from "../records";
+import type { UnsavedAccount, SavedAccount } from "../records/account";
+import type { UserId, UnsavedUser, SavedUser } from "../records/user";
+import type { UnsavedSession, SavedSession } from "../records/session";
+
+// Sessions expire after 30 days of being idle
+export const defaultSessionMaxAge = 30 * 24 * 60 * 60 * 1000;
+// Sessions updated only if session is greater than this value (0 = always)
+export const defaulteSessionUpdateAge = 24 * 60 * 60 * 1000;
+
+const getCompoundId = (providerId: any, providerAccountId: any) =>
+  createHash("sha256")
+    .update(`${providerId}:${providerAccountId}`)
+    .digest("hex");
+
+const randomToken = () => randomBytes(32).toString("hex");
+
+export class NextAuthAdapter<TRepositories extends IMetamigoRepositories>
+  implements AdapterInstance<SavedUser, UnsavedUser, SavedSession>
+{
+  constructor(
+    private repos: TRepositories,
+    private readonly sessionMaxAge = defaultSessionMaxAge,
+    private readonly sessionUpdateAge = defaulteSessionUpdateAge
+  ) { }
+
+  async createUser(profile: UnsavedUser): Promise<SavedUser> {
+    // @ts-expect-error
+    return this.repos.users.upsert(omit(profile, ["isActive", "id"]));
+  }
+
+  async getUser(id: UserId): Promise<SavedUser | null> {
+    const user = await this.repos.users.findById({ id });
+    if (!user) return null;
+    // if a user has no linked accounts, then we do not return it
+    // see: https://github.com/nextauthjs/next-auth/issues/876
+    const accounts = await this.repos.accounts.findAllBy({
+      userId: user.id,
+    });
+
+    if (!accounts || accounts.length === 0) return null;
+    return user;
+  }
+
+  async getUserByEmail(email: string): Promise<SavedUser | null> {
+    const user = await this.repos.users.findBy({ email });
+    if (!user) return null;
+    // if a user has no linked accounts, then we do not return it
+    // see: https://github.com/nextauthjs/next-auth/issues/876
+    const accounts = await this.repos.accounts.findAllBy({
+      userId: user.id,
+    });
+
+    if (!accounts || accounts.length === 0) return null;
+    return user;
+  }
+
+  async getUserByProviderAccountId(
+    providerId: string,
+    providerAccountId: string
+  ): Promise<SavedUser | null> {
+    const account = await this.repos.accounts.findBy({
+      compoundId: getCompoundId(providerId, providerAccountId),
+    });
+    if (!account) return null;
+
+    return this.repos.users.findById({ id: account.userId });
+  }
+
+  async updateUser(user: SavedUser): Promise<SavedUser> {
+    return this.repos.users.update(user);
+  }
+
+  // @ts-expect-error
+  async linkAccount(
+    userId: string,
+    providerId: string,
+    providerType: string,
+    providerAccountId: string,
+    refreshToken: string,
+    accessToken: string,
+    accessTokenExpires: number
+  ): Promise<void> {
+    const exists = await this.repos.users.existsById({ id: userId });
+    if (!exists) return;
+    const account: UnsavedAccount = {
+      accessToken,
+      refreshToken,
+      compoundId: getCompoundId(providerId, providerAccountId),
+      providerAccountId,
+      providerId,
+      providerType,
+      accessTokenExpires: accessTokenExpires
+        ? new Date(accessTokenExpires)
+        : new Date(),
+      userId,
+    };
+    await this.repos.accounts.insert(account);
+  }
+
+  async unlinkAccount(
+    userId: string,
+    providerId: string,
+    providerAccountId: string
+  ): Promise<void> {
+    await this.repos.accounts.removeBy({
+      userId,
+      compoundId: getCompoundId(providerId, providerAccountId),
+    });
+  }
+
+  createSession(user: SavedUser): Promise<SavedSession> {
+    let expires;
+    if (this.sessionMaxAge) {
+      const dateExpires = new Date(Date.now() + this.sessionMaxAge);
+      expires = dateExpires.toISOString();
+    }
+
+    const session: UnsavedSession = {
+      // @ts-expect-error
+      expires,
+      userId: user.id,
+      sessionToken: randomToken(),
+      accessToken: randomToken(),
+    };
+
+    return this.repos.sessions.insert(session);
+  }
+
+  async getSession(sessionToken: string): Promise<SavedSession | null> {
+    const session = await this.repos.sessions.findBy({ sessionToken });
+    if (session && session.expires && new Date() > session.expires) {
+      this.repos.sessions.remove(session);
+      return null;
+    }
+
+    return session;
+  }
+
+  async updateSession(
+    session: SavedSession,
+    force?: boolean
+  ): Promise<SavedSession | null> {
+    if (
+      this.sessionMaxAge &&
+      (this.sessionUpdateAge || this.sessionUpdateAge === 0) &&
+      session.expires
+    ) {
+      // Calculate last updated date, to throttle write updates to database
+      // Formula: ({expiry date} - sessionMaxAge) + sessionUpdateAge
+      //     e.g. ({expiry date} - 30 days) + 1 hour
+      //
+      // Default for sessionMaxAge is 30 days.
+      // Default for sessionUpdateAge is 1 hour.
+      const dateSessionIsDueToBeUpdated = new Date(
+        session.expires.getTime() - this.sessionMaxAge + this.sessionUpdateAge
+      );
+
+      // Trigger update of session expiry date and write to database, only
+      // if the session was last updated more than {sessionUpdateAge} ago
+      if (new Date() > dateSessionIsDueToBeUpdated) {
+        const newExpiryDate = new Date();
+        newExpiryDate.setTime(newExpiryDate.getTime() + this.sessionMaxAge);
+        session.expires = newExpiryDate;
+      } else if (!force) {
+        return null;
+      }
+    } else if (!force) {
+      // If session MaxAge, session UpdateAge or session.expires are
+      // missing then don't even try to save changes, unless force is set.
+      return null;
+    }
+
+    const { expires } = session;
+    return this.repos.sessions.update({ ...session, expires });
+  }
+
+  async deleteSession(sessionToken: string): Promise<void> {
+    await this.repos.sessions.removeBy({ sessionToken });
+  }
+}

packages/metamigo-common/db/types.ts

@@ -0,0 +1,8 @@
+import * as PGP from "pg-promise";
+import * as PGPTS from "pg-promise/typescript/pg-subset";
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type IDatabase = PGP.IDatabase<any>;
+export type IMain = PGP.IMain;
+export type IResult = PGPTS.IResult;
+export type IInitOptions = PGP.IInitOptions;

packages/metamigo-common/hapi.ts

@@ -0,0 +1,123 @@
+import * as Hapi from "@hapi/hapi";
+import * as http from "http";
+import type { HttpTerminator } from "http-terminator";
+import * as Glue from "@hapi/glue";
+import * as Promster from "@promster/hapi";
+import figlet from "figlet";
+import PinoPlugin from "hapi-pino";
+import { createServer as createPrometheusServer } from "@promster/server";
+import { createHttpTerminator } from "http-terminator";
+
+import { getPrettyPrint } from "./logger";
+import RequestIdPlugin from "./plugins/request-id";
+import StatusPlugin from "./plugins/status";
+import ConfigPlugin from "./plugins/config";
+import { IMetamigoConfig } from "./config";
+
+export interface Server {
+  hapiServer: Hapi.Server;
+  promServer?: http.Server;
+  promTerminator?: HttpTerminator;
+}
+export const deployment = async <T extends IMetamigoConfig>(
+  manifest: Glue.Manifest,
+  config: T,
+  start = false
+): Promise<Server> => {
+  const hapiServer: Hapi.Server = await Glue.compose(manifest);
+
+  await hapiServer.initialize();
+
+  if (!start) return { hapiServer };
+
+  await announce(config);
+
+  await hapiServer.start();
+
+  const { port, address } = config.metrics;
+  const promServer = await createPrometheusServer({
+    port,
+    hostname: address,
+  });
+  const promTerminator = createHttpTerminator({
+    server: promServer,
+  });
+
+  console.log(`
+🚀 Server  listening on http://${hapiServer.info.address}:${hapiServer.info.port}
+   Metrics listening on http://${address}:${port}
+`);
+
+  return {
+    hapiServer,
+    promServer,
+    promTerminator,
+  };
+};
+
+export const stopDeployment = async (server: Server): Promise<void> => {
+  await server.hapiServer.stop();
+  if (server.promTerminator) await server.promTerminator.terminate();
+};
+
+export const defaultPlugins = <T extends IMetamigoConfig>(
+  config: T
+): string[] | Glue.PluginObject[] | Array<string | Glue.PluginObject> => {
+  const {
+    logRequestStart,
+    logRequestComplete,
+    logRequestPayload,
+    logRequestQueryParams,
+    level,
+    redact,
+    ignorePaths,
+    ignoreTags,
+    requestIdHeader,
+  } = config.logging;
+  const plugins = [
+    { plugin: ConfigPlugin, options: { config } },
+    {
+      plugin: PinoPlugin,
+      options: {
+        prettyPrint: getPrettyPrint(config),
+        level,
+        logRequestStart,
+        logRequestComplete,
+        logPayload: logRequestPayload,
+        logQueryParams: logRequestQueryParams,
+        redact: {
+          paths: redact,
+          remove: true,
+        },
+        ignorePaths,
+        ignoreTags,
+      },
+    },
+    {
+      plugin: RequestIdPlugin,
+      options: {
+        header: requestIdHeader,
+      },
+    },
+    { plugin: StatusPlugin },
+    { plugin: Promster.createPlugin() },
+  ];
+  // @ts-ignore
+  return plugins;
+};
+
+export const announce = async <T extends IMetamigoConfig>(
+  config: T
+): Promise<void> =>
+  new Promise((resolve, reject) => {
+    // @ts-expect-error
+    figlet.text(
+      config.meta.name,
+      { font: config.meta.figletFont },
+      (err, text) => {
+        if (err) reject(err);
+        console.log(`${text}`);
+        resolve();
+      }
+    );
+  });

packages/metamigo-common/helpers/index.ts

@@ -0,0 +1,44 @@
+/**
+ * Used by Flavor to mark a type in a readable way.
+ */
+export interface Flavoring<FlavorT> {
+  _type?: FlavorT;
+}
+/**
+ *
+ * Create a "flavored" version of a type. TypeScript will disallow mixing
+ * flavors, but will allow unflavored values of that type to be passed in where
+ * a flavored version is expected. This is a less restrictive form of branding.
+ *
+ */
+export type Flavor<T, FlavorT> = T & Flavoring<FlavorT>;
+
+export type UUID = Flavor<string, "A UUID">;
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const deepFreeze = (o: unknown): any => {
+  Object.freeze(o);
+
+  const oIsFunction = typeof o === "function";
+  const hasOwnProp = Object.prototype.hasOwnProperty;
+
+  Object.getOwnPropertyNames(o).forEach((prop) => {
+    if (
+      hasOwnProp.call(o, prop) &&
+      (oIsFunction
+        ? prop !== "caller" && prop !== "callee" && prop !== "arguments"
+        : true) &&
+      // @ts-expect-error
+      o[prop] !== null &&
+      // @ts-expect-error
+      (typeof o[prop] === "object" || typeof o[prop] === "function") &&
+      // @ts-expect-error
+      !Object.isFrozen(o[prop])
+    ) {
+      // @ts-expect-error
+      deepFreeze(o[prop]);
+    }
+  });
+
+  return o;
+};

packages/metamigo-common/helpers/response.ts

@@ -0,0 +1,59 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import * as Boom from "@hapi/boom";
+import * as Hapi from "@hapi/hapi";
+
+interface IResponseMeta {
+  operation?: string;
+  method?: string;
+  paging?: string | null;
+}
+
+interface IResponseError {
+  code?: string | number;
+  message?: string;
+  error?: string;
+}
+
+interface IResponse<T> {
+  meta: IResponseMeta;
+  data: T[];
+  errors: IResponseError[];
+}
+
+interface IResponseOptions<T> {
+  value?: T | null | undefined;
+  boom?: Boom.Boom<any> | null | undefined;
+}
+
+export function createResponse<T>(
+  request: Hapi.Request,
+  { value = undefined, boom = undefined }: IResponseOptions<T>
+): IResponse<T> {
+  const errors: IResponseError[] = [];
+  const data: any = [];
+
+  if (boom) {
+    errors.push({
+      code: boom.output.payload.statusCode,
+      error: boom.output.payload.error,
+      message: boom.output.payload.message,
+    });
+  }
+
+  if (value && data) {
+    if (Array.isArray(value)) {
+      data.push(...value);
+    } else {
+      data.push(value);
+    }
+  }
+
+  return {
+    meta: {
+      method: request.method.toUpperCase(),
+      operation: request.url.pathname,
+    },
+    data,
+    errors,
+  };
+}

packages/metamigo-common/helpers/validation-error.ts

@@ -0,0 +1,62 @@
+import process from "process";
+import * as Hapi from "@hapi/hapi";
+import * as Joi from "joi";
+import Hoek from "@hapi/hoek";
+import * as Boom from "@hapi/boom";
+
+export interface HapiValidationError extends Joi.ValidationError {
+  output: {
+    statusCode: number;
+    headers: Hapi.Utils.Dictionary<string | string[]>;
+    payload: {
+      statusCode: number;
+      error: string;
+      message?: string;
+      validation: {
+        source: string;
+        keys: string[];
+      };
+    };
+  };
+}
+export function defaultValidationErrorHandler(
+  request: Hapi.Request,
+  h: Hapi.ResponseToolkit,
+  err?: Error
+): Hapi.Lifecycle.ReturnValue {
+  // Newer versions of Joi don't format the key for missing params the same way. This shim
+  // provides backwards compatibility. Unfortunately, Joi doesn't export it's own Error class
+  // in JS so we have to rely on the `name` key before we can cast it.
+  //
+  // The Hapi code we're 'overwriting' can be found here:
+  //     https://github.com/hapijs/hapi/blob/master/lib/validation.js#L102
+  if (err && err.name === "ValidationError" && err.hasOwnProperty("output")) {
+    const validationError: HapiValidationError = err as HapiValidationError;
+    const validationKeys: string[] = [];
+
+    validationError.details.forEach((detail) => {
+      if (detail.path.length > 0) {
+        validationKeys.push(Hoek.escapeHtml(detail.path.join(".")));
+      } else {
+        // If no path, use the value sigil to signal the entire value had an issue.
+        validationKeys.push("value");
+      }
+    });
+
+    validationError.output.payload.validation.keys = validationKeys;
+  }
+
+  throw err;
+}
+
+export const validatingFailAction = async (
+  request: Hapi.Request,
+  h: Hapi.ResponseToolkit,
+  err: Error
+): Promise<void> => {
+  if (process.env.NODE_ENV === "production") {
+    throw Boom.badRequest("Invalid request payload input");
+  } else {
+    defaultValidationErrorHandler(request, h, err);
+  }
+};

packages/metamigo-common/index.ts

@@ -0,0 +1,23 @@
+export * from "./config";
+export * from "./controllers/crud-controller";
+export * from "./controllers/nextauth-adapter";
+export * from "./hapi";
+export * from "./helpers";
+export * from "./helpers/response";
+export * from "./helpers/validation-error";
+export * from "./logger";
+export * from "./records";
+
+import * as pino from "pino";
+
+declare module "@hapi/hapi" {
+  interface Server {
+    // @ts-ignore
+    logger: pino.Logger;
+  }
+
+  interface Request {
+    // @ts-ignore
+    logger: pino.Logger;
+  }
+}

packages/metamigo-common/logger.ts

@@ -0,0 +1,22 @@
+import pino, { LoggerOptions } from "pino";
+import { IMetamigoConfig } from "./config";
+
+export const getPrettyPrint = <T extends IMetamigoConfig>(config: T): boolean => {
+  const { prettyPrint } = config.logging;
+  if (prettyPrint === "auto") return config?.isDev || false;
+  return prettyPrint === true;
+};
+
+export const configureLogger = <T extends IMetamigoConfig>(
+  config: T
+): pino.Logger => {
+  const { level, redact } = config.logging;
+  const options: LoggerOptions = {
+    level,
+    redact: {
+      paths: redact,
+      remove: true,
+    },
+  };
+  return pino(options);
+};

packages/metamigo-common/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "common",
+  "version": "0.2.0",
+  "description": "",
+  "main": "build/main/index.js",
+  "types": "build/main/index.d.ts",
+  "author": "Abel Luck <abel@guardianproject.info>",
+  "license": "AGPL-3.0-or-later",
+  "private": false,
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "fix:lint": "eslint src --ext .ts --fix",
+    "fix:prettier": "prettier \"src/**/*.ts\" --write",
+    "test": "yarn test:jest && yarn test:lint && yarn test:prettier",
+    "test:lint": "eslint src --ext .ts",
+    "test:prettier": "prettier \"src/**/*.ts\" --list-different",
+    "test:jest": "jest --coverage --forceExit --detectOpenHandles --reporters=default --reporters=jest-junit",
+    "doc": "yarn run doc:html",
+    "doc:html": "typedoc src/ --exclude '**/*.test.ts' --exclude '**/*.spec.ts' --name $npm_package_name --readme README.md --target es2019 --mode file --out build/docs",
+    "watch:build": "tsc -p tsconfig.json -w"
+  },
+  "devDependencies": {
+    "@types/figlet": "^1.5.5",
+    "@types/lodash": "^4.14.191",
+    "@types/node": "*",
+    "@types/uuid": "^9.0.0",
+    "camelcase-keys": "^8.0.2",
+    "pg-monitor": "^2.0.0",
+    "typedoc": "^0.23.24"
+  },
+  "dependencies": {
+    "@digiresilience/hapi-nextauth": "0.2.1",
+    "@hapi/boom": "^10.0.0",
+    "@hapi/glue": "^9.0.0",
+    "@hapi/hapi": "^21.2.0",
+    "@hapi/hoek": "^11.0.2",
+    "@hapi/inert": "^7.0.0",
+    "@hapi/vision": "^7.0.0",
+    "@hapipal/schmervice": "^2.1.0",
+    "@promster/hapi": "^8.0.6",
+    "@promster/server": "^7.0.8",
+    "@promster/types": "^3.2.5",
+    "@types/convict": "^6.1.1",
+    "@types/hapi__glue": "^6.1.6",
+    "@types/hapi__hapi": "^20.0.13",
+    "@types/hapi__inert": "^5.2.4",
+    "@types/hapi__vision": "^5.5.4",
+    "@types/hapi-pino": "^9.1.2",
+    "@types/hapipal__schmervice": "^2.0.3",
+    "@types/joi": "^17.2.3",
+    "chalk": "^5.2.0",
+    "commander": "^10.0.0",
+    "convict": "^6.2.4",
+    "decamelcase-keys": "^1.1.1",
+    "figlet": "^1.5.2",
+    "hapi-pino": "^11.0.1",
+    "http-terminator": "^3.2.0",
+    "joi": "^17.7.0",
+    "lodash": "^4.17.21",
+    "pg-promise": "^11.0.2",
+    "pino": "^8.8.0",
+    "prom-client": "^14.x.x",
+    "uuid": "^9.0.0"
+  }
+}

packages/metamigo-common/plugins/config.ts

@@ -0,0 +1,23 @@
+import { Server } from "@hapi/hapi";
+import cloneDeep from "lodash/cloneDeep";
+import { deepFreeze } from "../helpers";
+
+interface ConfigOptions {
+  config: unknown;
+}
+
+const register = async (
+  server: Server,
+  options: ConfigOptions
+): Promise<void> => {
+  const safeConfig = deepFreeze(cloneDeep(options.config));
+  server.decorate("server", "config", () => safeConfig);
+};
+
+const ConfigPlugin = {
+  register,
+  name: "config",
+  version: "0.0.1",
+};
+
+export default ConfigPlugin;

packages/metamigo-common/plugins/request-id.ts

@@ -0,0 +1,37 @@
+import { Server } from "@hapi/hapi";
+import { v4 as uuid } from "uuid";
+
+interface RequestIdOptions {
+  header?: string;
+}
+
+const register = async (
+  server: Server,
+  options?: RequestIdOptions
+): Promise<void> => {
+  const header = options?.header || "x-request-id";
+  server.ext("onPreResponse", async (request, h) => {
+    if (!request.response) {
+      return h.continue;
+    }
+
+    if ("isBoom" in request.response) {
+      const id = request.response.output.headers[header] || uuid();
+      request.response.output.headers[header] = id;
+    } else {
+      const id = request.headers[header] || uuid();
+      // @ts-ignore
+      request.response.header(header, id);
+    }
+
+    return h.continue;
+  });
+};
+
+const RequestIdPlugin = {
+  register,
+  name: "request-id",
+  version: "0.0.1",
+};
+
+export default RequestIdPlugin;

packages/metamigo-common/plugins/status.ts

@@ -0,0 +1,60 @@
+import { Server, RouteOptionsAccess } from "@hapi/hapi";
+import { Prometheus } from "@promster/hapi";
+
+interface StatusOptions {
+  path?: string;
+  auth?: RouteOptionsAccess;
+}
+
+const count = (statusCounter: any) => async () => {
+  statusCounter.inc();
+  return "Incremented metamigo_status_test counter";
+};
+
+const ping = async () => "OK";
+
+const statusRoutes = (server: Server, opt?: StatusOptions) => {
+  const path = opt?.path || "/status";
+  const statusCounter = new Prometheus.Counter({
+    name: "metamigo_status_test",
+    help: "Test counter",
+  });
+
+  return [
+    {
+      method: "GET",
+      path: `${path}/ping`,
+      handler: ping,
+      options: {
+        auth: opt?.auth,
+        tags: ["api", "status", "ping"],
+        description: "Returns 200 and OK as the response.",
+      },
+    },
+    {
+      method: "GET",
+      path: `${path}/inc`,
+      handler: count(statusCounter),
+      options: {
+        auth: opt?.auth,
+        tags: ["api", "status", "prometheus"],
+        description: "Increments a test counter, for testing prometheus.",
+      },
+    },
+  ];
+};
+
+const register = async (
+  server: Server,
+  options: StatusOptions
+): Promise<void> => {
+  server.route(statusRoutes(server, options));
+};
+
+const StatusPlugin = {
+  register,
+  name: "status",
+  version: "0.0.1",
+};
+
+export default StatusPlugin;

packages/metamigo-common/records/account.ts

@@ -0,0 +1,30 @@
+import { recordInfo } from "./record-info";
+import { RepositoryBase } from "./base";
+import { Flavor, UUID } from "../helpers";
+import { UserId } from "./user";
+
+export type AccountId = Flavor<UUID, "Account Id">;
+
+export interface UnsavedAccount {
+  compoundId: string;
+  userId: UserId;
+  providerType: string;
+  providerId: string;
+  providerAccountId: string;
+  refreshToken: string;
+  accessToken: string;
+  accessTokenExpires: Date;
+}
+
+export interface SavedAccount extends UnsavedAccount {
+  id: AccountId;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+export const AccountRecord = recordInfo<UnsavedAccount, SavedAccount>(
+  "app_public",
+  "accounts"
+);
+
+export class AccountRecordRepository extends RepositoryBase(AccountRecord) {}

packages/metamigo-common/records/base.ts

@@ -0,0 +1,57 @@
+import { TableName } from "pg-promise";
+import { IMain } from "../db/types";
+import { CrudRepository } from "./crud-repository";
+import { PgRecordInfo, UnsavedR, SavedR, KeyType } from "./record-info";
+import type { IDatabase } from "pg-promise";
+
+export type PgProtocol<T> = IDatabase<T> & T;
+
+/**
+ * This function returns a constructor for a repository class for [[TRecordInfo]]
+ *
+ * @param aRecordType the record type runtime definition
+ */
+// haven't figured out a good return type for this function
+// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+export function unboundRepositoryBase<
+  TRecordInfo extends PgRecordInfo,
+  TDatabaseExtension
+>(aRecordType: TRecordInfo) {
+  return class Repository extends CrudRepository<
+    UnsavedR<TRecordInfo>,
+    SavedR<TRecordInfo>,
+    KeyType<TRecordInfo>
+  > {
+    _recordType!: TRecordInfo;
+    static readonly recordType = aRecordType;
+    static readonly schemaName = aRecordType.schemaName;
+    static readonly tableName = aRecordType.tableName;
+    public readonly recordType = aRecordType;
+    public readonly schemaTable: TableName;
+    public db: PgProtocol<TDatabaseExtension>;
+    public pgp: IMain;
+
+    constructor(db: PgProtocol<TDatabaseExtension>) {
+      super();
+
+      this.pgp = db.$config.pgp;
+      this.schemaTable = new this.pgp.helpers.TableName({
+        schema: aRecordType.schemaName,
+        table: aRecordType.tableName,
+      });
+
+      this.db = db;
+      if (!this.db) {
+        throw new Error("Missing database in repository");
+      }
+    }
+  };
+}
+
+// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+export function RepositoryBase<
+  Rec extends PgRecordInfo,
+  TDatabaseExtension = unknown
+>(recordType: Rec) {
+  return unboundRepositoryBase<Rec, TDatabaseExtension>(recordType);
+}

packages/metamigo-common/records/crud-repository.ts

@@ -0,0 +1,321 @@
+/* eslint-disable @typescript-eslint/ban-types,@typescript-eslint/no-explicit-any */
+import { TableName } from "pg-promise";
+import decamelcaseKeys from "decamelcase-keys";
+import isObject from "lodash/isObject";
+import isArray from "lodash/isArray";
+import zipObject from "lodash/zipObject";
+import isEmpty from "lodash/isEmpty";
+import omit from "lodash/omit";
+import { IDatabase, IMain, IResult } from "../db/types";
+import { PgRecordInfo, idKeysOf } from "./record-info";
+
+export interface ICrudRepository<
+  TUnsavedR,
+  TSavedR extends TUnsavedR & IdKeyT,
+  IdKeyT extends object
+> {
+  findById(id: IdKeyT): Promise<TSavedR | null>;
+  findBy(example: Partial<TSavedR>): Promise<TSavedR | null>;
+  findAll(): Promise<TSavedR[]>;
+  findAllBy(example: Partial<TSavedR>): Promise<TSavedR[]>;
+  existsById(id: IdKeyT): Promise<boolean>;
+  countBy(example: Partial<TSavedR>): Promise<number>;
+  count(): Promise<number>;
+  insert(record: TUnsavedR): Promise<TSavedR>;
+  insertAll(toInsert: TUnsavedR[]): Promise<TSavedR[]>;
+  updateById(id: IdKeyT, attrs: Partial<TSavedR>): Promise<TSavedR>;
+  update(record: TSavedR): Promise<TSavedR>;
+  updateAll(toUpdate: TSavedR[]): Promise<TSavedR[]>;
+  remove(record: TSavedR): Promise<number>;
+  removeAll(toRemove: TSavedR[]): Promise<number>;
+  removeBy(example: Partial<TSavedR>): Promise<TSavedR | null>;
+  removeById(id: IdKeyT): Promise<number>;
+}
+
+// The snake cased object going into the db
+type DatabaseRow = Record<string, unknown>;
+
+/**
+ * Base class for generic CRUD operations on a repository for a specific type.
+ *
+ * Several assumptions are made about your environment for this generic CRUD repository to work:
+ *
+ * - the underlying column names are snake_cased (this behavior can be changed, see [[columnize]])
+ * - the rows have only a single primary key (composite keys are not supported)
+ *
+ * @typeParam ID The type of the id column
+ * @typeParam T The type of the record
+ */
+export abstract class CrudRepository<
+  TUnsavedR,
+  TSavedR extends TUnsavedR & IdKeyT,
+  IdKeyT extends object
+> implements ICrudRepository<TUnsavedR, TSavedR, IdKeyT>
+{
+  /**
+   * the fully qualified table name
+   */
+  abstract schemaTable: TableName;
+  abstract recordType: PgRecordInfo<TUnsavedR, TSavedR, IdKeyT>;
+  abstract db: IDatabase;
+  abstract pgp: IMain;
+
+  /**
+   * Converts the record's columns into snake_case
+   *
+   * @param record the record of type T to convert
+   */
+  columnize(record: TSavedR | Partial<TSavedR>): DatabaseRow {
+    return decamelcaseKeys(record);
+  }
+
+  /*
+   * Creates a simple where clause with each key-value in `example` is
+   * formatted as KEY=VALUE and all kv-pairs are ANDed together.
+   *
+   * @param example key value pair of column names and values
+   */
+  where(example: Partial<TSavedR>): string {
+    const snaked = this.columnize(example);
+    const clauses = Object.keys(snaked).reduce((acc, cur) => {
+      const colName = this.pgp.as.format("$1:name", cur);
+      return `${acc} and ${colName} = $<${cur}>`;
+    }, "");
+    const where = this.pgp.as.format(`WHERE 1=1 ${clauses}`, { ...snaked }); // Pre-format WHERE condition
+    return where;
+  }
+
+  /**
+   * Converts a value containing the id of the record (which could be a primitive type, a composite object, or an array of values)
+   * into an object which can be safely passed to [[where]].
+   */
+  idsObj(idValues: IdKeyT): IdKeyT {
+    if (isEmpty(idValues)) {
+      throw new Error(`idsObj(${this.schemaTable}): passed empty id(s)`);
+    }
+
+    let ids = {};
+    const idKeys = idKeysOf(this.recordType as any);
+    if (isArray(idValues)) {
+      ids = zipObject(idKeys, idValues);
+    } else if (isObject(idValues)) {
+      ids = idValues;
+    } else {
+      if (idKeys.length !== 1) {
+        throw new Error(
+          `idsObj(${this.schemaTable}): passed record has multiple primary keys. the ids must be passed as an object or array. ${idValues}`
+        );
+      }
+      // @ts-ignore
+      ids[idKeys[0]] = idValues;
+    }
+
+    // this is a sanity check so we don't do something like
+    // deleting  all the data if a WHERE slips in with no ids
+    if (isEmpty(ids)) {
+      throw new Error(`idsObj(${this.schemaTable}): passed empty ids`);
+    }
+
+    return ids as IdKeyT;
+  }
+
+  /**
+   *  Returns all rows in the table
+   */
+  async findAll(): Promise<TSavedR[]> {
+    return this.db.any("SELECT * FROM $1", [this.schemaTable]);
+  }
+
+  /**
+   * Returns the number of rows in the table
+   */
+  async count(): Promise<number> {
+    return this.db.one(
+      "SELECT count(*) FROM $1",
+      [this.schemaTable],
+      (a: { count: string }) => Number(a.count)
+    );
+  }
+
+  /**
+   * Returns the number of rows in the table matching the example
+   */
+  async countBy(example: Partial<TSavedR>): Promise<number> {
+    return this.db.one(
+      "SELECT count(*) FROM $1 $2:raw ",
+      [this.schemaTable, this.where(example)],
+      (a: { count: string }) => Number(a.count)
+    );
+  }
+
+  /**
+   * Find a single row where the example are true.
+   * @param example key-value pairs of column names and values
+   */
+  async findBy(example: Partial<TSavedR>): Promise<TSavedR | null> {
+    return this.db.oneOrNone("SELECT * FROM $1 $2:raw LIMIT 1", [
+      this.schemaTable,
+      this.where(example),
+    ]);
+  }
+
+  /**
+   * Retrieves a row by ID
+   * @param id
+   */
+  async findById(id: IdKeyT): Promise<TSavedR | null> {
+    const where = this.idsObj(id);
+    return this.db.oneOrNone("SELECT * FROM $1 $2:raw", [
+      this.schemaTable,
+      this.where(where),
+    ]);
+  }
+
+  /**
+   * Returns whether a given row with id exists
+   * @param id
+   */
+  async existsById(id: IdKeyT): Promise<boolean> {
+    return this.db.one(
+      "SELECT EXISTS(SELECT 1 FROM $1 $2:raw)",
+      [this.schemaTable, this.where(this.idsObj(id))],
+      (a: { exists: boolean }) => a.exists
+    );
+  }
+
+  /**
+   * Find all rows where the example are true.
+   * @param example key-value pairs of column names and values
+   */
+  async findAllBy(example: Partial<TSavedR>): Promise<TSavedR[]> {
+    return this.db.any("SELECT * FROM $1 $2:raw", [
+      this.schemaTable,
+      this.where(example),
+    ]);
+  }
+
+  /**
+   * Creates a new row
+   * @param record
+   * @return the new row
+   */
+  async insert(record: TUnsavedR): Promise<TSavedR> {
+    return this.db.one("INSERT INTO $1 ($2:name) VALUES ($2:csv) RETURNING *", [
+      this.schemaTable,
+      this.columnize(record as any),
+    ]);
+  }
+
+  /**
+   * Like `insert` but will insert/update a batch of rows at once
+   */
+  async insertAll(toInsert: TUnsavedR[]): Promise<TSavedR[]> {
+    return this.db.tx((t) => {
+      const insertCommands: any[] = [];
+
+      toInsert.forEach((record) => {
+        insertCommands.push(this.insert(record));
+      });
+
+      return t.batch(insertCommands);
+    });
+  }
+
+  /**
+   * Deletes a row by id
+   * @param id
+   * @return the number of rows affected
+   */
+  async removeById(id: IdKeyT): Promise<number> {
+    return this.db.result(
+      "DELETE FROM $1 $2:raw",
+      [this.schemaTable, this.where(this.idsObj(id))],
+      (r: IResult) => r.rowCount
+    );
+  }
+
+  /**
+   * Delete records matching the query
+   * @param example key-value pairs of column names and values
+   */
+  async removeBy(example: Partial<TSavedR>): Promise<TSavedR | null> {
+    if (isEmpty(example))
+      throw new Error(
+        `removeBy(${this.schemaTable}): passed empty constraint!`
+      );
+    return this.db.result("DELETE FROM $1 $2:raw", [
+      this.schemaTable,
+      this.where(example),
+    ]);
+  }
+
+  /**
+   * Deletes the given row
+   *
+   * @param record to remove
+   * @return the number of rows affected
+   */
+  async remove(record: TSavedR): Promise<number> {
+    return this.removeById(this.recordType.idOf(record));
+  }
+
+  /**
+   * Deletes all rows
+   * @param toRemove a list of rows to remove, if empty, DELETES ALL ROWS
+   * @return the number of rows affected
+   */
+  async removeAll(toRemove: TSavedR[] = []): Promise<number> {
+    if (toRemove.length === 0) {
+      return this.db.result(
+        "DELETE FROM $1 WHERE 1=1;",
+        [this.schemaTable],
+        (r: IResult) => r.rowCount
+      );
+    }
+
+    const results = await this.db.tx((t) => {
+      const delCommands: any[] = [];
+
+      toRemove.forEach((record) => {
+        delCommands.push(this.remove(record));
+      });
+
+      return t.batch(delCommands);
+    });
+    return results.length;
+  }
+
+  /**
+   * Updates an existing row
+   * @param id
+   * @param attrs
+   * @return the updated row
+   */
+  async updateById(id: IdKeyT, attrs: Partial<TSavedR>): Promise<TSavedR> {
+    const idKeys = idKeysOf(this.recordType as any);
+    const attrsSafe = omit(attrs, idKeys);
+    return this.db.one(
+      "UPDATE $1 SET ($2:name) = ROW($2:csv) $3:raw RETURNING *",
+      [this.schemaTable, this.columnize(attrsSafe), this.where(this.idsObj(id))]
+    );
+  }
+
+  async update(record: TSavedR): Promise<TSavedR> {
+    return this.updateById(this.recordType.idOf(record), record);
+  }
+
+  /**
+   * Update a batch of records at once
+   */
+  async updateAll(toUpdate: TSavedR[]): Promise<TSavedR[]> {
+    return this.db.tx((t) => {
+      const updateCommands: any[] = [];
+
+      toUpdate.forEach((record) => {
+        updateCommands.push(this.update(record));
+      });
+
+      return t.batch(updateCommands);
+    });
+  }
+}

packages/metamigo-common/records/index.ts

@@ -0,0 +1,16 @@
+export * from "./base";
+export * from "./record-info";
+export * from "./crud-repository";
+export * from "./user";
+export * from "./session";
+export * from "./account";
+
+import type { AccountRecordRepository } from "./account";
+import type { UserRecordRepository } from "./user";
+import type { SessionRecordRepository } from "./session";
+
+export interface IMetamigoRepositories {
+  users: UserRecordRepository;
+  sessions: SessionRecordRepository;
+  accounts: AccountRecordRepository;
+}

packages/metamigo-common/records/record-info.d.ts

@@ -0,0 +1,54 @@
+export interface EntityType<TUnsaved = any, TSaved = any, TIds extends object = any> {
+    _saved: TSaved;
+    _unsaved: TUnsaved;
+    _idKeys: TIds;
+    idOf: (rec: TSaved) => TIds;
+}
+export declare type UnsavedR<T extends {
+    _unsaved: any;
+}> = T["_unsaved"];
+export declare type SavedR<T extends {
+    _saved: any;
+}> = T["_saved"];
+export declare type KeyType<R extends EntityType> = R["_idKeys"];
+export interface PgRecordInfo<Unsaved = any, Saved extends Unsaved & IdType = any, IdType extends object = any> extends EntityType<Unsaved, Saved, IdType> {
+    tableName: string;
+    schemaName: string;
+    idKeys: (keyof Saved)[];
+}
+/**
+ * Extract the runtime key name from a recordInfo
+ */
+export declare function idKeysOf<RI extends PgRecordInfo>(recordInfoWithIdKey: RI): string[];
+/**
+ * Turns a record type with possibly more fields than "id" into an array
+ */
+export declare function collectIdValues<RecordT extends PgRecordInfo>(idObj: KeyType<RecordT>, knexRecordType: RecordT): string[];
+/**
+ *
+ * Creates a record descriptor that captures the table name, primary key name,
+ * unsaved type, and saved type of a database record type. Assumes "id" as the
+ * primary key name
+ *
+ */
+export declare function recordInfo<Unsaved, Saved extends Unsaved & {
+    id: any;
+}>(schemaName: string, tableName: string): PgRecordInfo<Unsaved, Saved, Pick<Saved, "id">>;
+export declare function recordInfo<Type extends {
+    id: string;
+}>(schemaName: string, tableName: string): PgRecordInfo<Type, Type, Pick<Type, "id">>;
+/**
+ *
+ * Creates a record descriptor that captures the table name, primary key name,
+ * unsaved type, and saved type of a database record type.
+ *
+ */
+export declare function recordInfo<Unsaved, Saved extends Unsaved, Id extends keyof Saved>(schemaName: string, tableName: string, idKey: Id[]): PgRecordInfo<Unsaved, Saved, Pick<Saved, Id>>;
+/**
+ *
+ * Creates a record descriptor for records with composite primary keys
+ *
+ */
+export declare function compositeRecordType<TUnsaved, TSaved extends TUnsaved = TUnsaved>(schemaName: string, tableName: string): {
+    withCompositeKeys<TKeys extends keyof TSaved>(keys: TKeys[]): PgRecordInfo<TUnsaved, TSaved, Pick<TSaved, TKeys>>;
+};

packages/metamigo-common/records/record-info.ts

@@ -0,0 +1,133 @@
+/* eslint-disable @typescript-eslint/ban-types,@typescript-eslint/no-explicit-any,@typescript-eslint/explicit-module-boundary-types */
+import at from "lodash/at";
+import pick from "lodash/pick";
+
+export interface EntityType<
+  TUnsaved = any,
+  TSaved = any,
+  TIds extends object = any
+> {
+  _saved: TSaved;
+  _unsaved: TUnsaved;
+  _idKeys: TIds;
+  idOf: (rec: TSaved) => TIds;
+}
+
+export type UnsavedR<T extends { _unsaved: any }> = T["_unsaved"];
+export type SavedR<T extends { _saved: any }> = T["_saved"];
+export type KeyType<R extends EntityType> = R["_idKeys"];
+
+export interface PgRecordInfo<
+  Unsaved = any,
+  Saved extends Unsaved & IdType = any,
+  IdType extends object = any
+> extends EntityType<Unsaved, Saved, IdType> {
+  tableName: string;
+  schemaName: string;
+  idKeys: (keyof Saved)[];
+}
+
+/**
+ * Extract the runtime key name from a recordInfo
+ */
+export function idKeysOf<RI extends PgRecordInfo>(
+  recordInfoWithIdKey: RI
+): string[] {
+  return recordInfoWithIdKey.idKeys as any;
+}
+
+/**
+ * Turns a record type with possibly more fields than "id" into an array
+ */
+export function collectIdValues<RecordT extends PgRecordInfo>(
+  idObj: KeyType<RecordT>,
+  knexRecordType: RecordT
+): string[] {
+  return at(idObj, idKeysOf(knexRecordType));
+}
+
+function castToRecordInfo(
+  runtimeData: Omit<PgRecordInfo, "_idKeys" | "_saved" | "_unsaved">
+): PgRecordInfo {
+  return runtimeData as PgRecordInfo;
+}
+
+/**
+ *
+ * Creates a record descriptor that captures the table name, primary key name,
+ * unsaved type, and saved type of a database record type. Assumes "id" as the
+ * primary key name
+ *
+ */
+export function recordInfo<Unsaved, Saved extends Unsaved & { id: any }>(
+  schemaName: string,
+  tableName: string
+): PgRecordInfo<Unsaved, Saved, Pick<Saved, "id">>;
+
+export function recordInfo<Type extends { id: string }>(
+  schemaName: string,
+  tableName: string
+): PgRecordInfo<Type, Type, Pick<Type, "id">>;
+
+/**
+ *
+ * Creates a record descriptor that captures the table name, primary key name,
+ * unsaved type, and saved type of a database record type.
+ *
+ */
+export function recordInfo<
+  Unsaved,
+  Saved extends Unsaved,
+  Id extends keyof Saved
+>(
+  schemaName: string,
+  tableName: string,
+  idKey: Id[]
+): PgRecordInfo<Unsaved, Saved, Pick<Saved, Id>>;
+
+/**
+ *
+ * Don't use this signature  be sure to provide unsaved and saved types.
+ *
+ */
+export function recordInfo(
+  schemaName: string,
+  tableName: string,
+  idKeys?: string[]
+) {
+  idKeys = idKeys || ["id"];
+  return castToRecordInfo({
+    schemaName,
+    tableName,
+    idKeys,
+    idOf: (rec) => pick(rec, idKeys as any),
+  });
+}
+
+/**
+ *
+ * Creates a record descriptor for records with composite primary keys
+ *
+ */
+export function compositeRecordType<
+  TUnsaved,
+  TSaved extends TUnsaved = TUnsaved
+>(
+  schemaName: string,
+  tableName: string
+): {
+  withCompositeKeys<TKeys extends keyof TSaved>(
+    keys: TKeys[]
+  ): PgRecordInfo<TUnsaved, TSaved, Pick<TSaved, TKeys>>;
+} {
+  return {
+    withCompositeKeys(keys) {
+      return castToRecordInfo({
+        schemaName,
+        tableName,
+        idKeys: keys,
+        idOf: (rec) => pick(rec, keys),
+      });
+    },
+  };
+}

packages/metamigo-common/records/session.ts

@@ -0,0 +1,26 @@
+import { recordInfo } from "./record-info";
+import { RepositoryBase } from "./base";
+import { Flavor, UUID } from "../helpers";
+import { UserId } from "./user";
+
+export type SessionId = Flavor<UUID, "Session Id">;
+
+export interface UnsavedSession {
+  userId: UserId;
+  expires: Date;
+  sessionToken: string;
+  accessToken: string;
+}
+
+export interface SavedSession extends UnsavedSession {
+  id: SessionId;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+export const SessionRecord = recordInfo<UnsavedSession, SavedSession>(
+  "app_private",
+  "sessions"
+);
+
+export class SessionRecordRepository extends RepositoryBase(SessionRecord) {}

packages/metamigo-common/records/user.ts

@@ -0,0 +1,40 @@
+import { recordInfo } from "./record-info";
+import { RepositoryBase } from "./base";
+import { Flavor, UUID } from "../helpers";
+
+export type UserId = Flavor<UUID, "User Id">;
+
+export interface UnsavedUser {
+  name: string;
+  email: string;
+  emailVerified: Date;
+  avatar: string;
+  isActive: boolean;
+  userRole: string;
+}
+
+export interface SavedUser extends UnsavedUser {
+  id: UserId;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+export const UserRecord = recordInfo<UnsavedUser, SavedUser>(
+  "app_public",
+  "users"
+);
+
+export class UserRecordRepository extends RepositoryBase(UserRecord) {
+  async upsert(record: UnsavedUser | SavedUser): Promise<SavedUser> {
+    return this.db.one(
+      `INSERT INTO $1 ($2:name) VALUES ($2:csv)
+       ON CONFLICT (email)
+       DO UPDATE SET
+          name = EXCLUDED.name,
+          avatar = EXCLUDED.avatar,
+          email_verified = EXCLUDED.email_verified
+       RETURNING *`,
+      [this.schemaTable, this.columnize(record)]
+    );
+  }
+}

packages/metamigo-common/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "extends": "../tsconfig.json",
+  "compilerOptions": {
+    "incremental": true,
+    "outDir": "build/main",
+    "paths": {
+      "@hapipal/schmervice": ["vendor/hapipal__schmervice"],
+      "*": ["node_modules/@types/*", "*"]
+    }
+  },
+  "include": ["**/*.ts"],
+  "exclude": ["node_modules/**"]
+}