@monorise/core 1.0.0

package/data/ProjectionExpression.ts

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,470 @@
+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

@@ -0,0 +1,19 @@
+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

@@ -0,0 +1,92 @@
+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/dist/configs/service.config.d.ts

@@ -0,0 +1,5 @@
+import { ENTITY_REPLICATION_INDEX, MUTUAL_REPLICATION_INDEX } from '../constants/table';
+declare const CORE_TABLE: string;
+declare const CORE_EVENT_BUS: string;
+export { CORE_TABLE, CORE_EVENT_BUS, ENTITY_REPLICATION_INDEX, MUTUAL_REPLICATION_INDEX, };
+//# sourceMappingURL=service.config.d.ts.map

package/dist/configs/service.config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.config.d.ts","sourceRoot":"","sources":["../../configs/service.config.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,wBAAwB,EACxB,wBAAwB,EACzB,MAAM,oBAAoB,CAAC;AAE5B,QAAA,MAAM,UAAU,QAA+B,CAAC;AAChD,QAAA,MAAM,cAAc,QAAmC,CAAC;AAExD,OAAO,EACL,UAAU,EACV,cAAc,EACd,wBAAwB,EACxB,wBAAwB,GACzB,CAAC"}

package/dist/configs/service.config.js

@@ -0,0 +1,5 @@
+import { ENTITY_REPLICATION_INDEX, MUTUAL_REPLICATION_INDEX, } from '../constants/table';
+const CORE_TABLE = process.env.CORE_TABLE || '';
+const CORE_EVENT_BUS = process.env.CORE_EVENT_BUS || '';
+export { CORE_TABLE, CORE_EVENT_BUS, ENTITY_REPLICATION_INDEX, MUTUAL_REPLICATION_INDEX, };
+//# sourceMappingURL=service.config.js.map

package/dist/configs/service.config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.config.js","sourceRoot":"","sources":["../../configs/service.config.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,wBAAwB,EACxB,wBAAwB,GACzB,MAAM,oBAAoB,CAAC;AAE5B,MAAM,UAAU,GAAG,OAAO,CAAC,GAAG,CAAC,UAAU,IAAI,EAAE,CAAC;AAChD,MAAM,cAAc,GAAG,OAAO,CAAC,GAAG,CAAC,cAAc,IAAI,EAAE,CAAC;AAExD,OAAO,EACL,UAAU,EACV,cAAc,EACd,wBAAwB,EACxB,wBAAwB,GACzB,CAAC"}

package/dist/constants/table.d.ts

@@ -0,0 +1,4 @@
+export declare const REPLICATION_INDEX = "REPLICATION_INDEX";
+export declare const ENTITY_REPLICATION_INDEX = "ENTITY_REPLICATION_INDEX";
+export declare const MUTUAL_REPLICATION_INDEX = "MUTUAL_REPLICATION_INDEX";
+//# sourceMappingURL=table.d.ts.map

package/dist/constants/table.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"table.d.ts","sourceRoot":"","sources":["../../constants/table.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,iBAAiB,sBAAsB,CAAC;AACrD,eAAO,MAAM,wBAAwB,6BAA6B,CAAC;AACnE,eAAO,MAAM,wBAAwB,6BAA6B,CAAC"}

package/dist/constants/table.js

@@ -0,0 +1,4 @@
+export const REPLICATION_INDEX = 'REPLICATION_INDEX';
+export const ENTITY_REPLICATION_INDEX = 'ENTITY_REPLICATION_INDEX';
+export const MUTUAL_REPLICATION_INDEX = 'MUTUAL_REPLICATION_INDEX';
+//# sourceMappingURL=table.js.map

package/dist/constants/table.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"table.js","sourceRoot":"","sources":["../../constants/table.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,iBAAiB,GAAG,mBAAmB,CAAC;AACrD,MAAM,CAAC,MAAM,wBAAwB,GAAG,0BAA0B,CAAC;AACnE,MAAM,CAAC,MAAM,wBAAwB,GAAG,0BAA0B,CAAC"}

package/dist/controllers/entity/create-entity.controller.d.ts

@@ -0,0 +1,8 @@
+import type { Request, Response } from 'express';
+import type { EntityService } from '#/services/entity.service';
+export declare class CreateEntityController {
+    private entityService;
+    constructor(entityService: EntityService);
+    controller: (req: Request, res: Response) => void;
+}
+//# sourceMappingURL=create-entity.controller.d.ts.map

package/dist/controllers/entity/create-entity.controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-entity.controller.d.ts","sourceRoot":"","sources":["../../../controllers/entity/create-entity.controller.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAIjD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAE/D,qBAAa,sBAAsB;IACrB,OAAO,CAAC,aAAa;gBAAb,aAAa,EAAE,aAAa;IAEhD,UAAU,EAAE,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,KAAK,IAAI,CAuC/C;CACH"}

package/dist/controllers/entity/create-entity.controller.js

@@ -0,0 +1,44 @@
+import httpStatus from 'http-status';
+import { ZodError } from 'zod';
+import { StandardError } from '#/errors/standard-error';
+export class CreateEntityController {
+    entityService;
+    constructor(entityService) {
+        this.entityService = entityService;
+    }
+    controller = async (req, res) => {
+        const accountId = req.headers['account-id'];
+        const { entityType } = req.params;
+        try {
+            const entity = await this.entityService.createEntity({
+                entityType,
+                entityPayload: req.body,
+                accountId,
+                options: {
+                    createAndUpdateDatetime: req.body.createdAt,
+                },
+            });
+            return res.status(httpStatus.OK).json(entity);
+        }
+        catch (err) {
+            if (err instanceof ZodError) {
+                return res.status(httpStatus.BAD_REQUEST).json({
+                    code: 'API_VALIDATION_ERROR',
+                    message: 'API validation failed',
+                    details: err.flatten(),
+                });
+            }
+            if (err instanceof StandardError && err.code === 'EMAIL_EXISTS') {
+                return res.status(httpStatus.BAD_REQUEST).json({
+                    ...err.toJSON(),
+                });
+            }
+            console.log('===create-entity error:', {
+                err,
+                errorContext: JSON.stringify({ body: req.body, headers: req.headers }),
+            });
+            throw err;
+        }
+    };
+}
+//# sourceMappingURL=create-entity.controller.js.map

package/dist/controllers/entity/create-entity.controller.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-entity.controller.js","sourceRoot":"","sources":["../../../controllers/entity/create-entity.controller.ts"],"names":[],"mappings":"AAEA,OAAO,UAAU,MAAM,aAAa,CAAC;AACrC,OAAO,EAAE,QAAQ,EAAE,MAAM,KAAK,CAAC;AAC/B,OAAO,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAGxD,MAAM,OAAO,sBAAsB;IACb;IAApB,YAAoB,aAA4B;QAA5B,kBAAa,GAAb,aAAa,CAAe;IAAG,CAAC;IAEpD,UAAU,GAA0C,KAAK,EAAE,GAAG,EAAE,GAAG,EAAE,EAAE;QACrE,MAAM,SAAS,GAAG,GAAG,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC;QAC5C,MAAM,EAAE,UAAU,EAAE,GAAG,GAAG,CAAC,MAE1B,CAAC;QAEF,IAAI,CAAC;YACH,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,aAAa,CAAC,YAAY,CAAC;gBACnD,UAAU;gBACV,aAAa,EAAE,GAAG,CAAC,IAAI;gBACvB,SAAS;gBACT,OAAO,EAAE;oBACP,uBAAuB,EAAE,GAAG,CAAC,IAAI,CAAC,SAAS;iBAC5C;aACF,CAAC,CAAC;YAEH,OAAO,GAAG,CAAC,MAAM,CAAC,UAAU,CAAC,EAAE,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QAChD,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,IAAI,GAAG,YAAY,QAAQ,EAAE,CAAC;gBAC5B,OAAO,GAAG,CAAC,MAAM,CAAC,UAAU,CAAC,WAAW,CAAC,CAAC,IAAI,CAAC;oBAC7C,IAAI,EAAE,sBAAsB;oBAC5B,OAAO,EAAE,uBAAuB;oBAChC,OAAO,EAAE,GAAG,CAAC,OAAO,EAAE;iBACvB,CAAC,CAAC;YACL,CAAC;YAED,IAAI,GAAG,YAAY,aAAa,IAAI,GAAG,CAAC,IAAI,KAAK,cAAc,EAAE,CAAC;gBAChE,OAAO,GAAG,CAAC,MAAM,CAAC,UAAU,CAAC,WAAW,CAAC,CAAC,IAAI,CAAC;oBAC7C,GAAG,GAAG,CAAC,MAAM,EAAE;iBAChB,CAAC,CAAC;YACL,CAAC;YAED,OAAO,CAAC,GAAG,CAAC,yBAAyB,EAAE;gBACrC,GAAG;gBACH,YAAY,EAAE,IAAI,CAAC,SAAS,CAAC,EAAE,IAAI,EAAE,GAAG,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,CAAC,OAAO,EAAE,CAAC;aACvE,CAAC,CAAC;YAEH,MAAM,GAAG,CAAC;QACZ,CAAC;IACH,CAAC,CAAC;CACH"}