@monorise/core 1.0.2 → 1.0.4-0

package/data/ProjectionExpression.ts

@@ -1,8 +0,0 @@
-export type ProjectionExpressionValues =
-  (typeof PROJECTION_EXPRESSION)[keyof typeof PROJECTION_EXPRESSION];
-
-export const PROJECTION_EXPRESSION = {
-  NO_DATA: 'byEntityType, byEntityId, entityType, entityId, mutualId',
-  MUTUAL_DATA_ONLY:
-    'byEntityType, byEntityId, entityType, entityId, mutualId, mutualData',
-} as const;

package/data/Tag.ts

@@ -1,470 +0,0 @@
-import type {
-  AttributeValue,
-  DynamoDB,
-  QueryCommandInput,
-} from '@aws-sdk/client-dynamodb';
-import { marshall, unmarshall } from '@aws-sdk/util-dynamodb';
-import type { EntitySchemaMap, Entity as EntityType } from '@monorise/base';
-import { StandardError } from '../errors/standard-error';
-import { Entity } from './Entity';
-import type { ProjectionExpressionValues } from './ProjectionExpression';
-import { Repository } from './abstract/Repository.base';
-
-export class TaggedEntity<T extends EntityType> extends Entity<T> {
-  public tagName: string;
-  public group?: string;
-  public sortValue?: string;
-
-  constructor({
-    tagName,
-    group,
-    sortValue,
-    entityType,
-    entityId,
-    data,
-    createdAt,
-    updatedAt,
-  }: {
-    tagName: string;
-    group?: string;
-    sortValue?: string;
-    entityType: T;
-    entityId: string;
-    data?: Partial<EntitySchemaMap[T]>;
-    createdAt?: Date;
-    updatedAt?: Date;
-  }) {
-    super(entityType, entityId, data, createdAt, updatedAt);
-
-    this.tagName = tagName;
-    this.group = group;
-    this.sortValue = sortValue;
-  }
-
-  static fromItem<T extends EntityType>(
-    item?: Record<string, AttributeValue>,
-  ): TaggedEntity<T> {
-    if (!item) throw new StandardError('TAG_IS_UNDEFINED', 'Tag item empty');
-
-    const parsedItem = unmarshall(item);
-
-    return new TaggedEntity<T>({
-      tagName: parsedItem.tagName,
-      group: parsedItem.group,
-      sortValue: parsedItem.sortValue,
-      entityType: parsedItem.entityType,
-      entityId: parsedItem.entityId,
-      data: parsedItem.data,
-      createdAt: parsedItem.createdAt
-        ? new Date(parsedItem.createdAt)
-        : undefined,
-      updatedAt: parsedItem.updatedAt
-        ? new Date(parsedItem.updatedAt)
-        : undefined,
-    });
-  }
-
-  get pk(): string {
-    return `TAG#${this.entityType}#${this.tagName}${this.group ? `#${this.group}` : ''}`;
-  }
-
-  get sk(): string {
-    return `${this.sortValue ? `${this.sortValue}#` : ''}${this.entityType}#${this.entityId}`;
-  }
-
-  reversedKeys(): Record<string, AttributeValue> {
-    return {
-      PK: { S: `${this.entityType}#${this.entityId}` },
-      SK: {
-        S: this.pk,
-      },
-    };
-  }
-
-  replicationKeys(): Record<string, AttributeValue> {
-    const keys = this.reversedKeys();
-
-    return {
-      R1PK: keys.PK,
-      R1SK: keys.SK,
-    };
-  }
-
-  toItem(): Record<string, AttributeValue> {
-    return {
-      ...marshall(this.toJSON(), { removeUndefinedValues: true }),
-      ...this.keys(),
-    };
-  }
-
-  toJSON(): Record<string, unknown> {
-    return {
-      tagName: this.tagName,
-      group: this.group,
-      sortValue: this.sortValue,
-      entityType: this.entityType,
-      entityId: this.entityId,
-      data: this.data,
-      createdAt: this.createdAt,
-      updatedAt: this.updatedAt,
-    };
-  }
-}
-
-export class TagRepository extends Repository {
-  constructor(
-    private readonly TABLE_NAME: string,
-    private readonly dynamodbClient: DynamoDB,
-  ) {
-    super();
-  }
-
-  async getExistingTags<T extends EntityType>({
-    entityType,
-    entityId,
-    tagName,
-  }: {
-    entityType: T;
-    entityId: string;
-    tagName: string;
-  }): Promise<TaggedEntity<T>[]> {
-    const PK = `${entityType}#${entityId}`;
-    const SK = `TAG#${entityType}#${tagName}`;
-
-    const results = await this.dynamodbClient.query({
-      TableName: this.TABLE_NAME,
-      KeyConditionExpression: '#PK = :PK and begins_with(#SK, :SK)',
-      ExpressionAttributeNames: {
-        '#PK': 'PK',
-        '#SK': 'SK',
-      },
-      ExpressionAttributeValues: {
-        ':PK': { S: PK },
-        ':SK': { S: SK },
-      },
-    });
-
-    return (results.Items || []).map((item: any) => {
-      return TaggedEntity.fromItem(item);
-    });
-  }
-
-  async deleteTag({
-    tagName,
-    group,
-    sortValue,
-    entityType,
-    entityId,
-  }: {
-    tagName: string;
-    group?: string;
-    sortValue?: string;
-    entityType: EntityType;
-    entityId: string;
-  }): Promise<void> {
-    const tag = new TaggedEntity({
-      tagName,
-      group,
-      sortValue,
-      entityType,
-      entityId,
-    });
-
-    await Promise.all([
-      this.dynamodbClient.deleteItem({
-        TableName: this.TABLE_NAME,
-        Key: tag.keys(),
-      }),
-      this.dynamodbClient.deleteItem({
-        TableName: this.TABLE_NAME,
-        Key: tag.reversedKeys(),
-      }),
-    ]);
-
-    return;
-  }
-
-  async createTag<T extends EntityType>({
-    tagName,
-    group,
-    sortValue,
-    entity,
-  }: {
-    tagName: string;
-    group?: string;
-    sortValue?: string;
-    entity: Entity<T>;
-  }): Promise<TaggedEntity<T>> {
-    if (!entity.entityId) {
-      throw new StandardError(
-        'ENTITY_ID_IS_UNDEFINED',
-        'entityId is undefined',
-      );
-    }
-
-    const tag = new TaggedEntity({
-      tagName,
-      group,
-      sortValue,
-      entityType: entity.entityType,
-      entityId: entity.entityId,
-      data: entity.data,
-      createdAt: entity.createdAt ? new Date(entity.createdAt) : new Date(),
-      updatedAt: entity.updatedAt ? new Date(entity.updatedAt) : new Date(),
-    });
-
-    await Promise.all([
-      this.dynamodbClient.putItem({
-        TableName: this.TABLE_NAME,
-        Item: {
-          ...tag.toItem(),
-          ...tag.replicationKeys(),
-        },
-      }),
-      this.dynamodbClient.putItem({
-        TableName: this.TABLE_NAME,
-        Item: {
-          ...marshall(
-            {
-              tagName,
-              group,
-              sortValue,
-            },
-            { removeUndefinedValues: true },
-          ),
-          ...tag.reversedKeys(),
-          ...tag.replicationKeys(),
-        },
-      }),
-    ]);
-
-    return tag;
-  }
-
-  async listTags<T extends EntityType>({
-    entityType,
-    tagName,
-    limit, // if this is not set, it will return all items
-    query,
-    group,
-    start,
-    end,
-    options = {},
-  }: {
-    entityType: T;
-    tagName: string;
-    limit?: number;
-    start?: string;
-    end?: string;
-    query?: string;
-    group?: string;
-    options?: {
-      lastKey?: Record<string, AttributeValue>;
-      ProjectionExpression?: ProjectionExpressionValues;
-    };
-  }): Promise<{
-    items: Entity<T>[];
-    totalCount?: number;
-    lastKey?: Record<string, AttributeValue>;
-  }> {
-    const errorContext: Record<string, unknown> = {
-      entityType,
-      tagName,
-      limit,
-      query,
-      group,
-      start,
-      end,
-      options,
-    };
-
-    const tag = new TaggedEntity({
-      tagName,
-      entityType,
-      entityId: '',
-      group,
-    });
-
-    let expression: Pick<
-      QueryCommandInput,
-      | 'KeyConditionExpression'
-      | 'ExpressionAttributeNames'
-      | 'ExpressionAttributeValues'
-    > | null = null;
-
-    if (query && !start && !end) {
-      expression = {
-        KeyConditionExpression: '#PK = :PK and begins_with(#SK, :SK)',
-        ExpressionAttributeNames: {
-          '#PK': 'PK',
-          '#SK': 'SK',
-        },
-        ExpressionAttributeValues: {
-          ':PK': {
-            S: tag.pk,
-          },
-          ':SK': {
-            S: `${query}#`,
-          },
-        },
-      };
-    } else if (start && end) {
-      expression = {
-        KeyConditionExpression: '#PK = :PK and #SK between :SKStart and :SKEnd',
-        ExpressionAttributeNames: {
-          '#PK': 'PK',
-          '#SK': 'SK',
-        },
-        ExpressionAttributeValues: {
-          ':PK': {
-            S: tag.pk,
-          },
-          ':SKStart': {
-            S: `${start}#`,
-          },
-          ':SKEnd': {
-            S: `${end}#`,
-          },
-        },
-      };
-    } else if (start && !end) {
-      expression = {
-        KeyConditionExpression: '#PK = :PK and #SK >= :SK',
-        ExpressionAttributeNames: {
-          '#PK': 'PK',
-          '#SK': 'SK',
-        },
-        ExpressionAttributeValues: {
-          ':PK': {
-            S: tag.pk,
-          },
-          ':SK': {
-            S: `${start}#`,
-          },
-        },
-      };
-    } else if (!start && end) {
-      expression = {
-        KeyConditionExpression: '#PK = :PK and #SK <= :SK',
-        ExpressionAttributeNames: {
-          '#PK': 'PK',
-          '#SK': 'SK',
-        },
-        ExpressionAttributeValues: {
-          ':PK': {
-            S: tag.pk,
-          },
-          ':SK': {
-            S: `${end}#`,
-          },
-        },
-      };
-    } else if (group && !query && !start && !end) {
-      expression = {
-        KeyConditionExpression: '#PK = :PK',
-        ExpressionAttributeNames: {
-          '#PK': 'PK',
-        },
-        ExpressionAttributeValues: {
-          ':PK': {
-            S: tag.pk,
-          },
-        },
-      };
-    }
-
-    if (!expression) {
-      throw new StandardError(
-        'INVALID_QUERY',
-        'Invalid query. Please provide a valid query',
-        null,
-        errorContext,
-      );
-    }
-    const defaultListQuery: QueryCommandInput = {
-      TableName: this.TABLE_NAME,
-      Limit: limit,
-      ScanIndexForward: false,
-      ProjectionExpression: options?.ProjectionExpression,
-      ...expression,
-    };
-
-    let lastKey = options.lastKey;
-    let items: Record<string, AttributeValue>[] = [];
-    let remainingCount = limit ?? 0;
-    do {
-      const resp = await this.dynamodbClient.query({
-        ...defaultListQuery,
-        ...(remainingCount && { Limit: remainingCount }),
-        ...(lastKey && {
-          ExclusiveStartKey: lastKey,
-        }),
-      });
-      items = items.concat(resp.Items ?? []);
-
-      lastKey = resp.LastEvaluatedKey;
-
-      if (limit) {
-        remainingCount = remainingCount - (resp.Items?.length ?? 0);
-      }
-    } while (
-      // limit is given, haven't reach limit, and there are still items to retrieve
-      (limit && remainingCount && lastKey) ||
-      // no limit is given and there are still items to retrieve
-      (!limit && lastKey)
-    );
-
-    return {
-      items: (items || []).map(Entity.fromItem<T>),
-      totalCount: items.length,
-      lastKey,
-    };
-  }
-
-  async createLock({
-    entityType,
-    entityId,
-  }: {
-    entityType: EntityType;
-    entityId: string;
-  }): Promise<void> {
-    const oneMinuteLater = Math.floor(new Date().getTime() / 1000 + 1 * 60);
-
-    await this.dynamodbClient.putItem({
-      TableName: this.TABLE_NAME,
-      Item: {
-        PK: { S: `TAG#${entityType}#${entityId}` },
-        SK: { S: '#LOCK#' },
-        expiresAt: {
-          // auto delete lock after 1 minute
-          N: `${oneMinuteLater}`,
-        },
-      },
-      ConditionExpression: 'attribute_not_exists(PK)',
-    });
-
-    return;
-  }
-
-  async deleteLock({
-    entityType,
-    entityId,
-  }: {
-    entityType: EntityType;
-    entityId: string;
-  }): Promise<void> {
-    try {
-      await this.dynamodbClient.deleteItem({
-        TableName: this.TABLE_NAME,
-        Key: {
-          PK: { S: `TAG#${entityType}#${entityId}` },
-          SK: { S: '#LOCK#' },
-        },
-      });
-
-      return;
-    } catch (error) {
-      // if lock is not found, it's okay
-    }
-  }
-}

package/data/abstract/Item.base.ts

@@ -1,19 +0,0 @@
-import type { AttributeValue } from '@aws-sdk/client-dynamodb';
-
-export abstract class Item {
-  abstract get pk(): string;
-  abstract get sk(): string;
-  abstract get createdAt(): string | undefined;
-  abstract get updatedAt(): string | undefined;
-
-  public keys(): Record<string, AttributeValue> {
-    return {
-      PK: { S: this.pk },
-      SK: { S: this.sk },
-    };
-  }
-
-  abstract toItem(): Record<string, AttributeValue>;
-
-  abstract toJSON(): Record<string, unknown>;
-}

package/data/abstract/Repository.base.ts

@@ -1,92 +0,0 @@
-import type { AttributeValue } from '@aws-sdk/client-dynamodb';
-import { marshall } from '@aws-sdk/util-dynamodb';
-
-function flattenObject(
-  obj: Record<string, unknown>,
-  parentKey = '',
-  result: Record<string, unknown> = {},
-  level = 1,
-  opts?: {
-    maxLevel?: number;
-  },
-): Record<string, unknown> {
-  const MAX_LEVEL = opts?.maxLevel ?? 2;
-
-  for (const key in obj) {
-    if (obj.hasOwnProperty(key)) {
-      const propName = parentKey ? `${parentKey}.${key}` : key;
-      if (
-        typeof obj[key] === 'object' &&
-        obj[key] !== null &&
-        !Array.isArray(obj[key]) &&
-        level < MAX_LEVEL
-      ) {
-        flattenObject(
-          obj[key] as Record<string, unknown>,
-          propName,
-          result,
-          level + 1,
-          opts,
-        );
-      } else {
-        result[propName] = obj[key];
-      }
-    }
-  }
-  return result;
-}
-
-export abstract class Repository {
-  toUpdate(
-    parsedUpdateData: Record<string, unknown>,
-    opts?: {
-      // to limit the partial update depth for an object
-      // in some scenario, we have to ensure the object to be written must be an object instead of undefined/null
-      // eg, writing to data.cover.name must ensure data.cover is an object already else we will get error
-      maxLevel?: number;
-    },
-  ): {
-    UpdateExpression: string;
-    ExpressionAttributeNames: Record<string, string>;
-    ExpressionAttributeValues: Record<string, AttributeValue>;
-  } {
-    const flattenedData = flattenObject(parsedUpdateData, '', {}, 1, opts);
-
-    let updateExpression = '';
-    const expressionAttributeNames: Record<string, string> = {};
-    const expressionAttributeValues: Record<string, unknown> = {};
-
-    for (const key in flattenedData) {
-      if (updateExpression.length > 0) {
-        updateExpression += ', ';
-      }
-      const attributePath = key
-        .split('.')
-        .map((part) => `#${part}`)
-        .join('.');
-      const valuePlaceholder = `:${key.replace(/\./g, '_')}`;
-
-      updateExpression += `${attributePath} = ${valuePlaceholder}`;
-
-      key.split('.').forEach((part) => {
-        expressionAttributeNames[`#${part}`] = part;
-      });
-
-      expressionAttributeValues[valuePlaceholder] = flattenedData[key];
-    }
-
-    updateExpression = `SET ${updateExpression}`;
-
-    const updateAttributes = {
-      UpdateExpression: updateExpression,
-      ExpressionAttributeNames: {
-        ...expressionAttributeNames,
-      },
-      ExpressionAttributeValues: {
-        ...marshall(expressionAttributeValues),
-      },
-    };
-
-    return updateAttributes;
-  }
-}

package/errors/api-error.ts

@@ -1,39 +0,0 @@
-import * as httpStatus from 'http-status';
-import ExtendableError from './extendable-error';
-
-/**
- * Class representing an API error.
- * @extends ExtendableError
- */
-class APIError extends ExtendableError {
-  /**
-   * Creates an API error.
-   * @param {string} message - Error message.
-   * @param {number} status - HTTP status code of error.
-   * @param {boolean} isPublic - Whether the message should be visible to user or not.
-   * @param {string | undefined} stack - Stack trace.
-   */
-  constructor({
-    message,
-    errors,
-    stack,
-    status = httpStatus.INTERNAL_SERVER_ERROR,
-    isPublic = false,
-  }: {
-    message: string;
-    errors?: any;
-    stack?: string;
-    status?: number;
-    isPublic?: boolean;
-  }) {
-    super({
-      message,
-      errors,
-      status,
-      isPublic,
-      stack,
-    });
-  }
-}
-
-export default APIError;

package/errors/extendable-error.ts

@@ -1,35 +0,0 @@
-class ExtendableError extends Error {
-  public name: string;
-  public message: string;
-  public errors: any;
-  public status: number;
-  public isPublic: boolean;
-  public isOperational: boolean;
-  public stack?: string;
-
-  constructor({
-    message,
-    errors,
-    status,
-    isPublic,
-    stack,
-  }: {
-    message: string;
-    errors?: any;
-    status?: number;
-    isPublic?: boolean;
-    stack?: string;
-  }) {
-    super(message);
-    this.name = this.constructor.name;
-    this.message = message;
-    this.errors = errors;
-    this.status = status || 500; // Default value if status is not provided
-    this.isPublic = isPublic || false; // Default value if isPublic is not provided
-    this.isOperational = true; // This is required since bluebird 4 doesn't append it anymore.
-    this.stack = stack;
-    // Error.captureStackTrace(this, this.constructor.name);
-  }
-}
-
-export default ExtendableError;

package/errors/standard-error.ts

@@ -1,29 +0,0 @@
-export class StandardError extends Error {
-  public code: string;
-  public lastError?: object | null;
-  public context?: string | null;
-
-  constructor(
-    errorCode: string,
-    message: string,
-    lastError?: any,
-    context?: object | string | null,
-  ) {
-    super(message);
-
-    // So you can do typeof CustomError
-    Object.setPrototypeOf(this, new.target.prototype);
-
-    this.name = this.constructor.name;
-    this.code = errorCode;
-    this.lastError = lastError;
-    this.context = JSON.stringify(context, null, 2);
-  }
-
-  public toJSON() {
-    return {
-      code: this.code,
-      message: this.message,
-    };
-  }
-}

package/helpers/dependencies.ts

@@ -1,10 +0,0 @@
-import { nanoid } from 'nanoid';
-import { publishErrorEvent, publishEvent } from './event';
-
-export const getDependencies = () => {
-  return {
-    nanoid,
-    publishEvent,
-    publishErrorEvent,
-  };
-};