@squiz/db-lib 1.12.0-alpha.8 → 1.12.1-alpha.0

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "@squiz/db-lib",
-  "version": "1.12.0-alpha.8",
+  "version": "1.12.1-alpha.0",
   "description": "",
   "main": "lib/index.js",
   "scripts": {
     "compile": "node build.js && tsc",
-    "test": "jest -c jest.config.ts --passWithNoTests",
+    "test": "jest -c jest.config.ts --testMatch=\"**/*.spec.ts\" --testMatch=\"!**/*.integration.spec.ts\" --passWithNoTests",
+    "test:integration": "jest --testMatch=\"**/*.integration.spec.ts\" --passWithNoTests",
     "test:update-snapshots": "jest -c jest.config.ts --updateSnapshot",
     "clean": "rimraf \"tsconfig.tsbuildinfo\" \"./lib\""
   },
@@ -19,16 +20,16 @@
     "fs-extra": "11.1.0",
     "jest": "29.4.1",
     "rimraf": "4.1.2",
-    "ts-jest": "28.0.8",
+    "ts-jest": "29.0.5",
     "ts-loader": "9.3.1",
     "ts-node": "10.9.1",
     "typescript": "4.9.4"
   },
   "dependencies": {
     "@aws-sdk/client-secrets-manager": "3.264.0",
-    "@squiz/dx-logger-lib": "1.12.0-alpha.8",
+    "@squiz/dx-logger-lib": "1.12.1-alpha.0",
     "dotenv": "16.0.3",
     "pg": "8.9.0"
   },
-  "gitHead": "3a835dd86ed757cb28f4fc51a80114215f4fea41"
+  "gitHead": "4a0c81e76ca50706d137dee82869e3ea7844376e"
 }

package/src/AbstractRepository.integration.spec.ts

@@ -0,0 +1,155 @@
+import { AbstractRepository } from './AbstractRepository';
+import { ConnectionManager } from './ConnectionManager';
+
+interface IRepoTest {
+  lowercase: string;
+  camelCase: string;
+  PascalCase: string;
+  snake_case: string;
+  'kebab-case': string;
+  UPPERCASE: string;
+}
+
+class RepoTest implements IRepoTest {
+  public lowercase: string;
+  public camelCase: string;
+  public PascalCase: string;
+  public snake_case: string;
+  public 'kebab-case': string;
+  public UPPERCASE: string;
+
+  constructor(data: Partial<IRepoTest> = {}) {
+    this.lowercase = data.lowercase ?? 'some lowercase';
+    this.camelCase = data.camelCase ?? 'some camelCase';
+    this.PascalCase = data.PascalCase ?? 'some PascalCase';
+    this.snake_case = data.snake_case ?? 'some snake_case';
+    this['kebab-case'] = data['kebab-case'] ?? 'some kebab-case';
+    this.UPPERCASE = data.UPPERCASE ?? 'some UPPERCASE';
+  }
+}
+
+function defaultMapping(): { [key in keyof IRepoTest]: string } {
+  return {
+    lowercase: 'lowercase',
+    camelCase: 'camel_case',
+    PascalCase: 'pascal_case',
+    snake_case: 'snake_case',
+    'kebab-case': 'kebab_case',
+    UPPERCASE: 'uppercase',
+  };
+}
+
+const allProperties = Object.keys(defaultMapping()) as Array<keyof IRepoTest>;
+
+class AbstractRepositoryIntegrationTest extends AbstractRepository<IRepoTest, RepoTest> {}
+
+describe('AbstractRepository', () => {
+  let db: ConnectionManager<{ test: AbstractRepositoryIntegrationTest }>;
+  beforeAll(async () => {
+    db = new ConnectionManager(
+      'AbstractRepositoryIntegrationTest',
+      process.env.COMPONENT_DB_CONNECTION_STRING!,
+      '',
+      [],
+      (db) => ({
+        test: new AbstractRepositoryIntegrationTest(
+          db.repositories,
+          db.pool,
+          'abstract_repository_db_test',
+          defaultMapping(),
+          RepoTest,
+        ),
+      }),
+    );
+    await db.pool.query(`
+        CREATE TABLE IF NOT EXISTS abstract_repository_db_test (
+            lowercase text,
+            camel_case text,
+            pascal_case text,
+            snake_case text,
+            kebab_case text,
+            uppercase text
+        );
+    `);
+  });
+
+  afterAll(async () => {
+    await db.pool.query('DROP TABLE IF EXISTS abstract_repository_db_test;');
+    await db.close();
+  });
+
+  describe('properties are always mapped to columns', () => {
+    beforeEach(async () => {
+      await db.pool.query('DELETE FROM abstract_repository_db_test;');
+    });
+    it('create', async () => {
+      const repo = db.repositories.test;
+      const data = new RepoTest();
+      const result = await repo.create(data);
+      expect(result).toEqual(data);
+    });
+
+    it.each(allProperties)('update %s', async (property) => {
+      const repo = db.repositories.test;
+      const data = await repo.create(new RepoTest());
+      const result = await repo.update({ [property]: data[property] }, { [property]: `new ${data[property]}` });
+      expect(result).toEqual([{ ...data, [property]: `new ${data[property]}` }]);
+    });
+
+    it.each(allProperties)('delete %s', async (property) => {
+      const repo = db.repositories.test;
+      const data = await repo.create(new RepoTest());
+      const result = await repo.delete({ [property]: data[property] });
+      expect(result).toEqual(1);
+    });
+
+    it.each(allProperties)('findOne %s', async (property) => {
+      const repo = db.repositories.test;
+      const findData = await repo.create(new RepoTest({ [property]: 'some value' }));
+      const _differentData = await repo.create(new RepoTest({ [property]: 'some other value' }));
+
+      const result = await repo.findOne({ [property]: findData[property] });
+      expect(result).toEqual(findData);
+    });
+
+    it.each(allProperties)('find %s', async (property) => {
+      const repo = db.repositories.test;
+      const findData = await repo.create(new RepoTest({ [property]: 'some value' }));
+      const _differentData = await repo.create(new RepoTest({ [property]: 'some other value' }));
+
+      const result = await repo.find({ [property]: findData[property] });
+      expect(result).toEqual([findData]);
+    });
+
+    it.each(allProperties)('findAll %s', async (property) => {
+      const repo = db.repositories.test;
+      const findData = await repo.create(new RepoTest({ [property]: 'some value' }));
+      const differentData = await repo.create(new RepoTest({ [property]: 'some other value' }));
+
+      const result = await repo.findAll();
+      expect(result).toEqual([findData, differentData]);
+    });
+
+    it.each(allProperties)('getPage %s', async (property) => {
+      const repo = db.repositories.test;
+      const firstData = await repo.create(new RepoTest({ [property]: 'aaaaa' }));
+      const secondData = await repo.create(new RepoTest({ [property]: 'bbbb' }));
+
+      const ascResult = await repo.getPage(1, [property], 'asc');
+      expect(ascResult).toMatchObject({ items: [firstData, secondData], totalCount: 2 });
+      const descResult = await repo.getPage(1, [property], 'desc');
+      expect(descResult).toMatchObject({ items: [secondData, firstData], totalCount: 2 });
+    });
+
+    it.each(allProperties)('getPageRaw %s', async (property) => {
+      const repo = db.repositories.test;
+      const firstData = await repo.create(new RepoTest({ [property]: 'aaaaa' }));
+      const secondData = await repo.create(new RepoTest({ [property]: 'bbbb' }));
+
+      const ascResult = await repo.getPageRaw(1, [property], 'asc');
+      expect(ascResult).toMatchObject({ items: [firstData, secondData], totalCount: 2 });
+      const descResult = await repo.getPageRaw(1, [property], 'desc');
+      expect(descResult).toMatchObject({ items: [secondData, firstData], totalCount: 2 });
+    });
+  });
+});

package/src/AbstractRepository.ts

@@ -23,11 +23,13 @@ export type PageResult<T> = {
 export type SortDirection = 'desc' | 'asc';
 export const DEFAULT_PAGE_SIZE = 20;
 
-export abstract class AbstractRepository<T extends object, ObjT extends T> implements Reader<T>, Writer<T> {
+export abstract class AbstractRepository<SHAPE extends object, DATA_CLASS extends SHAPE>
+  implements Reader<SHAPE>, Writer<SHAPE>
+{
   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 modelPropertyToSqlColumn: { [key in keyof SHAPE]: string };
   /** object where the key is the sql column name and the value is the model property name */
   protected sqlColumnToModelProperty: { [key: string]: string };
 
@@ -35,8 +37,8 @@ export abstract class AbstractRepository<T extends object, ObjT extends T> imple
     protected repositories: Repositories,
     protected pool: Pool,
     tableName: string,
-    mapping: { [key in keyof T]: string },
-    protected classRef: { new (data?: Record<string, unknown>): ObjT },
+    mapping: { [key in keyof SHAPE]: string },
+    protected classRef: { new (data?: Record<string, unknown>): DATA_CLASS },
   ) {
     this.tableName = `"${tableName}"`;
 
@@ -53,9 +55,9 @@ export abstract class AbstractRepository<T extends object, ObjT extends T> imple
     return await this.pool.connect();
   }
 
-  async create(value: ObjT, transactionClient: PoolClient | null = null): Promise<T> {
+  async create(value: DATA_CLASS, transactionClient: PoolClient | null = null): Promise<SHAPE> {
     const columns = Object.keys(value)
-      .map((a) => `"${this.modelPropertyToSqlColumn[a as keyof T]}"`)
+      .map((a) => `"${this.modelPropertyToSqlColumn[a as keyof SHAPE]}"`)
       .join(', ');
 
     const values = Object.values(value)
@@ -71,12 +73,16 @@ export abstract class AbstractRepository<T extends object, ObjT extends T> imple
     return result[0];
   }
 
-  async update(where: Partial<T>, newValue: Partial<T>, transactionClient: PoolClient | null = null): Promise<T[]> {
+  async update(
+    where: Partial<SHAPE>,
+    newValue: Partial<SHAPE>,
+    transactionClient: PoolClient | null = null,
+  ): Promise<SHAPE[]> {
     const whereValues = Object.values(where);
     const newValues = Object.values(newValue);
 
     const setString = Object.keys(newValue)
-      .map((a, index) => `"${this.modelPropertyToSqlColumn[a as keyof T]}" = $${index + 1}`)
+      .map((a, index) => `"${this.modelPropertyToSqlColumn[a as keyof SHAPE]}" = $${index + 1}`)
       .join(', ');
 
     const whereString = this.createWhereStringFromPartialModel(where, newValues.length);
@@ -93,7 +99,7 @@ export abstract class AbstractRepository<T extends object, ObjT extends T> imple
     return result;
   }
 
-  async delete(where: Partial<T>, transactionClient: PoolClient | null = null): Promise<number> {
+  async delete(where: Partial<SHAPE>, transactionClient: PoolClient | null = null): Promise<number> {
     const client = transactionClient ?? (await this.getConnection());
 
     try {
@@ -109,7 +115,7 @@ export abstract class AbstractRepository<T extends object, ObjT extends T> imple
     }
   }
 
-  protected createWhereStringFromPartialModel(values: Partial<T>, initialIndex: number = 0) {
+  protected createWhereStringFromPartialModel(values: Partial<SHAPE>, initialIndex: number = 0) {
     const keys = Object.keys(values);
 
     if (keys.length == 0) {
@@ -117,7 +123,7 @@ export abstract class AbstractRepository<T extends object, ObjT extends T> imple
     }
 
     const sql = keys.reduce((acc, key, index) => {
-      const condition = `"${this.modelPropertyToSqlColumn[key as keyof T]}" = $${1 + index + initialIndex}`;
+      const condition = `"${this.modelPropertyToSqlColumn[key as keyof SHAPE]}" = $${1 + index + initialIndex}`;
 
       return acc === '' ? `${acc} ${condition}` : `${acc} AND ${condition}`;
     }, '');
@@ -146,12 +152,12 @@ export abstract class AbstractRepository<T extends object, ObjT extends T> imple
     query: string,
     values: any[],
     transactionClient: PoolClient | null = null,
-  ): Promise<T[]> {
+  ): Promise<SHAPE[]> {
     const rows = await this.executeQueryRaw(query, values, transactionClient);
     return rows.map((a) => this.createAndHydrateModel(a));
   }
 
-  protected createAndHydrateModel(row: any): T {
+  protected createAndHydrateModel(row: any): SHAPE {
     const inputData: Record<string, unknown> = {};
 
     for (const key of Object.keys(row)) {
@@ -162,7 +168,7 @@ export abstract class AbstractRepository<T extends object, ObjT extends T> imple
     return new this.classRef(inputData);
   }
 
-  async findOne(item: Partial<T>): Promise<T | undefined> {
+  async findOne(item: Partial<SHAPE>): Promise<SHAPE | undefined> {
     const result = await this.executeQuery(
       `SELECT *
       FROM ${this.tableName}
@@ -174,7 +180,7 @@ export abstract class AbstractRepository<T extends object, ObjT extends T> imple
     return result[0];
   }
 
-  async find(item: Partial<T>): Promise<T[]> {
+  async find(item: Partial<SHAPE>): Promise<SHAPE[]> {
     const result = await this.executeQuery(
       `SELECT *
       FROM ${this.tableName}
@@ -185,7 +191,7 @@ export abstract class AbstractRepository<T extends object, ObjT extends T> imple
     return result;
   }
 
-  async findAll(): Promise<T[]> {
+  async findAll(): Promise<SHAPE[]> {
     const result = await this.executeQuery(
       `SELECT *
       FROM ${this.tableName}`,
@@ -195,7 +201,7 @@ export abstract class AbstractRepository<T extends object, ObjT extends T> imple
     return result;
   }
 
-  async getCount(item: Partial<T> | null = null): Promise<number> {
+  async getCount(item: Partial<SHAPE> | null = null): Promise<number> {
     let whereClause = '';
 
     if (item) {
@@ -207,46 +213,25 @@ export abstract class AbstractRepository<T extends object, ObjT extends T> imple
 
   async getPage(
     pageNumber: number,
-    sortBy: (keyof T)[] = [],
+    sortBy: (keyof SHAPE)[] = [],
     direction: SortDirection = 'asc',
     pageSize: number | null = null,
-    item: Partial<T> | null = null,
-  ): Promise<PageResult<T>> {
-    if (pageSize === null) {
-      pageSize = DEFAULT_PAGE_SIZE;
-    }
-    if (pageNumber <= 0) {
-      throw new Error(`Page number value cannot be less than 1`);
-    }
-    if (pageSize <= 0) {
-      throw new Error(`Page size value cannot be less than 1`);
-    }
+    item: Partial<SHAPE> | null = null,
+  ): Promise<PageResult<SHAPE>> {
     let whereClause = '';
     if (item) {
       whereClause = `WHERE ${this.createWhereStringFromPartialModel(item)}`;
     }
 
-    let orderByClause = '';
-    if (sortBy.length) {
-      orderByClause = `ORDER BY ${sortBy
-        .map((a) => this.modelPropertyToSqlColumn[a as keyof T])
-        .join(',')} ${direction}`;
-    }
-    const offset = (pageNumber - 1) * pageSize;
-
-    const items = await this.executeQuery(
-      `SELECT *
-      FROM ${this.tableName} ${whereClause} ${orderByClause}
-      OFFSET ${offset}
-      LIMIT ${pageSize}`,
-      item ? Object.values(item) : [],
-    );
-
-    return {
-      items,
-      totalCount: await this.getCount(item),
+    return this.getPageRaw(
+      pageNumber,
+      sortBy,
+      direction,
+      whereClause,
+      this.tableName,
+      Object.values(item ?? {}),
       pageSize,
-    };
+    );
   }
 
   async getCountRaw(whereClause: string = '', values: any[] = [], tableRef: string = ''): Promise<number> {
@@ -260,13 +245,13 @@ export abstract class AbstractRepository<T extends object, ObjT extends T> imple
 
   async getPageRaw(
     pageNumber: number,
-    sortBy: (keyof T)[] = [],
+    sortBy: (keyof SHAPE)[] = [],
     direction: SortDirection = 'asc',
     whereClause: string = '',
     tableRef: string = '',
     values: any[] = [],
     pageSize: number | null = null,
-  ): Promise<PageResult<T>> {
+  ): Promise<PageResult<SHAPE>> {
     if (pageSize === null) {
       pageSize = DEFAULT_PAGE_SIZE;
     }
@@ -279,7 +264,9 @@ export abstract class AbstractRepository<T extends object, ObjT extends T> imple
 
     let orderByClause = '';
     if (sortBy.length) {
-      orderByClause = `ORDER BY ${sortBy.join(',')} ${direction}`;
+      orderByClause = `ORDER BY ${sortBy
+        .map((a) => this.modelPropertyToSqlColumn[a as keyof SHAPE])
+        .join(',')} ${direction}`;
     }
 
     const offset = (pageNumber - 1) * pageSize;

package/test.env

@@ -0,0 +1 @@
+COMPONENT_DB_CONNECTION_STRING=postgresql://root:root@localhost:5432/cmp_db?schema=public