@squiz/db-lib 1.2.1-alpha.95 → 1.2.1-alpha.97

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@squiz/db-lib",
-  "version": "1.2.1-alpha.95",
+  "version": "1.2.1-alpha.97",
   "description": "",
   "main": "lib/index.js",
   "scripts": {
     "start": "node ./lib/index.js",
     "compile": "node build.js && npx tsc",
     "lint": "eslint ./src --ext .ts",
-    "test": "echo \"tested in integration\"",
+    "test": "jest -c jest.config.ts",
     "test:integration___": "jest -c jest.config.ts",
     "test:update-snapshots": "jest -c jest.config.ts --updateSnapshot",
     "clean": "rimraf \".tsbuildinfo\" \"./lib\""
@@ -18,20 +18,21 @@
     "@types/jest": "28.1.6",
     "@types/node": "17.0.27",
     "@types/pg": "8.6.5",
-    "esbuild": "0.14.49",
-    "eslint": "8.18.0",
+    "esbuild": "0.15.3",
+    "eslint": "8.22.0",
     "fs-extra": "10.1.0",
     "jest": "28.1.3",
     "rimraf": "3.0.2",
-    "ts-jest": "28.0.5",
+    "ts-jest": "28.0.7",
     "ts-loader": "9.3.1",
-    "ts-node": "10.8.1",
+    "ts-node": "10.9.1",
     "typescript": "4.7.4"
   },
   "dependencies": {
-    "@aws-sdk/client-secrets-manager": "^3.121.0",
+    "@aws-sdk/client-secrets-manager": "3.121.0",
+    "@squiz/dx-logger-lib": "^1.2.1-alpha.97",
     "dotenv": "16.0.1",
-    "pg": "^8.7.3"
+    "pg": "8.7.3"
   },
-  "gitHead": "3b3b33ee15543041c29262becfc9cd3674ddc111"
+  "gitHead": "bf3e5580c5b09c3e46a5965da38e4ed4657463d4"
 }

package/src/AbstractRepository.ts

@@ -17,24 +17,27 @@ export type Repository<T> = Reader<T> & Writer<T>;
 export abstract class AbstractRepository<T> implements Reader<T>, Writer<T> {
   protected tableName: string;
 
+  /** object where the key is the model property name amd the value is sql column name */
   protected modelPropertyToSqlColumn: { [key in keyof T]: string };
-  protected sqlColumnToModelProperty: { [key: string]: keyof T };
+  /** object where the key is the sql column name and the value is the model property name */
+  protected sqlColumnToModelProperty: { [key: string]: string };
 
   constructor(
     protected repositories: Repositories,
     protected pool: Pool,
     tableName: string,
     mapping: { [key in keyof T]: string },
-    protected classRef: { new (): T },
+    protected classRef: { new (data?: Record<string, unknown>): T },
   ) {
     this.tableName = `"${tableName}"`;
 
     this.modelPropertyToSqlColumn = mapping;
+
     this.sqlColumnToModelProperty = Object.entries(mapping).reduce((prev, curr) => {
-      const [modelProp, columnName] = curr as [keyof T, string];
+      const [modelProp, columnName] = curr as [string, string];
       prev[columnName] = modelProp;
       return prev;
-    }, {} as { [key: string]: keyof T });
+    }, {} as { [key: string]: string });
   }
 
   protected async getConnection(): Promise<PoolClient> {
@@ -131,13 +134,14 @@ export abstract class AbstractRepository<T> implements Reader<T>, Writer<T> {
   }
 
   protected createAndHydrateModel(row: any): T {
-    const model = new this.classRef();
+    const inputData: Record<string, unknown> = {};
 
     for (const key of Object.keys(row)) {
-      model[this.sqlColumnToModelProperty[key]] = row[key];
+      const translatedKey = this.sqlColumnToModelProperty[key];
+      inputData[translatedKey] = row[key];
     }
 
-    return model;
+    return new this.classRef(inputData);
   }
 
   async findOne(item: Partial<T>): Promise<T | undefined> {

package/src/Migrator.ts

@@ -1,11 +1,15 @@
 import fs from 'fs/promises';
 import { PoolClient } from 'pg';
 import path from 'path';
+import os from 'os';
+import { getLogger } from '@squiz/dx-logger-lib';
 
 // Be carful about changing this value. This needs to be consistent across deployments
 // this ID is used to signal other running instances that a migration is executing.
 const MIGRATION_ADVISORY_LOCK = 4569465;
 
+const logger = getLogger({ name: 'db-migrator', meta: { pid: process.pid, hostname: os.hostname() } });
+
 export class Migrator {
   constructor(protected migrationDir: string, protected migrationList: string[], protected pool: PoolClient) {}
 
@@ -25,15 +29,15 @@ export class Migrator {
   protected async applyMigration(migration: string, sql: string) {
     try {
       const result = await this.pool.query(sql);
-      console.log(process.pid, 'Applying ' + migration);
+      logger.info('Applying ' + migration);
 
       if (result.rowCount !== undefined) {
-        console.log(process.pid, 'affected rows', result.rowCount);
+        logger.info('affected rows', result.rowCount);
       }
 
       await this.pool.query('insert into __migrations__ (id) values ($1)', [migration]);
     } catch (e) {
-      console.log(process.pid, 'error occurred running migration', migration, e);
+      logger.info('error occurred running migration', migration, e);
       throw e;
     }
   }
@@ -79,18 +83,18 @@ export class Migrator {
       const lockObtained = await this.tryToObtainLock();
 
       if (lockObtained === false) {
-        console.log(process.pid, 'migration already running');
+        logger.info('migration already running');
         await sleep(500);
         return await this.migrate();
       }
 
       await this.runMigrations();
-      console.log(process.pid, 'completed migration');
+      logger.info('completed migration');
       await this.releaseLock();
 
       this.dispose();
     } catch (e) {
-      console.log(process.pid, 'migration failed releasing lock');
+      logger.info('migration failed releasing lock');
       await this.releaseLock();
       throw e;
     }
@@ -101,11 +105,11 @@ export class Migrator {
     const pending = await this.getPending(this.migrationList, appliedMigrations);
 
     if (pending.length === 0) {
-      console.log(process.pid, 'No pending migrations');
+      logger.info('No pending migrations');
       return;
     }
 
-    console.log(process.pid, 'Pending migrations:\n\t', pending.join('\n\t'));
+    logger.info('Pending migrations:\n\t', pending.join('\n\t'));
 
     for (const migration of pending) {
       await this.runMigration(migration);
@@ -121,7 +125,7 @@ export class Migrator {
 
       await this.pool.query('COMMIT');
     } catch (e) {
-      console.log(process.pid, 'migration failed', migration, e);
+      logger.error('migration failed', migration, e);
       await this.pool.query('ROLLBACK');
       throw e;
     }

package/src/PostgresErrorCodes.ts

@@ -0,0 +1,270 @@
+// See https://github.com/postgres/postgres/blob/master/src/backend/utils/errcodes.txt
+
+export enum PostgresErrorCode {
+  SUCCESSFUL_COMPLETION = '00000',
+  WARNING = '01000',
+  WARNING_DYNAMIC_RESULT_SETS_RETURNED = '0100C',
+  WARNING_IMPLICIT_ZERO_BIT_PADDING = '01008',
+  WARNING_NULL_VALUE_ELIMINATED_IN_SET_FUNCTION = '01003',
+  WARNING_PRIVILEGE_NOT_GRANTED = '01007',
+  WARNING_PRIVILEGE_NOT_REVOKED = '01006',
+  WARNING_STRING_DATA_RIGHT_TRUNCATION = '01004',
+  WARNING_DEPRECATED_FEATURE = '01P01',
+  NO_DATA = '02000',
+  NO_ADDITIONAL_DYNAMIC_RESULT_SETS_RETURNED = '02001',
+  SQL_STATEMENT_NOT_YET_COMPLETE = '03000',
+  CONNECTION_EXCEPTION = '08000',
+  CONNECTION_DOES_NOT_EXIST = '08003',
+  CONNECTION_FAILURE = '08006',
+  SQLCLIENT_UNABLE_TO_ESTABLISH_SQLCONNECTION = '08001',
+  SQLSERVER_REJECTED_ESTABLISHMENT_OF_SQLCONNECTION = '08004',
+  TRANSACTION_RESOLUTION_UNKNOWN = '08007',
+  PROTOCOL_VIOLATION = '08P01',
+  TRIGGERED_ACTION_EXCEPTION = '09000',
+  FEATURE_NOT_SUPPORTED = '0A000',
+  INVALID_TRANSACTION_INITIATION = '0B000',
+  LOCATOR_EXCEPTION = '0F000',
+  L_E_INVALID_SPECIFICATION = '0F001',
+  INVALID_GRANTOR = '0L000',
+  INVALID_GRANT_OPERATION = '0LP01',
+  INVALID_ROLE_SPECIFICATION = '0P000',
+  DIAGNOSTICS_EXCEPTION = '0Z000',
+  STACKED_DIAGNOSTICS_ACCESSED_WITHOUT_ACTIVE_HANDLER = '0Z002',
+  CASE_NOT_FOUND = '20000',
+  CARDINALITY_VIOLATION = '21000',
+  DATA_EXCEPTION = '22000',
+  ARRAY_ELEMENT_ERROR = '2202E',
+  ARRAY_SUBSCRIPT_ERROR = '2202E',
+  CHARACTER_NOT_IN_REPERTOIRE = '22021',
+  DATETIME_FIELD_OVERFLOW = '22008',
+  DATETIME_VALUE_OUT_OF_RANGE = '22008',
+  DIVISION_BY_ZERO = '22012',
+  ERROR_IN_ASSIGNMENT = '22005',
+  ESCAPE_CHARACTER_CONFLICT = '2200B',
+  INDICATOR_OVERFLOW = '22022',
+  INTERVAL_FIELD_OVERFLOW = '22015',
+  INVALID_ARGUMENT_FOR_LOG = '2201E',
+  INVALID_ARGUMENT_FOR_NTILE = '22014',
+  INVALID_ARGUMENT_FOR_NTH_VALUE = '22016',
+  INVALID_ARGUMENT_FOR_POWER_FUNCTION = '2201F',
+  INVALID_ARGUMENT_FOR_WIDTH_BUCKET_FUNCTION = '2201G',
+  INVALID_CHARACTER_VALUE_FOR_CAST = '22018',
+  INVALID_DATETIME_FORMAT = '22007',
+  INVALID_ESCAPE_CHARACTER = '22019',
+  INVALID_ESCAPE_OCTET = '2200D',
+  INVALID_ESCAPE_SEQUENCE = '22025',
+  NONSTANDARD_USE_OF_ESCAPE_CHARACTER = '22P06',
+  INVALID_INDICATOR_PARAMETER_VALUE = '22010',
+  INVALID_PARAMETER_VALUE = '22023',
+  INVALID_PRECEDING_OR_FOLLOWING_SIZE = '22013',
+  INVALID_REGULAR_EXPRESSION = '2201B',
+  INVALID_ROW_COUNT_IN_LIMIT_CLAUSE = '2201W',
+  INVALID_ROW_COUNT_IN_RESULT_OFFSET_CLAUSE = '2201X',
+  INVALID_TABLESAMPLE_ARGUMENT = '2202H',
+  INVALID_TABLESAMPLE_REPEAT = '2202G',
+  INVALID_TIME_ZONE_DISPLACEMENT_VALUE = '22009',
+  INVALID_USE_OF_ESCAPE_CHARACTER = '2200C',
+  MOST_SPECIFIC_TYPE_MISMATCH = '2200G',
+  NULL_VALUE_NOT_ALLOWED = '22004',
+  NULL_VALUE_NO_INDICATOR_PARAMETER = '22002',
+  NUMERIC_VALUE_OUT_OF_RANGE = '22003',
+  SEQUENCE_GENERATOR_LIMIT_EXCEEDED = '2200H',
+  STRING_DATA_LENGTH_MISMATCH = '22026',
+  STRING_DATA_RIGHT_TRUNCATION = '22001',
+  SUBSTRING_ERROR = '22011',
+  TRIM_ERROR = '22027',
+  UNTERMINATED_C_STRING = '22024',
+  ZERO_LENGTH_CHARACTER_STRING = '2200F',
+  FLOATING_POINT_EXCEPTION = '22P01',
+  INVALID_TEXT_REPRESENTATION = '22P02',
+  INVALID_BINARY_REPRESENTATION = '22P03',
+  BAD_COPY_FILE_FORMAT = '22P04',
+  UNTRANSLATABLE_CHARACTER = '22P05',
+  NOT_AN_XML_DOCUMENT = '2200L',
+  INVALID_XML_DOCUMENT = '2200M',
+  INVALID_XML_CONTENT = '2200N',
+  INVALID_XML_COMMENT = '2200S',
+  INVALID_XML_PROCESSING_INSTRUCTION = '2200T',
+  DUPLICATE_JSON_OBJECT_KEY_VALUE = '22030',
+  INVALID_ARGUMENT_FOR_SQL_JSON_DATETIME_FUNCTION = '22031',
+  INVALID_JSON_TEXT = '22032',
+  INVALID_SQL_JSON_SUBSCRIPT = '22033',
+  MORE_THAN_ONE_SQL_JSON_ITEM = '22034',
+  NO_SQL_JSON_ITEM = '22035',
+  NON_NUMERIC_SQL_JSON_ITEM = '22036',
+  NON_UNIQUE_KEYS_IN_A_JSON_OBJECT = '22037',
+  SINGLETON_SQL_JSON_ITEM_REQUIRED = '22038',
+  SQL_JSON_ARRAY_NOT_FOUND = '22039',
+  SQL_JSON_MEMBER_NOT_FOUND = '2203A',
+  SQL_JSON_NUMBER_NOT_FOUND = '2203B',
+  SQL_JSON_OBJECT_NOT_FOUND = '2203C',
+  TOO_MANY_JSON_ARRAY_ELEMENTS = '2203D',
+  TOO_MANY_JSON_OBJECT_MEMBERS = '2203E',
+  SQL_JSON_SCALAR_REQUIRED = '2203F',
+  SQL_JSON_ITEM_CANNOT_BE_CAST_TO_TARGET_TYPE = '2203G',
+  INTEGRITY_CONSTRAINT_VIOLATION = '23000',
+  RESTRICT_VIOLATION = '23001',
+  NOT_NULL_VIOLATION = '23502',
+  FOREIGN_KEY_VIOLATION = '23503',
+  UNIQUE_VIOLATION = '23505',
+  CHECK_VIOLATION = '23514',
+  EXCLUSION_VIOLATION = '23P01',
+  INVALID_CURSOR_STATE = '24000',
+  INVALID_TRANSACTION_STATE = '25000',
+  ACTIVE_SQL_TRANSACTION = '25001',
+  BRANCH_TRANSACTION_ALREADY_ACTIVE = '25002',
+  HELD_CURSOR_REQUIRES_SAME_ISOLATION_LEVEL = '25008',
+  INAPPROPRIATE_ACCESS_MODE_FOR_BRANCH_TRANSACTION = '25003',
+  INAPPROPRIATE_ISOLATION_LEVEL_FOR_BRANCH_TRANSACTION = '25004',
+  NO_ACTIVE_SQL_TRANSACTION_FOR_BRANCH_TRANSACTION = '25005',
+  READ_ONLY_SQL_TRANSACTION = '25006',
+  SCHEMA_AND_DATA_STATEMENT_MIXING_NOT_SUPPORTED = '25007',
+  NO_ACTIVE_SQL_TRANSACTION = '25P01',
+  IN_FAILED_SQL_TRANSACTION = '25P02',
+  IDLE_IN_TRANSACTION_SESSION_TIMEOUT = '25P03',
+  INVALID_SQL_STATEMENT_NAME = '26000',
+  TRIGGERED_DATA_CHANGE_VIOLATION = '27000',
+  INVALID_AUTHORIZATION_SPECIFICATION = '28000',
+  INVALID_PASSWORD = '28P01',
+  DEPENDENT_PRIVILEGE_DESCRIPTORS_STILL_EXIST = '2B000',
+  DEPENDENT_OBJECTS_STILL_EXIST = '2BP01',
+  INVALID_TRANSACTION_TERMINATION = '2D000',
+  SQL_ROUTINE_EXCEPTION = '2F000',
+  S_R_E_FUNCTION_EXECUTED_NO_RETURN_STATEMENT = '2F005',
+  S_R_E_MODIFYING_SQL_DATA_NOT_PERMITTED = '2F002',
+  S_R_E_PROHIBITED_SQL_STATEMENT_ATTEMPTED = '2F003',
+  S_R_E_READING_SQL_DATA_NOT_PERMITTED = '2F004',
+  INVALID_CURSOR_NAME = '34000',
+  EXTERNAL_ROUTINE_EXCEPTION = '38000',
+  E_R_E_CONTAINING_SQL_NOT_PERMITTED = '38001',
+  E_R_E_MODIFYING_SQL_DATA_NOT_PERMITTED = '38002',
+  E_R_E_PROHIBITED_SQL_STATEMENT_ATTEMPTED = '38003',
+  E_R_E_READING_SQL_DATA_NOT_PERMITTED = '38004',
+  EXTERNAL_ROUTINE_INVOCATION_EXCEPTION = '39000',
+  E_R_I_E_INVALID_SQLSTATE_RETURNED = '39001',
+  E_R_I_E_NULL_VALUE_NOT_ALLOWED = '39004',
+  E_R_I_E_TRIGGER_PROTOCOL_VIOLATED = '39P01',
+  E_R_I_E_SRF_PROTOCOL_VIOLATED = '39P02',
+  E_R_I_E_EVENT_TRIGGER_PROTOCOL_VIOLATED = '39P03',
+  SAVEPOINT_EXCEPTION = '3B000',
+  S_E_INVALID_SPECIFICATION = '3B001',
+  INVALID_CATALOG_NAME = '3D000',
+  INVALID_SCHEMA_NAME = '3F000',
+  TRANSACTION_ROLLBACK = '40000',
+  T_R_INTEGRITY_CONSTRAINT_VIOLATION = '40002',
+  T_R_SERIALIZATION_FAILURE = '40001',
+  T_R_STATEMENT_COMPLETION_UNKNOWN = '40003',
+  T_R_DEADLOCK_DETECTED = '40P01',
+  SYNTAX_ERROR_OR_ACCESS_RULE_VIOLATION = '42000',
+  SYNTAX_ERROR = '42601',
+  INSUFFICIENT_PRIVILEGE = '42501',
+  CANNOT_COERCE = '42846',
+  GROUPING_ERROR = '42803',
+  WINDOWING_ERROR = '42P20',
+  INVALID_RECURSION = '42P19',
+  INVALID_FOREIGN_KEY = '42830',
+  INVALID_NAME = '42602',
+  NAME_TOO_LONG = '42622',
+  RESERVED_NAME = '42939',
+  DATATYPE_MISMATCH = '42804',
+  INDETERMINATE_DATATYPE = '42P18',
+  COLLATION_MISMATCH = '42P21',
+  INDETERMINATE_COLLATION = '42P22',
+  WRONG_OBJECT_TYPE = '42809',
+  GENERATED_ALWAYS = '428C9',
+  UNDEFINED_COLUMN = '42703',
+  UNDEFINED_CURSOR = '34000',
+  UNDEFINED_DATABASE = '3D000',
+  UNDEFINED_FUNCTION = '42883',
+  UNDEFINED_PSTATEMENT = '26000',
+  UNDEFINED_SCHEMA = '3F000',
+  UNDEFINED_TABLE = '42P01',
+  UNDEFINED_PARAMETER = '42P02',
+  UNDEFINED_OBJECT = '42704',
+  DUPLICATE_COLUMN = '42701',
+  DUPLICATE_CURSOR = '42P03',
+  DUPLICATE_DATABASE = '42P04',
+  DUPLICATE_FUNCTION = '42723',
+  DUPLICATE_PSTATEMENT = '42P05',
+  DUPLICATE_SCHEMA = '42P06',
+  DUPLICATE_TABLE = '42P07',
+  DUPLICATE_ALIAS = '42712',
+  DUPLICATE_OBJECT = '42710',
+  AMBIGUOUS_COLUMN = '42702',
+  AMBIGUOUS_FUNCTION = '42725',
+  AMBIGUOUS_PARAMETER = '42P08',
+  AMBIGUOUS_ALIAS = '42P09',
+  INVALID_COLUMN_REFERENCE = '42P10',
+  INVALID_COLUMN_DEFINITION = '42611',
+  INVALID_CURSOR_DEFINITION = '42P11',
+  INVALID_DATABASE_DEFINITION = '42P12',
+  INVALID_FUNCTION_DEFINITION = '42P13',
+  INVALID_PSTATEMENT_DEFINITION = '42P14',
+  INVALID_SCHEMA_DEFINITION = '42P15',
+  INVALID_TABLE_DEFINITION = '42P16',
+  INVALID_OBJECT_DEFINITION = '42P17',
+  WITH_CHECK_OPTION_VIOLATION = '44000',
+  INSUFFICIENT_RESOURCES = '53000',
+  DISK_FULL = '53100',
+  OUT_OF_MEMORY = '53200',
+  TOO_MANY_CONNECTIONS = '53300',
+  CONFIGURATION_LIMIT_EXCEEDED = '53400',
+  PROGRAM_LIMIT_EXCEEDED = '54000',
+  STATEMENT_TOO_COMPLEX = '54001',
+  TOO_MANY_COLUMNS = '54011',
+  TOO_MANY_ARGUMENTS = '54023',
+  OBJECT_NOT_IN_PREREQUISITE_STATE = '55000',
+  OBJECT_IN_USE = '55006',
+  CANT_CHANGE_RUNTIME_PARAM = '55P02',
+  LOCK_NOT_AVAILABLE = '55P03',
+  UNSAFE_NEW_ENUM_VALUE_USAGE = '55P04',
+  OPERATOR_INTERVENTION = '57000',
+  QUERY_CANCELED = '57014',
+  ADMIN_SHUTDOWN = '57P01',
+  CRASH_SHUTDOWN = '57P02',
+  CANNOT_CONNECT_NOW = '57P03',
+  DATABASE_DROPPED = '57P04',
+  IDLE_SESSION_TIMEOUT = '57P05',
+  SYSTEM_ERROR = '58000',
+  IO_ERROR = '58030',
+  UNDEFINED_FILE = '58P01',
+  DUPLICATE_FILE = '58P02',
+  SNAPSHOT_TOO_OLD = '72000',
+  CONFIG_FILE_ERROR = 'F0000',
+  LOCK_FILE_EXISTS = 'F0001',
+  FDW_ERROR = 'HV000',
+  FDW_COLUMN_NAME_NOT_FOUND = 'HV005',
+  FDW_DYNAMIC_PARAMETER_VALUE_NEEDED = 'HV002',
+  FDW_FUNCTION_SEQUENCE_ERROR = 'HV010',
+  FDW_INCONSISTENT_DESCRIPTOR_INFORMATION = 'HV021',
+  FDW_INVALID_ATTRIBUTE_VALUE = 'HV024',
+  FDW_INVALID_COLUMN_NAME = 'HV007',
+  FDW_INVALID_COLUMN_NUMBER = 'HV008',
+  FDW_INVALID_DATA_TYPE = 'HV004',
+  FDW_INVALID_DATA_TYPE_DESCRIPTORS = 'HV006',
+  FDW_INVALID_DESCRIPTOR_FIELD_IDENTIFIER = 'HV091',
+  FDW_INVALID_HANDLE = 'HV00B',
+  FDW_INVALID_OPTION_INDEX = 'HV00C',
+  FDW_INVALID_OPTION_NAME = 'HV00D',
+  FDW_INVALID_STRING_LENGTH_OR_BUFFER_LENGTH = 'HV090',
+  FDW_INVALID_STRING_FORMAT = 'HV00A',
+  FDW_INVALID_USE_OF_NULL_POINTER = 'HV009',
+  FDW_TOO_MANY_HANDLES = 'HV014',
+  FDW_OUT_OF_MEMORY = 'HV001',
+  FDW_NO_SCHEMAS = 'HV00P',
+  FDW_OPTION_NAME_NOT_FOUND = 'HV00J',
+  FDW_REPLY_HANDLE = 'HV00K',
+  FDW_SCHEMA_NOT_FOUND = 'HV00Q',
+  FDW_TABLE_NOT_FOUND = 'HV00R',
+  FDW_UNABLE_TO_CREATE_EXECUTION = 'HV00L',
+  FDW_UNABLE_TO_CREATE_REPLY = 'HV00M',
+  FDW_UNABLE_TO_ESTABLISH_CONNECTION = 'HV00N',
+  PLPGSQL_ERROR = 'P0000',
+  RAISE_EXCEPTION = 'P0001',
+  NO_DATA_FOUND = 'P0002',
+  TOO_MANY_ROWS = 'P0003',
+  ASSERT_FAILURE = 'P0004',
+  INTERNAL_ERROR = 'XX000',
+  DATA_CORRUPTED = 'XX001',
+  INDEX_CORRUPTED = 'XX002',
+}

package/src/assertions/assertAssign.spec.ts

@@ -0,0 +1,18 @@
+import { assertAssign } from './assertAssign';
+import { assertIsString } from './assertIsString';
+
+describe('assertAssign', () => {
+  it('should assert the input meets an assertion function and return if valid', () => {
+    expect(assertAssign('123', assertIsString)).toEqual('123');
+  });
+
+  it('should assert the input meets an assertion function and throw if not valid', () => {
+    expect(() => assertAssign(123, assertIsString)).toThrowErrorMatchingInlineSnapshot(`"value is not a string"`);
+  });
+
+  it('should allow custom error message', () => {
+    expect(() => assertAssign(123, assertIsString, 'custom error')).toThrowErrorMatchingInlineSnapshot(
+      `"custom error"`,
+    );
+  });
+});

package/src/assertions/assertAssign.ts

@@ -0,0 +1,22 @@
+import { AssertionError } from 'assert';
+
+/**
+ * Assert and return unknown value as known type
+ */
+export function assertAssign<T>(
+  value: unknown,
+  assertionFunc: (val: unknown) => asserts val is T,
+  errorMessage?: string,
+): T {
+  try {
+    assertionFunc(value);
+  } catch (e) {
+    if (errorMessage) {
+      throw new AssertionError({ message: errorMessage });
+    } else {
+      throw e;
+    }
+  }
+
+  return value;
+}

package/src/assertions/assertAssignWithDefaultUndefinedValue.spec.ts

@@ -0,0 +1,31 @@
+import { assertAssignWithDefaultUndefinedValue } from './assertAssignWithDefaultUndefinedValue';
+import { assertIsObject } from './assertIsObject';
+import { assertIsString } from './assertIsString';
+
+describe('assertAssignWithDefaultUndefinedValue', () => {
+  it('should assert the input meets an assertion function and return if valid', () => {
+    expect(assertAssignWithDefaultUndefinedValue('123', assertIsString, 'xx')).toEqual('123');
+  });
+
+  it('should return default value if input is undefined', () => {
+    expect(assertAssignWithDefaultUndefinedValue(undefined, assertIsString, 'xx')).toEqual('xx');
+  });
+
+  it('should handle different types of type assertions', () => {
+    expect(assertAssignWithDefaultUndefinedValue(undefined, assertIsObject, { default: 'hello' })).toEqual({
+      default: 'hello',
+    });
+  });
+
+  it('should assert the input meets an assertion function and throw if not valid', () => {
+    expect(() => assertAssignWithDefaultUndefinedValue(123, assertIsString, 'xx')).toThrowErrorMatchingInlineSnapshot(
+      `"value is not a string"`,
+    );
+  });
+
+  it('should allow custom error message', () => {
+    expect(() =>
+      assertAssignWithDefaultUndefinedValue(123, assertIsString, 'xx', 'custom error'),
+    ).toThrowErrorMatchingInlineSnapshot(`"custom error"`);
+  });
+});

package/src/assertions/assertAssignWithDefaultUndefinedValue.ts

@@ -0,0 +1,17 @@
+import { assertAssign } from './assertAssign';
+
+/**
+ * If value is undefined, return default value otherwise assert it meets assertion rule
+ */
+export function assertAssignWithDefaultUndefinedValue<T>(
+  value: unknown,
+  assertionFunc: (val: unknown) => asserts val is T,
+  defaultValue: T,
+  errorMessage?: string,
+): T {
+  if (value === undefined || value === null) {
+    return defaultValue;
+  }
+
+  return assertAssign(value, assertionFunc, errorMessage);
+}

package/src/assertions/assertIsDefined.spec.ts

@@ -0,0 +1,19 @@
+import { assertIsDefined } from './assertIsDefined';
+
+describe('assertIsDefined', () => {
+  it('should throw an assertion error if input is undefined', () => {
+    expect(() => assertIsDefined(undefined)).toThrowErrorMatchingInlineSnapshot(
+      `"Expected 'val' to be defined, but received undefined"`,
+    );
+  });
+
+  it('should throw an assertion error if input is null', () => {
+    expect(() => assertIsDefined(null)).toThrowErrorMatchingInlineSnapshot(
+      `"Expected 'val' to be defined, but received null"`,
+    );
+  });
+
+  it('should return "void" or undefined if valid', () => {
+    expect(assertIsDefined(123)).toBeUndefined();
+  });
+});

package/src/assertions/assertIsDefined.ts

@@ -0,0 +1,7 @@
+import { AssertionError } from 'assert';
+
+export function assertIsDefined<T>(value: T): asserts value is NonNullable<T> {
+  if (value === undefined || value === null) {
+    throw new AssertionError({ message: `Expected 'val' to be defined, but received ${value}` });
+  }
+}

package/src/assertions/assertIsMapOfStringString.spec.ts

@@ -0,0 +1,23 @@
+import { assertIsMapOfStringString } from './assertIsMapOfStringString';
+
+describe('assertIsMapOfStringString', () => {
+  it('should not throw if input is an object with only string values', () => {
+    expect(assertIsMapOfStringString({ prop: 'aa' })).toBeUndefined();
+  });
+  it('should not throw if input is an empty object', () => {
+    expect(assertIsMapOfStringString({})).toBeUndefined();
+  });
+
+  it("should throw if object property isn't a string", () => {
+    expect(() => assertIsMapOfStringString({ prop: 123 })).toThrowErrorMatchingInlineSnapshot(
+      `"property prop is not type of string"`,
+    );
+  });
+
+  it('should throw if input is not an object', () => {
+    expect(() => assertIsMapOfStringString(123)).toThrowErrorMatchingInlineSnapshot(`"value is not a string"`);
+    expect(() => assertIsMapOfStringString(undefined)).toThrowErrorMatchingInlineSnapshot(
+      `"value cannot be null or undefined"`,
+    );
+  });
+});

package/src/assertions/assertIsMapOfStringString.ts

@@ -0,0 +1,29 @@
+import { AssertionError } from 'assert';
+
+export function assertIsMapOfStringString(value: unknown): asserts value is { [key: string]: string } {
+  if (!value) {
+    throw new AssertionError({
+      actual: value,
+      expected: 'not null',
+      message: 'value cannot be null or undefined',
+    });
+  }
+
+  if (typeof value !== 'object') {
+    throw new AssertionError({
+      actual: value,
+      expected: 'string',
+      message: 'value is not a string',
+    });
+  }
+
+  for (const [key, propValue] of Object.entries(value)) {
+    if (typeof propValue !== 'string') {
+      throw new AssertionError({
+        actual: typeof propValue,
+        expected: 'string',
+        message: `property ${key} is not type of string`,
+      });
+    }
+  }
+}

package/src/assertions/assertIsNotAnEmptyString.spec.ts

@@ -0,0 +1,25 @@
+import { assertIsNotAnEmptyString } from './assertIsNotAnEmptyString';
+
+describe('assertIsNotAnEmptyString', () => {
+  it('should throw if input value is not a string', () => {
+    expect(() => assertIsNotAnEmptyString(null)).toThrowErrorMatchingInlineSnapshot(`"value is not a string"`);
+    expect(() => assertIsNotAnEmptyString(undefined)).toThrowErrorMatchingInlineSnapshot(`"value is not a string"`);
+    expect(() => assertIsNotAnEmptyString(132)).toThrowErrorMatchingInlineSnapshot(`"value is not a string"`);
+    expect(() => assertIsNotAnEmptyString({})).toThrowErrorMatchingInlineSnapshot(`"value is not a string"`);
+    expect(() => assertIsNotAnEmptyString(['aa'])).toThrowErrorMatchingInlineSnapshot(`"value is not a string"`);
+  });
+
+  it('should throw if input is empty string', () => {
+    expect(() => assertIsNotAnEmptyString('')).toThrowErrorMatchingInlineSnapshot(`"string cannot be empty"`);
+  });
+
+  it('should throw if input is whitespace string', () => {
+    expect(() => assertIsNotAnEmptyString(' ')).toThrowErrorMatchingInlineSnapshot(`"string cannot be empty"`);
+    expect(() => assertIsNotAnEmptyString('     ')).toThrowErrorMatchingInlineSnapshot(`"string cannot be empty"`);
+  });
+
+  it('should not throw if string of length >= 1 is passed in', () => {
+    expect(assertIsNotAnEmptyString('1')).toBeUndefined();
+    expect(assertIsNotAnEmptyString('11111')).toBeUndefined();
+  });
+});

package/src/assertions/assertIsNotAnEmptyString.ts

@@ -0,0 +1,17 @@
+import { AssertionError } from 'assert';
+
+export function assertIsNotAnEmptyString(val: any): asserts val is string {
+  if (typeof val !== 'string') {
+    throw new AssertionError({
+      actual: typeof val,
+      expected: 'string',
+      message: 'value is not a string',
+    });
+  }
+
+  if (val.trim().length === 0) {
+    throw new AssertionError({
+      message: 'string cannot be empty',
+    });
+  }
+}