@squiz/db-lib 1.65.0 → 1.66.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Change Log
 
+## 1.66.0
+
+### Minor Changes
+
+- 8ce1826: Use DynamoDB in Content API service
+
 ## 1.65.0
 
 ### Minor Changes

package/lib/dynamodb/AbstractDynamoDbRepository.d.ts

@@ -0,0 +1,158 @@
+import { DynamoDBDocument } from '@aws-sdk/lib-dynamodb';
+import { Transaction, DynamoDbManager } from '..';
+interface Reader<T> {
+    queryItems(partialItem: Partial<T>, useSortKey?: boolean, index?: keyof TableIndexes): Promise<T[]>;
+    getItem(id: string | Partial<T>): Promise<T | undefined>;
+}
+interface Writer<T> {
+    createItem(item: Partial<T>): Promise<T>;
+    updateItem(partialItem: Partial<T>, newValue: Partial<T>): Promise<T | undefined>;
+    deleteItem(partialItem: Partial<T>): Promise<number>;
+}
+type Repository<T> = Reader<T> & Writer<T>;
+type Repositories = Record<string, Repository<any>>;
+export type TableKeys = {
+    pk: {
+        attributeName: string;
+        format: string;
+    };
+    sk: {
+        attributeName: string;
+        format: string;
+    };
+};
+export type TableIndexes = Record<string, TableKeys>;
+export type KeysFormat = Record<keyof TableKeys | keyof TableIndexes, string>;
+export type EntityDefinition = {
+    keys: TableKeys;
+    indexes: TableIndexes;
+};
+export declare abstract class AbstractDynamoDbRepository<SHAPE extends object, DATA_CLASS extends SHAPE> implements Reader<SHAPE>, Writer<SHAPE> {
+    protected tableName: string;
+    protected dbManager: DynamoDbManager<Repositories>;
+    protected entityName: string;
+    protected entityDefinition: EntityDefinition;
+    protected classRef: {
+        new (data?: Record<string, unknown>): DATA_CLASS;
+    };
+    protected client: DynamoDBDocument;
+    protected keys: TableKeys;
+    protected indexes: TableIndexes;
+    protected keysFormat: KeysFormat;
+    constructor(tableName: string, dbManager: DynamoDbManager<Repositories>, entityName: string, entityDefinition: EntityDefinition, classRef: {
+        new (data?: Record<string, unknown>): DATA_CLASS;
+    });
+    /**
+     * Get the single item matching the key fields value in the given
+     * partial item. Will throw MissingKeyValuesError if key field values
+     * are missing
+     *
+     * @param item
+     *
+     * @throws MissingKeyValuesError
+     */
+    getItem(item: Partial<SHAPE>): Promise<DATA_CLASS | undefined>;
+    /**
+     * Finds all the items matching the partition key or
+     * the gsi key (when gsi index name is specified)
+     *
+     * @param item
+     * @param useSortKey
+     * @param index
+     * @throws MissingKeyValuesError
+     */
+    queryItems(item: Partial<SHAPE>, useSortKey?: boolean, index?: keyof TableIndexes): Promise<DATA_CLASS[]>;
+    /**
+     * Update the existing item matching the key fields value
+     * in the passed in partialItem
+     * @param partialItem
+     * @param newValue
+     * @param transaction
+     *
+     * @returns Promise<SHAPE | undefined>
+     * @throws MissingKeyValuesError
+     */
+    updateItem(partialItem: Partial<SHAPE>, newValue: Exclude<Partial<SHAPE>, Record<string, never>>, transaction?: Transaction): Promise<DATA_CLASS | undefined>;
+    /**
+     * Adds new item to the table
+     *
+     * @param value
+     * @param transaction
+     *
+     * @returns Promise<SHAPE>
+     * @throws DuplicateItemError
+     * @throws MissingKeyValuesError
+     */
+    createItem(value: DATA_CLASS, transaction?: Transaction): Promise<DATA_CLASS>;
+    /**
+     * Deletes an item from the table
+     *
+     * @param partialItem
+     * @param transaction
+     * @returns number
+     * @throw MissingKeyValuesError
+     */
+    deleteItem(partialItem: Partial<SHAPE>, transaction?: Transaction): Promise<number>;
+    /**
+     * Return repo model object from the db value
+     * @param item
+     * @returns
+     */
+    protected hydrateItem(item: Record<string, unknown>): DATA_CLASS;
+    /**
+     * Evaluate the partition key value from the partial item
+     * @param item
+     * @returns string
+     * @throw MissingKeyValuesError
+     */
+    protected getPk(item: Partial<SHAPE>): string;
+    /**
+     * Evaluate the sort key value from the partial item
+     * @param item
+     * @returns string
+     *
+     * @throw MissingKeyValuesError
+     */
+    protected getSk(item: Partial<SHAPE>): string;
+    /**
+     * Evaluate the key value from the
+     *
+     * Example 1:
+     * Input:
+     *  - item: {id: foo, name: 'some-name' }
+     *  - attributeName: pk
+     *  - this.keysFormat = { pk: 'item#{id}', 'sk': '#meta', ... }
+     * Output:
+     *  - 'item#foo'
+     *
+     * Example 2:
+     * Input:
+     *  - item: {id: foo, name: 'some-name', itemType: 'A' }
+     *  - attributeName: sk
+     *  - this.keysFormat = { pk: 'item#{id}', 'sk': 'type#{itemType}', ... }
+     * Output:
+     *  - 'type#A'
+     *
+     * Example 3:
+     * Input:
+     *  - item: {id: foo, name: 'some-name' }
+     *  - attributeName: sk
+     *  - this.keysFormat = { pk: 'item#{id}', 'sk': 'name-type#{itemType}{name}', ... }
+     * Output:
+     *  - Error: "Key field "itemType" must be specified in the input item"
+     *
+     * @param item
+     * @param attributeName
+     *
+     * @returns string
+     * @throw MissingKeyValuesError
+     */
+    protected getKey(item: Partial<SHAPE>, attributeName: keyof KeysFormat): string;
+    /**
+     * Validate the data matches with "DATA_MODEL"
+     * @param value
+     * @return void
+     */
+    private assertValueMatchesModel;
+}
+export {};

package/lib/dynamodb/AbstractDynamoDbRepository.spec.d.ts

@@ -0,0 +1,24 @@
+import { AbstractDynamoDbRepository } from './AbstractDynamoDbRepository';
+import { DynamoDbManager } from './DynamoDbManager';
+import 'aws-sdk-client-mock-jest';
+interface ITestItem {
+    name: string;
+    age: number;
+    country: string;
+    data?: object;
+}
+declare class TestItem implements ITestItem {
+    name: string;
+    age: number;
+    country: string;
+    data: object;
+    constructor(data?: Partial<ITestItem>);
+}
+export type TestRepositories = {
+    testItem: TestItemRepository;
+};
+export type TestDbManager = DynamoDbManager<TestRepositories>;
+declare class TestItemRepository extends AbstractDynamoDbRepository<ITestItem, TestItem> {
+    constructor(tableName: string, dbManager: TestDbManager);
+}
+export {};

package/lib/dynamodb/DynamoDbManager.d.ts

@@ -0,0 +1,18 @@
+import { DynamoDBDocument, TransactWriteCommandInput } from '@aws-sdk/lib-dynamodb';
+export type Transaction = {
+    id?: string;
+};
+type TransactionItems = TransactWriteCommandInput['TransactItems'];
+export type TransactionItem = NonNullable<TransactionItems>[number];
+export declare class DynamoDbManager<TRepositories> {
+    client: DynamoDBDocument;
+    private transactionItems;
+    repositories: TRepositories;
+    constructor(client: DynamoDBDocument, repositoryCreator: (dbManager: DynamoDbManager<TRepositories>) => TRepositories);
+    executeInTransaction<T>(func: (transaction: Transaction) => Promise<T>): Promise<T>;
+    addWriteTransactionItem(transactionId: string, item: TransactionItem): void;
+    private executeTransaction;
+    private startTransaction;
+    private closeTransaction;
+}
+export {};

package/lib/error/DuplicateItemError.d.ts

@@ -0,0 +1,5 @@
+import { InternalServerError } from '@squiz/dx-common-lib';
+export declare class DuplicateItemError extends InternalServerError {
+    name: string;
+    constructor(message: string);
+}

package/lib/error/InvalidDbSchemaError.d.ts

@@ -0,0 +1,5 @@
+import { BadRequestError } from '@squiz/dx-common-lib';
+export declare class InvalidDbSchemaError extends BadRequestError {
+    name: string;
+    constructor(message: string);
+}

package/lib/error/MissingKeyValuesError.d.ts

@@ -0,0 +1,5 @@
+import { InternalServerError } from '@squiz/dx-common-lib';
+export declare class MissingKeyValuesError extends InternalServerError {
+    name: string;
+    constructor(message: string);
+}

package/lib/error/TransactionError.d.ts

@@ -0,0 +1,5 @@
+import { InternalServerError } from '@squiz/dx-common-lib';
+export declare class TransactionError extends InternalServerError {
+    name: string;
+    constructor(message: string);
+}

package/lib/index.d.ts

@@ -1,7 +1,13 @@
 export * from './AbstractRepository';
 export * from './ConnectionManager';
+export * from './dynamodb/DynamoDbManager';
+export * from './dynamodb/AbstractDynamoDbRepository';
 export * from './Migrator';
 export * from './Repositories';
 export * from './getConnectionInfo';
+export * from './error/DuplicateItemError';
+export * from './error/TransactionError';
+export * from './error/MissingKeyValuesError';
+export * from './error/InvalidDbSchemaError';
 export * from './PostgresErrorCodes';
 export { Pool, PoolClient } from 'pg';