@unchainedshop/core-worker 3.0.0-alpha2 → 3.0.0-alpha3

package/src/module/configureWorkerModule.ts

@@ -1,26 +1,122 @@
+import type { WorkData, WorkResult } from '../worker-index.js';
+import type { ModuleInput, UnchainedCore } from '@unchainedshop/core';
+
 import os from 'os';
-import { ModuleInput, ModuleMutations } from '@unchainedshop/types/core.js';
-import { Work, WorkerModule, WorkerSettingsOptions } from '@unchainedshop/types/worker.js';
 import { createLogger } from '@unchainedshop/logger';
 import {
   generateDbFilterById,
-  generateDbMutations,
   buildSortOptions,
   mongodb,
+  generateDbObjectId,
 } from '@unchainedshop/mongodb';
-import { SortDirection } from '@unchainedshop/types/api.js';
 import { emit, registerEvents } from '@unchainedshop/events';
-import { buildObfuscatedFieldsFilter } from '@unchainedshop/utils';
+import { buildObfuscatedFieldsFilter, SortDirection, SortOption } from '@unchainedshop/utils';
 import { WorkQueueCollection } from '../db/WorkQueueCollection.js';
-import { WorkQueueSchema } from '../db/WorkQueueSchema.js';
 import { DIRECTOR_MARKED_FAILED_ERROR, WorkerDirector } from '../director/WorkerDirector.js';
 import { WorkerEventTypes } from '../director/WorkerEventTypes.js';
 import { WorkStatus } from '../director/WorkStatus.js';
+import { Work } from '../types.js';
+import addMigrations from './migrations/addMigrations.js';
 
 const { UNCHAINED_WORKER_ID = os.hostname() } = process.env;
 
 const logger = createLogger('unchained:core-worker');
 
+export interface WorkerSettingsOptions {
+  blacklistedVariables?: string[];
+}
+
+export type WorkerReport = {
+  type: string;
+  newCount: number;
+  errorCount: number;
+  successCount: number;
+  startCount: number;
+  deleteCount: number;
+};
+
+export type WorkQueueQuery = {
+  created?: { end?: Date; start?: Date };
+  types?: Array<string>;
+  status: Array<WorkStatus>;
+  queryString?: string;
+  scheduled?: { end?: Date; start?: Date };
+};
+
+export type WorkerModule = {
+  activeWorkTypes: () => Promise<Array<string>>;
+  findWork: (query: { workId?: string; originalWorkId?: string }) => Promise<Work>;
+  findWorkQueue: (
+    query: WorkQueueQuery & {
+      sort?: Array<SortOption>;
+      limit?: number;
+      skip?: number;
+    },
+  ) => Promise<Array<Work>>;
+  count: (query: WorkQueueQuery) => Promise<number>;
+  workExists: (query: { workId?: string; originalWorkId?: string }) => Promise<boolean>;
+
+  // Transformations
+  status: (work: Work) => WorkStatus;
+
+  type: (work: Work) => string;
+
+  // Mutations
+  addWork: (data: WorkData) => Promise<Work>;
+
+  allocateWork: (doc: { types: Array<string>; worker: string }) => Promise<Work>;
+
+  processNextWork: (unchainedAPI: UnchainedCore, workerId?: string) => Promise<Work>;
+
+  rescheduleWork: (work: Work, scheduled: Date, unchainedAPI: UnchainedCore) => Promise<Work>;
+
+  ensureOneWork: (work: WorkData) => Promise<Work>;
+
+  ensureNoWork: (work: { priority: number; type: string; scheduleId: string }) => Promise<void>;
+
+  finishWork: (
+    _id: string,
+    data: WorkResult<any> & {
+      finished?: Date;
+      started?: Date;
+      worker?: string;
+    },
+  ) => Promise<Work | null>;
+
+  deleteWork: (_id: string) => Promise<Work | null>;
+
+  markOldWorkAsFailed: (params: {
+    types: Array<string>;
+    worker: string;
+    referenceDate: Date;
+  }) => Promise<Array<Work>>;
+
+  getReport: (params?: { types?: string[]; from?: Date; to?: Date }) => Promise<WorkerReport[]>;
+};
+
+const WORK_STATUS_FILTER_MAP = {
+  [WorkStatus.DELETED]: { deleted: { $exists: true } },
+  [WorkStatus.NEW]: {
+    started: { $exists: false },
+    deleted: { $exists: false },
+  },
+  [WorkStatus.ALLOCATED]: {
+    started: { $exists: true },
+    finished: { $exists: false },
+    deleted: { $exists: false },
+  },
+  [WorkStatus.SUCCESS]: {
+    finished: { $exists: true },
+    success: true,
+    deleted: { $exists: false },
+  },
+  [WorkStatus.FAILED]: {
+    finished: { $exists: true },
+    success: false,
+    deleted: { $exists: false },
+  },
+};
+
 export const buildQuerySelector = ({
   created,
   scheduled,
@@ -37,30 +133,8 @@ export const buildQuerySelector = ({
   queryString?: string;
   types?: Array<string>;
 }) => {
-  const filterMap = {
-    [WorkStatus.DELETED]: { deleted: { $exists: true } },
-    [WorkStatus.NEW]: {
-      started: { $exists: false },
-      deleted: { $exists: false },
-    },
-    [WorkStatus.ALLOCATED]: {
-      started: { $exists: true },
-      finished: { $exists: false },
-      deleted: { $exists: false },
-    },
-    [WorkStatus.SUCCESS]: {
-      finished: { $exists: true },
-      success: true,
-      deleted: { $exists: false },
-    },
-    [WorkStatus.FAILED]: {
-      finished: { $exists: true },
-      success: false,
-      deleted: { $exists: false },
-    },
-  };
   const statusQuery = {
-    $or: Object.entries(filterMap).reduce(
+    $or: Object.entries(WORK_STATUS_FILTER_MAP).reduce(
       (acc, [key, filter]) => (status?.includes(key as WorkStatus) ? [...acc, filter] : acc),
       [],
     ),
@@ -91,6 +165,24 @@ export const buildQuerySelector = ({
   return { ...query, ...rest };
 };
 
+const convertFilterMapToPipelineBranches = () => {
+  return Object.entries(WORK_STATUS_FILTER_MAP).map(([status, conditions]) => {
+    const caseConditions = Object.entries(conditions).map(([field, condition]) => {
+      if (typeof condition === 'object' && '$exists' in condition) {
+        return condition.$exists
+          ? { $ne: [{ $type: `$${field}` }, 'missing'] }
+          : { $eq: [{ $type: `$${field}` }, 'missing'] };
+      }
+      return { $eq: [`$${field}`, condition] };
+    });
+
+    return {
+      case: caseConditions.length > 1 ? { $and: caseConditions } : caseConditions[0],
+      then: status,
+    };
+  });
+};
+
 const defaultSort: Array<{ key: string; value: SortDirection }> = [
   { key: 'started', value: SortDirection.DESC },
   { key: 'priority', value: SortDirection.DESC },
@@ -98,18 +190,48 @@ const defaultSort: Array<{ key: string; value: SortDirection }> = [
   { key: 'created', value: SortDirection.ASC },
 ];
 
+const normalizeWorkQueueAggregateResult = (data = []): WorkerReport[] => {
+  const statusToFieldMap = {
+    NEW: 'newCount',
+    ALLOCATED: 'startCount',
+    FAILED: 'errorCount',
+    SUCCESS: 'successCount',
+    DELETED: 'deleteCount',
+  };
+
+  return data.map((item) => {
+    const workStatistics: WorkerReport = {
+      type: item.type,
+      ...(Object.values(statusToFieldMap).reduce((acc, key) => ({ ...acc, [key]: 0 }), {}) as any),
+    };
+
+    item.statuses.forEach(({ status, count }) => {
+      if (statusToFieldMap[status]) {
+        workStatistics[statusToFieldMap[status]] = count;
+      }
+    });
+    const { errorCount, successCount, deleteCount } = workStatistics;
+
+    workStatistics.startCount += errorCount + successCount + deleteCount;
+    workStatistics.newCount += workStatistics.startCount;
+
+    return workStatistics;
+  }) as unknown as WorkerReport[];
+};
+
 export const configureWorkerModule = async ({
   db,
+  migrationRepository,
   options,
 }: ModuleInput<WorkerSettingsOptions>): Promise<WorkerModule> => {
+  addMigrations(migrationRepository);
+
   registerEvents(Object.values(WorkerEventTypes));
 
   const WorkQueue = await WorkQueueCollection(db);
 
   const removePrivateFields = buildObfuscatedFieldsFilter(options?.blacklistedVariables);
 
-  const mutations = generateDbMutations<Work>(WorkQueue, WorkQueueSchema) as ModuleMutations<Work>;
-
   const allocateWork: WorkerModule['allocateWork'] = async ({ types, worker = UNCHAINED_WORKER_ID }) => {
     // Find a work item that is scheduled for now and is not started.
     // Also:
@@ -153,18 +275,21 @@ export const configureWorkerModule = async ({
 
     if (!workBeforeUpdate) return null;
 
-    await mutations.update(workId, {
-      $set: {
-        finished,
-        success,
-        error,
-        result,
-        ...(!workBeforeUpdate.started ? { started } : {}),
-        worker,
+    const work = await WorkQueue.findOneAndUpdate(
+      generateDbFilterById(workId),
+      {
+        $set: {
+          updated: new Date(),
+          finished,
+          success,
+          error,
+          result,
+          ...(!workBeforeUpdate.started ? { started } : {}),
+          worker,
+        },
       },
-    });
-
-    const work = await WorkQueue.findOne(generateDbFilterById(workId), {});
+      { returnDocument: 'after' },
+    );
 
     const duration = new Date(work.finished).getTime() - new Date(work.started).getTime();
     if (work.success) {
@@ -332,14 +457,15 @@ export const configureWorkerModule = async ({
       }
 
       const created = new Date();
-      const workId = await mutations.create({
+      const { insertedId: workId } = await WorkQueue.insertOne({
+        _id: generateDbObjectId(),
+        created,
         type,
         input,
         priority,
         scheduled: scheduled || created,
         originalWorkId,
         retries,
-        created,
         worker,
       });
 
@@ -354,13 +480,17 @@ export const configureWorkerModule = async ({
     },
 
     rescheduleWork: async (currentWork, scheduled) => {
-      await mutations.update(currentWork._id, {
-        $set: {
-          scheduled,
+      const work = await WorkQueue.findOneAndUpdate(
+        generateDbFilterById(currentWork._id),
+        {
+          $set: {
+            updated: new Date(),
+            scheduled,
+          },
         },
-      });
+        { returnDocument: 'after' },
+      );
 
-      const work = await WorkQueue.findOne(generateDbFilterById(currentWork._id), {});
       emit(WorkerEventTypes.RESCHEDULED, {
         work: removePrivateFields(work),
         oldScheduled: currentWork.scheduled,
@@ -371,12 +501,13 @@ export const configureWorkerModule = async ({
 
     allocateWork,
 
-    ensureNoWork: async ({ type, priority = 0 }) => {
+    ensureNoWork: async ({ type, priority = 0, scheduleId }) => {
       const query = buildQuerySelector({
         type,
         status: [WorkStatus.NEW],
         priority,
         autoscheduled: true,
+        scheduleId,
       });
 
       await WorkQueue.updateMany(query, {
@@ -386,16 +517,25 @@ export const configureWorkerModule = async ({
       });
     },
 
-    ensureOneWork: async (
-      { type, input, priority = 0, scheduled, timeout, originalWorkId, retries = 20 },
-      workId,
-    ) => {
+    ensureOneWork: async ({
+      type,
+      input,
+      priority = 0,
+      scheduled,
+      timeout,
+      originalWorkId,
+      retries = 20,
+      scheduleId,
+    }) => {
+      const workId = `${scheduleId}:${scheduled.getTime()}`;
+
       const created = new Date();
       const query = buildQuerySelector({
         type,
         status: [WorkStatus.NEW],
         priority,
         autoscheduled: true,
+        scheduleId,
       });
       try {
         const result = await WorkQueue.findOneAndUpdate(
@@ -414,6 +554,7 @@ export const configureWorkerModule = async ({
             },
             $setOnInsert: {
               _id: workId,
+              scheduleId,
               scheduled,
               type,
               created,
@@ -428,6 +569,7 @@ export const configureWorkerModule = async ({
             upsert: true,
           },
         );
+
         if (!result.lastErrorObject.updatedExisting) {
           logger.info(`${type} auto-scheduled @ ${new Date(scheduled).toISOString()}`, {
             workId,
@@ -435,7 +577,7 @@ export const configureWorkerModule = async ({
           emit(WorkerEventTypes.ADDED, removePrivateFields(result.value));
         }
         return result.value;
-      } catch (e) {
+      } catch {
         /* TODO: 
         If the findOneAndUpdate call failed because of _id conflict with a DELETED work,
         we should permanently remove the conflicting deleted work 
@@ -458,9 +600,16 @@ export const configureWorkerModule = async ({
       );
       if (!workBeforeRemoval) return null;
 
-      await mutations.delete(workId);
+      const work = await WorkQueue.findOneAndUpdate(
+        generateDbFilterById(workId),
+        {
+          $set: {
+            deleted: new Date(),
+          },
+        },
+        { returnDocument: 'after' },
+      );
 
-      const work = await WorkQueue.findOne(generateDbFilterById(workId), {});
       emit(WorkerEventTypes.DELETED, removePrivateFields(work));
 
       return work;
@@ -493,5 +642,84 @@ export const configureWorkerModule = async ({
         ),
       );
     },
+
+    getReport: async ({ types, from, to } = { types: null, from: null, to: null }) => {
+      const pipeline = [];
+      const matchConditions = [];
+      // build date filter based on provided values it can be a range if both to and from is supplied
+      // a upper or lowe limit if either from or to is provided
+      // or all if none is provided
+      if (from || to) {
+        const dateConditions = [];
+        if (from) {
+          const fromDate = new Date(from);
+          dateConditions.push({
+            $or: [{ created: { $gte: fromDate } }, { updated: { $gte: fromDate } }],
+          });
+        }
+        if (to) {
+          const toDate = new Date(to);
+          dateConditions.push({
+            $or: [{ created: { $lte: toDate } }, { updated: { $lte: toDate } }],
+          });
+        }
+        if (dateConditions.length > 0) {
+          matchConditions.push({ $and: dateConditions });
+        }
+      }
+      // build types filter if type is provided or ignore types if it is not provided
+      if (types && Array.isArray(types) && types.length) {
+        matchConditions.push({ type: { $in: types } });
+      }
+      if (matchConditions.length > 0) {
+        pipeline.push({
+          $match: {
+            $and: matchConditions,
+          },
+        });
+      }
+      pipeline.push(
+        {
+          $addFields: {
+            status: {
+              $switch: {
+                branches: convertFilterMapToPipelineBranches(),
+                default: 'UNKNOWN',
+              },
+            },
+          },
+        },
+        {
+          $group: {
+            _id: {
+              type: '$type',
+              status: '$status',
+            },
+            count: { $sum: 1 },
+          },
+        },
+        {
+          $group: {
+            _id: '$_id.type',
+            statuses: {
+              $push: {
+                status: '$_id.status',
+                count: '$count',
+              },
+            },
+          },
+        },
+
+        {
+          $project: {
+            _id: 0,
+            type: '$_id',
+            statuses: 1,
+          },
+        },
+      );
+
+      return normalizeWorkQueueAggregateResult(await WorkQueue.aggregate(pipeline).toArray()) as any;
+    },
   };
 };

package/src/module/migrations/addMigrations.ts

@@ -0,0 +1,18 @@
+import { Migration, MigrationRepository } from '@unchainedshop/core';
+import { WorkQueueCollection } from '../../db/WorkQueueCollection.js';
+
+export default function addMigrations(repository: MigrationRepository<Migration>) {
+  repository?.register({
+    id: 20240905161400,
+    name: 'Remove all autoscheduled work items so they get scheduled freshly',
+    up: async () => {
+      const WorkQueue = await WorkQueueCollection(repository.db);
+
+      await WorkQueue.deleteMany({
+        autoscheduled: true,
+        started: null,
+        deleted: null,
+      });
+    },
+  });
+}

package/src/schedulers/FailedRescheduler.ts

@@ -1,7 +1,9 @@
-import { IScheduler, Work, WorkData } from '@unchainedshop/types/worker.js';
 import { log } from '@unchainedshop/logger';
 import { subscribe } from '@unchainedshop/events';
 import { WorkerEventTypes } from '../director/WorkerEventTypes.js';
+import { UnchainedCore } from '@unchainedshop/core';
+import { WorkData } from '../worker-index.js';
+import { Work } from '../types.js';
 
 export interface FailedReschedulerParams {
   retryInput?: (
@@ -10,6 +12,20 @@ export interface FailedReschedulerParams {
   ) => Promise<Record<string, any> | null>;
 }
 
+export type IScheduler<P> = {
+  key: string;
+  label: string;
+  version: string;
+
+  actions: (
+    params: P,
+    unchainedAPI: UnchainedCore,
+  ) => {
+    start: () => void;
+    stop: () => void;
+  };
+};
+
 export const FailedRescheduler: IScheduler<FailedReschedulerParams> = {
   key: 'shop.unchained.scheduler.failed',
   label: 'Reschedule failed works',

package/src/types.ts

@@ -0,0 +1,20 @@
+import type { TimestampFields } from '@unchainedshop/mongodb';
+
+export type Work = {
+  _id?: string;
+  priority: number;
+  retries: number;
+  scheduled: Date;
+  type: string;
+  input: Record<string, any>;
+  error?: any;
+  finished?: Date;
+  originalWorkId?: string;
+  result?: any;
+  started?: Date;
+  success?: boolean;
+  timeout?: number;
+  worker?: string;
+  autoscheduled?: boolean;
+  scheduleId?: string;
+} & TimestampFields;

package/src/worker-index.ts

@@ -1,12 +1,12 @@
-export { configureWorkerModule } from './module/configureWorkerModule.js';
+export * from './types.js';
 
-export { WorkerDirector } from './director/WorkerDirector.js';
-export { WorkerAdapter } from './director/WorkerAdapter.js';
+export * from './module/configureWorkerModule.js';
+export * from './director/WorkerDirector.js';
+export * from './director/WorkerAdapter.js';
 export { WorkStatus } from './director/WorkStatus.js';
 export { WorkerEventTypes } from './director/WorkerEventTypes.js';
 
-export { FailedRescheduler } from './schedulers/FailedRescheduler.js';
-
-export { BaseWorker } from './workers/BaseWorker.js';
-export { EventListenerWorker } from './workers/EventListenerWorker.js';
-export { IntervalWorker } from './workers/IntervalWorker.js';
+export * from './schedulers/FailedRescheduler.js';
+export * from './workers/BaseWorker.js';
+export * from './workers/EventListenerWorker.js';
+export * from './workers/IntervalWorker.js';

package/src/workers/BaseWorker.ts

@@ -1,7 +1,34 @@
-import { IWorker, WorkData } from '@unchainedshop/types/worker.js';
 import later from '@breejs/later';
 import { log } from '@unchainedshop/logger';
 import { WorkerDirector } from '../director/WorkerDirector.js';
+import { UnchainedCore } from '@unchainedshop/core';
+import { Work } from '../types.js';
+
+export type WorkData = Pick<
+  Partial<Work>,
+  'input' | 'originalWorkId' | 'priority' | 'retries' | 'timeout' | 'scheduled' | 'worker' | 'scheduleId'
+> & { type: string };
+
+export type IWorker<P extends { workerId?: string }> = {
+  key: string;
+  label: string;
+  version: string;
+  type: string;
+  external: boolean;
+
+  getFloorDate: (date?: Date) => Date;
+
+  actions: (
+    params: P,
+    unchainedAPI: UnchainedCore,
+  ) => {
+    autorescheduleTypes: (options: { referenceDate: Date }) => Promise<Array<Work | null>>;
+    process: (options: { maxWorkItemCount?: number; referenceDate?: Date }) => Promise<void>;
+    reset: () => Promise<void>;
+    start: () => void;
+    stop: () => void;
+  };
+};
 
 interface WorkerParams {
   workerId?: string;
@@ -47,6 +74,7 @@ export const BaseWorker: IWorker<WorkerParams> = {
               await unchainedAPI.modules.worker.ensureNoWork({
                 type: workConfig.type,
                 priority: workConfig.priority || 0,
+                scheduleId,
               });
               return null;
             }
@@ -57,6 +85,7 @@ export const BaseWorker: IWorker<WorkerParams> = {
             nextDate.setMilliseconds(0);
             const workData: WorkData = {
               type: workConfig.type,
+              scheduleId,
               scheduled: nextDate,
               timeout: workConfig.timeout,
               priority: workConfig.priority || 0,
@@ -68,8 +97,7 @@ export const BaseWorker: IWorker<WorkerParams> = {
               // when it explicitly returns a falsish input instead of a dictionary
               if (!workData.input) return null;
             }
-            const workId = `${scheduleId}:${workData.scheduled.getTime()}`;
-            return unchainedAPI.modules.worker.ensureOneWork(workData, workId);
+            return unchainedAPI.modules.worker.ensureOneWork(workData);
           }),
         );
       },

package/src/workers/EventListenerWorker.ts

@@ -1,7 +1,6 @@
-import { IWorker } from '@unchainedshop/types/worker.js';
 import { subscribe } from '@unchainedshop/events';
 import { WorkerEventTypes } from '../director/WorkerEventTypes.js';
-import { BaseWorker } from './BaseWorker.js';
+import { BaseWorker, IWorker } from './BaseWorker.js';
 
 function debounce<T extends (...args: any) => any>(func: T, wait) {
   let timeout;

package/src/workers/IntervalWorker.ts

@@ -1,6 +1,6 @@
-import { IWorker, WorkerSchedule } from '@unchainedshop/types/worker.js';
 import later from '@breejs/later';
-import { BaseWorker } from './BaseWorker.js';
+import { BaseWorker, IWorker } from './BaseWorker.js';
+import { WorkerSchedule } from '../worker-index.js';
 
 const { NODE_ENV } = process.env;
 

package/lib/db/WorkQueueSchema.d.ts

@@ -1,3 +0,0 @@
-import SimpleSchema from 'simpl-schema';
-export declare const WorkQueueSchema: SimpleSchema;
-//# sourceMappingURL=WorkQueueSchema.d.ts.map

package/lib/db/WorkQueueSchema.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"WorkQueueSchema.d.ts","sourceRoot":"","sources":["../../src/db/WorkQueueSchema.ts"],"names":[],"mappings":"AACA,OAAO,YAAY,MAAM,cAAc,CAAC;AAExC,eAAO,MAAM,eAAe,cAmB3B,CAAC"}

package/lib/db/WorkQueueSchema.js

@@ -1,20 +0,0 @@
-import { Schemas } from '@unchainedshop/utils';
-import SimpleSchema from 'simpl-schema';
-export const WorkQueueSchema = new SimpleSchema({
-    finished: Date,
-    originalWorkId: { type: String },
-    priority: { type: Number, required: true },
-    retries: { type: Number, required: true },
-    scheduled: { type: Date, required: true },
-    started: Date,
-    success: Boolean,
-    timeout: Number,
-    type: { type: String, required: true },
-    worker: String,
-    // Worker data
-    input: { type: Object, blackbox: true },
-    result: { type: Object, blackbox: true },
-    error: { type: Object, blackbox: true },
-    ...Schemas.timestampFields,
-}, { requiredByDefault: false });
-//# sourceMappingURL=WorkQueueSchema.js.map

package/lib/db/WorkQueueSchema.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"WorkQueueSchema.js","sourceRoot":"","sources":["../../src/db/WorkQueueSchema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAC/C,OAAO,YAAY,MAAM,cAAc,CAAC;AAExC,MAAM,CAAC,MAAM,eAAe,GAAG,IAAI,YAAY,CAC7C;IACE,QAAQ,EAAE,IAAI;IACd,cAAc,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE;IAChC,QAAQ,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,IAAI,EAAE;IAC1C,OAAO,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,IAAI,EAAE;IACzC,SAAS,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE;IACzC,OAAO,EAAE,IAAI;IACb,OAAO,EAAE,OAAO;IAChB,OAAO,EAAE,MAAM;IACf,IAAI,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,IAAI,EAAE;IACtC,MAAM,EAAE,MAAM;IACd,cAAc;IACd,KAAK,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,IAAI,EAAE;IACvC,MAAM,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,IAAI,EAAE;IACxC,KAAK,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,IAAI,EAAE;IACvC,GAAG,OAAO,CAAC,eAAe;CAC3B,EACD,EAAE,iBAAiB,EAAE,KAAK,EAAE,CAC7B,CAAC"}