@nest-yalc-2/api-strategy 1.3.3

package/src/strategies/nest-local-call.strategy.ts

@@ -0,0 +1,153 @@
+import { HttpAdapterHost } from '@nestjs/core';
+import {
+  HttpAbstractStrategy,
+  HttpOptions,
+  IHttpCallStrategyOptions,
+  IHttpCallStrategyResponse,
+} from './http-abstract-call.strategy.js';
+import { FastifyAdapter } from '@nestjs/platform-fastify';
+import { ClassType } from '@nest-yalc-2/types/globals.d.js';
+import { InjectOptions } from 'fastify';
+import { YalcGlobalClsService } from '@nest-yalc-2/app/cls.module.js';
+import { filterHeaders } from '../header-whitelist.helper.js';
+import { AppConfigService } from '@nest-yalc-2/app/app-config.service.js';
+import { MAIN_APP_CONFIG_SERVICE } from '@nest-yalc-2/app/def.const.js';
+
+export type NestLocalCallStrategyOptions = IHttpCallStrategyOptions & {
+  internalRequestHeader?: string;
+  internalRequestToken?: string;
+};
+
+export class NestLocalCallStrategy extends HttpAbstractStrategy {
+  private readonly internalHeader: string;
+  private readonly internalToken?: string;
+
+  constructor(
+    protected readonly adapterHost: HttpAdapterHost,
+    protected readonly clsService: YalcGlobalClsService,
+    protected readonly configService: AppConfigService,
+    private baseUrl = '',
+    protected readonly options: NestLocalCallStrategyOptions = {},
+  ) {
+    super();
+    this.internalHeader =
+      options.internalRequestHeader ?? 'x-internal-request-token';
+    this.internalToken =
+      options.internalRequestToken ??
+      (configService as any)?.values?.internalRequestToken;
+  }
+
+  async call<
+    TOptData extends string | object | Buffer | NodeJS.ReadableStream,
+    TParams extends Record<string, any>,
+    TResData,
+  >(
+    path: string,
+    options?: HttpOptions<TOptData, TParams>,
+  ): Promise<IHttpCallStrategyResponse<TResData>> {
+    const instance: FastifyAdapter = this.adapterHost.httpAdapter.getInstance();
+    const clsHeaders = filterHeaders(
+      this.clsService.get('headers'),
+      this.options.headersWhitelist,
+    );
+    const headers: Record<string, any> = {
+      ...clsHeaders,
+      ...(options?.headers ?? {}),
+    };
+    if (
+      this.internalHeader &&
+      this.internalToken &&
+      !headers[this.internalHeader]
+    ) {
+      headers[this.internalHeader] = this.internalToken;
+    }
+    /**
+     * We need this to do a type check on the options and
+     * implement the mapping from HttpOptions to InjectOptions;
+     */
+    const _options:
+      | {
+          [k: string | number | symbol]: never;
+        }
+      | InjectOptions = {
+      headers,
+      method: options?.method,
+      /**@todo investigate where to set thi */
+      // signal: options?.signal,
+      payload: options?.data, // map data to payload
+    };
+
+    const args: InjectOptions = {
+      ..._options,
+      url: `${this.baseUrl}${path}`,
+    };
+
+    if (options?.parameters) {
+      args.query = Object.fromEntries(new URLSearchParams(options.parameters));
+    }
+
+    const result = await instance.inject(args);
+
+    let data;
+    try {
+      if (
+        this.options.shouldSkipJsonParse &&
+        this.options.shouldSkipJsonParse(result.body)
+      ) {
+        data = result.body;
+      } else {
+        data = result.json();
+      }
+    } catch (_e) {
+      //The content-type of the response is not application/json
+      // if so, we use the body instead
+      data = result.body;
+    }
+
+    return {
+      data,
+      headers: result.headers,
+      status: result.statusCode,
+      statusText: result.statusMessage,
+      request: result.payload, // TODO: double check if it's the correct value
+    };
+  }
+}
+
+export interface NestLocalCallStrategyProviderOptions {
+  baseUrl?: string;
+  NestLocalStrategy?: ClassType<NestLocalCallStrategy>;
+  headersWhitelist?: string[];
+  internalRequestHeader?: string;
+  internalRequestToken?: string;
+}
+
+/**
+ * Just a convenient provider to inject the NestLocalCallStrategy
+ */
+export const NestLocalCallStrategyProvider = (
+  provide: string,
+  options: NestLocalCallStrategyProviderOptions = {},
+) => ({
+  provide,
+  useFactory: (
+    httpAdapter: HttpAdapterHost,
+    clsService: YalcGlobalClsService,
+    configService: AppConfigService,
+  ) => {
+    const _options = {
+      baseUrl: '',
+      NestLocalStrategy: NestLocalCallStrategy,
+      ...options,
+    };
+
+    return new _options.NestLocalStrategy(
+      httpAdapter,
+      clsService,
+      configService,
+      _options.baseUrl,
+      _options,
+    );
+  },
+  inject: [HttpAdapterHost, YalcGlobalClsService, MAIN_APP_CONFIG_SERVICE],
+});

package/src/strategies/nest-local-event.strategy.d.ts

@@ -0,0 +1,17 @@
+import { IEventStrategy } from '../context-event.interface.js';
+import { EventEmitter2 } from '@nestjs/event-emitter';
+import { ClassType } from '@nest-yalc-2/types/globals.d.js';
+export declare class NestLocalEventStrategy<P = any, O = any> implements IEventStrategy {
+    private eventEmitter;
+    constructor(eventEmitter: EventEmitter2);
+    emit(path: string, payload: P, options?: O): boolean;
+    emitAsync(path: string, payload: P, options?: O): Promise<any>;
+}
+export interface NestLocalEventStrategyProviderOptions {
+    NestLocalStrategy?: ClassType<NestLocalEventStrategy>;
+}
+export declare const NestLocalEventStrategyProvider: (provide: string, options?: NestLocalEventStrategyProviderOptions) => {
+    provide: string;
+    useFactory: (eventEmitter: EventEmitter2) => NestLocalEventStrategy<any, any>;
+    inject: (typeof EventEmitter2)[];
+};

package/src/strategies/nest-local-event.strategy.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NestLocalEventStrategyProvider = exports.NestLocalEventStrategy = void 0;
+const event_emitter_1 = require("@nestjs/event-emitter");
+class NestLocalEventStrategy {
+    constructor(eventEmitter) {
+        this.eventEmitter = eventEmitter;
+    }
+    emit(path, payload, options) {
+        return this.eventEmitter.emit(path, payload, options);
+    }
+    emitAsync(path, payload, options) {
+        return this.eventEmitter.emitAsync(path, payload, options);
+    }
+}
+exports.NestLocalEventStrategy = NestLocalEventStrategy;
+const NestLocalEventStrategyProvider = (provide, options = {}) => ({
+    provide,
+    useFactory: (eventEmitter) => {
+        const _options = {
+            baseUrl: '',
+            NestLocalStrategy: NestLocalEventStrategy,
+            ...options,
+        };
+        return new _options.NestLocalStrategy(eventEmitter);
+    },
+    inject: [event_emitter_1.EventEmitter2],
+});
+exports.NestLocalEventStrategyProvider = NestLocalEventStrategyProvider;
+//# sourceMappingURL=nest-local-event.strategy.js.map

package/src/strategies/nest-local-event.strategy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"nest-local-event.strategy.js","sourceRoot":"","sources":["nest-local-event.strategy.ts"],"names":[],"mappings":";;;AACA,yDAAsD;AAGtD,MAAa,sBAAsB;IAIjC,YAAoB,YAA2B;QAA3B,iBAAY,GAAZ,YAAY,CAAe;IAAG,CAAC;IAEnD,IAAI,CAAC,IAAY,EAAE,OAAU,EAAE,OAAW;QACxC,OAAO,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC;IACxD,CAAC;IAED,SAAS,CAAC,IAAY,EAAE,OAAU,EAAE,OAAW;QAC7C,OAAO,IAAI,CAAC,YAAY,CAAC,SAAS,CAAC,IAAI,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC;IAC7D,CAAC;CACF;AAbD,wDAaC;AASM,MAAM,8BAA8B,GAAG,CAC5C,OAAe,EACf,UAAiD,EAAE,EACnD,EAAE,CAAC,CAAC;IACJ,OAAO;IACP,UAAU,EAAE,CAAC,YAA2B,EAAE,EAAE;QAC1C,MAAM,QAAQ,GAAG;YACf,OAAO,EAAE,EAAE;YACX,iBAAiB,EAAE,sBAAsB;YACzC,GAAG,OAAO;SACX,CAAC;QAEF,OAAO,IAAI,QAAQ,CAAC,iBAAiB,CAAC,YAAY,CAAC,CAAC;IACtD,CAAC;IACD,MAAM,EAAE,CAAC,6BAAa,CAAC;CACxB,CAAC,CAAC;AAfU,QAAA,8BAA8B,kCAexC"}

package/src/strategies/nest-local-event.strategy.ts

@@ -0,0 +1,42 @@
+import { IEventStrategy } from '../context-event.interface.js';
+import { EventEmitter2 } from '@nestjs/event-emitter';
+import { ClassType } from '@nest-yalc-2/types/globals.d.js';
+
+export class NestLocalEventStrategy<
+  P = any,
+  O = any,
+> implements IEventStrategy {
+  constructor(private eventEmitter: EventEmitter2) {}
+
+  emit(path: string, payload: P, options?: O): boolean {
+    return this.eventEmitter.emit(path, payload, options);
+  }
+
+  emitAsync(path: string, payload: P, options?: O): Promise<any> {
+    return this.eventEmitter.emitAsync(path, payload, options);
+  }
+}
+
+export interface NestLocalEventStrategyProviderOptions {
+  NestLocalStrategy?: ClassType<NestLocalEventStrategy>;
+}
+
+/**
+ * Just a convenient provider to inject the NestLocalCallStrategy
+ */
+export const NestLocalEventStrategyProvider = (
+  provide: string,
+  options: NestLocalEventStrategyProviderOptions = {},
+) => ({
+  provide,
+  useFactory: (eventEmitter: EventEmitter2) => {
+    const _options = {
+      baseUrl: '',
+      NestLocalStrategy: NestLocalEventStrategy,
+      ...options,
+    };
+
+    return new _options.NestLocalStrategy(eventEmitter);
+  },
+  inject: [EventEmitter2],
+});

package/src/strategies/rabbitmq-event.strategy.d.ts

@@ -0,0 +1,34 @@
+import { OnModuleDestroy } from '@nestjs/common';
+import type { ClassType } from '@nest-yalc-2/types/globals.d.js';
+import { Options } from 'amqplib';
+import { IEventStrategy } from '../context-event.interface.js';
+export interface RabbitMqEventStrategyOptions<P = any> {
+    url: string;
+    exchange: string;
+    exchangeType?: string;
+    durable?: boolean;
+    persistent?: boolean;
+    contentType?: string;
+    publishOptions?: Options.Publish;
+    serialize?: (payload: P) => Buffer | string;
+}
+export declare class RabbitMqEventStrategy<P = any, O = any> implements IEventStrategy<P, boolean, O>, OnModuleDestroy {
+    private readonly options;
+    private connection?;
+    private channel?;
+    constructor(options: RabbitMqEventStrategyOptions<P>);
+    emit(path: string, payload: P): boolean;
+    emitAsync(path: string, payload: P): Promise<boolean>;
+    onModuleDestroy(): Promise<void>;
+    private publish;
+    private serialize;
+    private getChannel;
+}
+export interface RabbitMqEventStrategyProviderOptions<P = any> {
+    RabbitMqStrategy?: ClassType<RabbitMqEventStrategy<P>>;
+    options: RabbitMqEventStrategyOptions<P> | (() => RabbitMqEventStrategyOptions<P>);
+}
+export declare const RabbitMqEventStrategyProvider: <P = any>(provide: string, options: RabbitMqEventStrategyProviderOptions<P>) => {
+    provide: string;
+    useFactory: () => RabbitMqEventStrategy<P, any> | RabbitMqEventStrategy<any, any>;
+};

package/src/strategies/rabbitmq-event.strategy.js

@@ -0,0 +1,97 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RabbitMqEventStrategyProvider = exports.RabbitMqEventStrategy = void 0;
+const amqplib_1 = __importDefault(require("amqplib"));
+class RabbitMqEventStrategy {
+    constructor(options) {
+        this.options = options;
+    }
+    emit(path, payload) {
+        void this.publish(path, payload).catch(() => undefined);
+        return true;
+    }
+    async emitAsync(path, payload) {
+        return this.publish(path, payload);
+    }
+    async onModuleDestroy() {
+        await closeRabbitResource(this.channel);
+        await closeRabbitResource(this.connection);
+        this.channel = undefined;
+        this.connection = undefined;
+    }
+    async publish(path, payload) {
+        const channel = await this.getChannel();
+        const body = this.serialize(payload);
+        return channel.publish(this.options.exchange, path, body, {
+            contentType: this.options.contentType ?? 'application/json',
+            persistent: this.options.persistent ?? true,
+            ...this.options.publishOptions,
+        });
+    }
+    serialize(payload) {
+        const serialized = this.options.serialize?.(payload);
+        if (Buffer.isBuffer(serialized)) {
+            return serialized;
+        }
+        return Buffer.from(serialized ?? JSON.stringify(payload));
+    }
+    async getChannel() {
+        if (this.channel) {
+            return this.channel;
+        }
+        this.connection = await amqplib_1.default.connect(this.options.url);
+        this.channel = await this.connection.createChannel();
+        await this.channel.assertExchange(this.options.exchange, this.options.exchangeType ?? 'topic', {
+            durable: this.options.durable ?? true,
+        });
+        return this.channel;
+    }
+}
+exports.RabbitMqEventStrategy = RabbitMqEventStrategy;
+const RabbitMqEventStrategyProvider = (provide, options) => ({
+    provide,
+    useFactory: () => {
+        const Strategy = options.RabbitMqStrategy ?? RabbitMqEventStrategy;
+        const strategyOptions = typeof options.options === 'function'
+            ? options.options()
+            : options.options;
+        return new Strategy(strategyOptions);
+    },
+});
+exports.RabbitMqEventStrategyProvider = RabbitMqEventStrategyProvider;
+async function closeRabbitResource(resource) {
+    if (!resource) {
+        return;
+    }
+    let timeout;
+    try {
+        await Promise.race([
+            resource.close(),
+            new Promise((resolve) => {
+                timeout = setTimeout(resolve, 1000);
+            }),
+        ]);
+    }
+    catch (error) {
+        if (!(error instanceof Error) || !error.message.includes('closing')) {
+            throw error;
+        }
+    }
+    finally {
+        if (timeout) {
+            clearTimeout(timeout);
+        }
+        forceCloseRabbitResource(resource);
+    }
+}
+function forceCloseRabbitResource(resource) {
+    const connection = resource.connection;
+    connection?.heartbeater?.clear();
+    resource.heartbeater?.clear();
+    connection?.stream?.destroy();
+    resource.stream?.destroy();
+}
+//# sourceMappingURL=rabbitmq-event.strategy.js.map

package/src/strategies/rabbitmq-event.strategy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rabbitmq-event.strategy.js","sourceRoot":"","sources":["rabbitmq-event.strategy.ts"],"names":[],"mappings":"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"}

package/src/strategies/rabbitmq-event.strategy.ts

@@ -0,0 +1,154 @@
+import { OnModuleDestroy } from '@nestjs/common';
+import type { ClassType } from '@nest-yalc-2/types/globals.d.js';
+import amqp, { Channel, ChannelModel, Options } from 'amqplib';
+import { IEventStrategy } from '../context-event.interface.js';
+
+interface RabbitConnectionResource {
+  stream?: { destroy: () => void };
+  heartbeater?: { clear: () => void };
+}
+
+export interface RabbitMqEventStrategyOptions<P = any> {
+  url: string;
+  exchange: string;
+  exchangeType?: string;
+  durable?: boolean;
+  persistent?: boolean;
+  contentType?: string;
+  publishOptions?: Options.Publish;
+  serialize?: (payload: P) => Buffer | string;
+}
+
+export class RabbitMqEventStrategy<P = any, O = any>
+  implements IEventStrategy<P, boolean, O>, OnModuleDestroy
+{
+  private connection?: ChannelModel;
+  private channel?: Channel;
+
+  constructor(private readonly options: RabbitMqEventStrategyOptions<P>) {}
+
+  emit(path: string, payload: P): boolean {
+    void this.publish(path, payload).catch(() => undefined);
+    return true;
+  }
+
+  async emitAsync(path: string, payload: P): Promise<boolean> {
+    return this.publish(path, payload);
+  }
+
+  async onModuleDestroy() {
+    await closeRabbitResource(this.channel);
+    await closeRabbitResource(this.connection);
+    this.channel = undefined;
+    this.connection = undefined;
+  }
+
+  private async publish(path: string, payload: P) {
+    const channel = await this.getChannel();
+    const body = this.serialize(payload);
+
+    return channel.publish(this.options.exchange, path, body, {
+      contentType: this.options.contentType ?? 'application/json',
+      persistent: this.options.persistent ?? true,
+      ...this.options.publishOptions,
+    });
+  }
+
+  private serialize(payload: P) {
+    const serialized = this.options.serialize?.(payload);
+
+    if (Buffer.isBuffer(serialized)) {
+      return serialized;
+    }
+
+    return Buffer.from(serialized ?? JSON.stringify(payload));
+  }
+
+  private async getChannel() {
+    if (this.channel) {
+      return this.channel;
+    }
+
+    this.connection = await amqp.connect(this.options.url);
+    this.channel = await this.connection.createChannel();
+    await this.channel.assertExchange(
+      this.options.exchange,
+      this.options.exchangeType ?? 'topic',
+      {
+        durable: this.options.durable ?? true,
+      },
+    );
+
+    return this.channel;
+  }
+}
+
+export interface RabbitMqEventStrategyProviderOptions<P = any> {
+  RabbitMqStrategy?: ClassType<RabbitMqEventStrategy<P>>;
+  options:
+    | RabbitMqEventStrategyOptions<P>
+    | (() => RabbitMqEventStrategyOptions<P>);
+}
+
+export const RabbitMqEventStrategyProvider = <P = any>(
+  provide: string,
+  options: RabbitMqEventStrategyProviderOptions<P>,
+) => ({
+  provide,
+  useFactory: () => {
+    const Strategy = options.RabbitMqStrategy ?? RabbitMqEventStrategy;
+    const strategyOptions =
+      typeof options.options === 'function'
+        ? options.options()
+        : options.options;
+
+    return new Strategy(strategyOptions);
+  },
+});
+
+async function closeRabbitResource(resource?: {
+  close: () => Promise<void>;
+  connection?: unknown;
+  stream?: { destroy: () => void };
+  heartbeater?: { clear: () => void };
+}) {
+  if (!resource) {
+    return;
+  }
+
+  let timeout: NodeJS.Timeout | undefined;
+
+  try {
+    await Promise.race([
+      resource.close(),
+      new Promise((resolve) => {
+        timeout = setTimeout(resolve, 1000);
+      }),
+    ]);
+  } catch (error) {
+    if (!(error instanceof Error) || !error.message.includes('closing')) {
+      throw error;
+    }
+  } finally {
+    if (timeout) {
+      clearTimeout(timeout);
+    }
+
+    forceCloseRabbitResource(resource);
+  }
+}
+
+function forceCloseRabbitResource(resource: {
+  connection?: unknown;
+  stream?: { destroy: () => void };
+  heartbeater?: { clear: () => void };
+}) {
+  const connection = resource.connection as
+    | RabbitConnectionResource
+    | undefined;
+
+  connection?.heartbeater?.clear();
+  resource.heartbeater?.clear();
+  connection?.stream?.destroy();
+  resource.stream?.destroy();
+}

package/src/strategies/shadow-call.strategy.d.ts

@@ -0,0 +1,17 @@
+import { IApiCallStrategy, ICallOptions, IObjectWithData } from '../context-call.interface.js';
+export type ShadowCallStrategyErrorMode = 'throw' | 'ignore';
+export interface ShadowCallStrategyOptions {
+    awaitShadows?: boolean;
+    shadowErrorMode?: ShadowCallStrategyErrorMode;
+}
+export declare class ShadowCallStrategy implements IApiCallStrategy {
+    private readonly primary;
+    private readonly shadows;
+    private readonly awaitShadows;
+    private readonly shadowErrorMode;
+    constructor(primary: IApiCallStrategy, shadows: IApiCallStrategy[], options?: ShadowCallStrategyOptions);
+    call<TOptData, TParams extends Record<string, any>, TResData>(path: string, options?: ICallOptions<TOptData, TParams>): Promise<IObjectWithData<TResData>>;
+    get<TOptData, TParams extends Record<string, any>, TResData>(path: string, options?: ICallOptions<TOptData, TParams>): Promise<IObjectWithData<TResData>>;
+    post<TOptData, TParams extends Record<string, any>, TResData>(path: string, options?: ICallOptions<TOptData, TParams>): Promise<IObjectWithData<TResData>>;
+    private execute;
+}

package/src/strategies/shadow-call.strategy.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ShadowCallStrategy = void 0;
+class ShadowCallStrategy {
+    constructor(primary, shadows, options = {}) {
+        this.primary = primary;
+        this.shadows = shadows;
+        if (shadows.length === 0) {
+            throw new Error('ShadowCallStrategy requires at least one shadow strategy.');
+        }
+        this.shadowErrorMode = options.shadowErrorMode ?? 'ignore';
+        this.awaitShadows =
+            options.awaitShadows ?? this.shadowErrorMode === 'throw';
+    }
+    call(path, options) {
+        return this.execute((strategy) => strategy.call(path, options), (strategy) => strategy.call(path, options));
+    }
+    get(path, options) {
+        return this.execute((strategy) => strategy.get(path, options), (strategy) => strategy.get(path, options));
+    }
+    post(path, options) {
+        return this.execute((strategy) => strategy.post(path, options), (strategy) => strategy.post(path, options));
+    }
+    async execute(primaryCall, shadowCall) {
+        const primaryResult = await primaryCall(this.primary);
+        const shadowExecution = Promise.all(this.shadows.map((strategy) => shadowCall(strategy)));
+        if (this.awaitShadows) {
+            if (this.shadowErrorMode === 'throw') {
+                await shadowExecution;
+            }
+            else {
+                await shadowExecution.catch(() => undefined);
+            }
+        }
+        else {
+            void shadowExecution.catch(() => undefined);
+        }
+        return primaryResult;
+    }
+}
+exports.ShadowCallStrategy = ShadowCallStrategy;
+//# sourceMappingURL=shadow-call.strategy.js.map

package/src/strategies/shadow-call.strategy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shadow-call.strategy.js","sourceRoot":"","sources":["shadow-call.strategy.ts"],"names":[],"mappings":";;;AAaA,MAAa,kBAAkB;IAI7B,YACmB,OAAyB,EACzB,OAA2B,EAC5C,UAAqC,EAAE;QAFtB,YAAO,GAAP,OAAO,CAAkB;QACzB,YAAO,GAAP,OAAO,CAAoB;QAG5C,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACzB,MAAM,IAAI,KAAK,CACb,2DAA2D,CAC5D,CAAC;QACJ,CAAC;QAED,IAAI,CAAC,eAAe,GAAG,OAAO,CAAC,eAAe,IAAI,QAAQ,CAAC;QAC3D,IAAI,CAAC,YAAY;YACf,OAAO,CAAC,YAAY,IAAI,IAAI,CAAC,eAAe,KAAK,OAAO,CAAC;IAC7D,CAAC;IAED,IAAI,CACF,IAAY,EACZ,OAAyC;QAEzC,OAAO,IAAI,CAAC,OAAO,CACjB,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,EAAE,OAAO,CAAC,EAC1C,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,EAAE,OAAO,CAAC,CAC3C,CAAC;IACJ,CAAC;IAED,GAAG,CACD,IAAY,EACZ,OAAyC;QAEzC,OAAO,IAAI,CAAC,OAAO,CACjB,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,EAAE,OAAO,CAAC,EACzC,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,EAAE,OAAO,CAAC,CAC1C,CAAC;IACJ,CAAC;IAED,IAAI,CACF,IAAY,EACZ,OAAyC;QAEzC,OAAO,IAAI,CAAC,OAAO,CACjB,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,EAAE,OAAO,CAAC,EAC1C,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,EAAE,OAAO,CAAC,CAC3C,CAAC;IACJ,CAAC;IAEO,KAAK,CAAC,OAAO,CACnB,WAEuC,EACvC,UAAyE;QAEzE,MAAM,aAAa,GAAG,MAAM,WAAW,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QACtD,MAAM,eAAe,GAAG,OAAO,CAAC,GAAG,CACjC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,CACrD,CAAC;QAEF,IAAI,IAAI,CAAC,YAAY,EAAE,CAAC;YACtB,IAAI,IAAI,CAAC,eAAe,KAAK,OAAO,EAAE,CAAC;gBACrC,MAAM,eAAe,CAAC;YACxB,CAAC;iBAAM,CAAC;gBACN,MAAM,eAAe,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC,CAAC;YAC/C,CAAC;QACH,CAAC;aAAM,CAAC;YACN,KAAK,eAAe,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC,CAAC;QAC9C,CAAC;QAED,OAAO,aAAa,CAAC;IACvB,CAAC;CACF;AAzED,gDAyEC"}