@cratis/chronicle 0.1.0 → 0.2.0

package/Projections/declarative/ProjectionBuilderFor.ts

@@ -1,294 +0,0 @@
-// Copyright (c) Cratis. All rights reserved.
-// Licensed under the MIT license. See LICENSE file in the project root for full license information.
-
-import { AutoMap } from '@cratis/chronicle.contracts';
-import { getEventTypeFor } from '../../Events/eventTypeDecorator';
-import { EventSequenceId } from '../../EventSequences/EventSequenceId';
-import { IChildrenBuilder } from './IChildrenBuilder';
-import { IFromBuilder } from './IFromBuilder';
-import { IFromEveryBuilder } from './IFromEveryBuilder';
-import { IJoinBuilder } from './IJoinBuilder';
-import { INestedBuilder } from './INestedBuilder';
-import { IProjectionBuilderFor } from './IProjectionBuilderFor';
-import { IRemovedWithBuilder } from './IRemovedWithBuilder';
-import { IRemovedWithJoinBuilder } from './IRemovedWithJoinBuilder';
-import { JoinBuilder } from './JoinBuilder';
-import { FromEveryBuilder } from './FromEveryBuilder';
-import { FromBuilder } from './FromBuilder';
-import { RemovedWithBuilder } from './RemovedWithBuilder';
-import { RemovedWithJoinBuilder } from './RemovedWithJoinBuilder';
-
-type ContractEventType = { Id: string; Generation: number; Tombstone: boolean };
-
-interface FromRecord {
-    Key: ContractEventType;
-    Value: { Properties: Record<string, string>; Key: string; ParentKey: string };
-}
-
-interface RemovedWithRecord {
-    Key: ContractEventType;
-    Value: { Key: string; ParentKey: string };
-}
-
-interface JoinRecord {
-    Key: ContractEventType;
-    Value: { On: string; Properties: Record<string, string>; Key: string };
-}
-
-interface RemovedWithJoinRecord {
-    Key: ContractEventType;
-    Value: { Key: string };
-}
-
-/**
- * Concrete implementation of {@link IProjectionBuilderFor} that accumulates projection
- * configuration and produces a Chronicle-compatible projection definition payload.
- * @template TReadModel - The read model type this projection produces.
- */
-export class ProjectionBuilderFor<TReadModel> implements IProjectionBuilderFor<TReadModel> {
-    private _eventSequenceId: string = EventSequenceId.eventLog.value;
-    private _containerName: string | undefined;
-    private _rewindable: boolean = true;
-    private _active: boolean = true;
-    private _autoMap: AutoMap = AutoMap.Enabled;
-    private _initialState: string = '{}';
-    private readonly _from: FromRecord[] = [];
-    private readonly _join: JoinRecord[] = [];
-    private readonly _removedWith: RemovedWithRecord[] = [];
-    private readonly _removedWithJoin: RemovedWithJoinRecord[] = [];
-    private _all: { Properties: Record<string, string>; IncludeChildren: boolean; AutoMap: AutoMap } = {
-        Properties: {},
-        IncludeChildren: false,
-        AutoMap: AutoMap.Inherit
-    };
-
-    /** @inheritdoc */
-    fromEventSequence(eventSequenceId: string): this {
-        this._eventSequenceId = eventSequenceId;
-        return this;
-    }
-
-    /** @inheritdoc */
-    containerName(name: string): this {
-        this._containerName = name;
-        return this;
-    }
-
-    /** @inheritdoc */
-    notRewindable(): this {
-        this._rewindable = false;
-        return this;
-    }
-
-    /** @inheritdoc */
-    passive(): this {
-        this._active = false;
-        return this;
-    }
-
-    /** @inheritdoc */
-    autoMap(): this {
-        this._autoMap = AutoMap.Enabled;
-        return this;
-    }
-
-    /** @inheritdoc */
-    noAutoMap(): this {
-        this._autoMap = AutoMap.Disabled;
-        return this;
-    }
-
-    /** @inheritdoc */
-    withInitialValues(initialValueProvider: () => TReadModel): this {
-        this._initialState = JSON.stringify(initialValueProvider());
-        return this;
-    }
-
-    /** @inheritdoc */
-    from<TEvent>(
-        eventType: new (...args: any[]) => TEvent,
-        builderCallback?: (builder: IFromBuilder<TReadModel, TEvent>) => void
-    ): this {
-        const contractType = this.toContractEventType(eventType);
-        const fromBuilder = new FromBuilder<TReadModel, TEvent>();
-        builderCallback?.(fromBuilder);
-        this._from.push({
-            Key: contractType,
-            Value: {
-                Properties: fromBuilder.entry.properties,
-                Key: fromBuilder.entry.key,
-                ParentKey: fromBuilder.entry.parentKey
-            }
-        });
-        return this;
-    }
-
-    /** @inheritdoc */
-    join<TEvent>(
-        eventType: new (...args: any[]) => TEvent,
-        builderCallback?: (builder: IJoinBuilder<TReadModel, TEvent>) => void
-    ): this {
-        const contractType = this.toContractEventType(eventType);
-        const joinBuilder = new JoinBuilder<TReadModel, TEvent>();
-        builderCallback?.(joinBuilder);
-        this._join.push({
-            Key: contractType,
-            Value: {
-                On: joinBuilder.entry.on,
-                Properties: joinBuilder.entry.properties,
-                Key: joinBuilder.entry.key
-            }
-        });
-        return this;
-    }
-
-    /** @inheritdoc */
-    fromEvery(builderCallback: (builder: IFromEveryBuilder<TReadModel>) => void): this {
-        const builder = new FromEveryBuilder<TReadModel>();
-        builderCallback(builder);
-        this._all = {
-            Properties: {
-                ...this._all.Properties,
-                ...builder.entry.properties
-            },
-            IncludeChildren: builder.entry.includeChildren,
-            AutoMap: AutoMap.Inherit
-        };
-        return this;
-    }
-
-    /** @inheritdoc */
-    removedWith<TEvent>(
-        eventType: new (...args: any[]) => TEvent,
-        builderCallback?: (builder: IRemovedWithBuilder<TReadModel, TEvent>) => void
-    ): this {
-        const contractType = this.toContractEventType(eventType);
-        const removedWithBuilder = new RemovedWithBuilder<TReadModel, TEvent>();
-        builderCallback?.(removedWithBuilder);
-        this._removedWith.push({
-            Key: contractType,
-            Value: {
-                Key: removedWithBuilder.entry.key,
-                ParentKey: removedWithBuilder.entry.parentKey
-            }
-        });
-        return this;
-    }
-
-    /** @inheritdoc */
-    removedWithJoin<TEvent>(
-        eventType: new (...args: any[]) => TEvent,
-        builderCallback?: (builder: IRemovedWithJoinBuilder<TReadModel, TEvent>) => void
-    ): this {
-        const contractType = this.toContractEventType(eventType);
-        const removedWithJoinBuilder = new RemovedWithJoinBuilder<TReadModel, TEvent>();
-        builderCallback?.(removedWithJoinBuilder);
-        this._removedWithJoin.push({
-            Key: contractType,
-            Value: {
-                Key: removedWithJoinBuilder.entry.key
-            }
-        });
-        return this;
-    }
-
-    /** @inheritdoc */
-    children<TChildModel>(
-        _targetPropertyAccessor: any,
-        _builderCallback: (builder: IChildrenBuilder<TReadModel, TChildModel>) => void
-    ): this {
-        throw new Error('children is not implemented yet.');
-    }
-
-    /** @inheritdoc */
-    nested<TNestedModel>(
-        _targetPropertyAccessor: any,
-        _builderCallback: (builder: INestedBuilder<TReadModel, TNestedModel>) => void
-    ): this {
-        throw new Error('nested is not implemented yet.');
-    }
-
-    /**
-     * Builds the contract-compatible projection definition payload.
-     * @param identifier - The projection identifier.
-     * @param readModelName - The read model container name.
-     * @returns The projection definition object ready to send to the kernel.
-     */
-    build(identifier: string, readModelName: string): Record<string, unknown> {
-        const definition: Record<string, unknown> = {
-            EventSequenceId: this._eventSequenceId,
-            Identifier: identifier,
-            ReadModel: this._containerName ?? readModelName,
-            IsActive: this._active,
-            IsRewindable: this._rewindable,
-            InitialModelState: this._initialState,
-            From: this._from,
-            Join: this._join,
-            Children: {},
-            FromEvery: [],
-            All: this._all,
-            FromEventProperty: undefined,
-            RemovedWith: this._removedWith,
-            RemovedWithJoin: this._removedWithJoin,
-            LastUpdated: { Value: '' },
-            Tags: [],
-            AutoMap: this._autoMap,
-            Nested: {}
-        };
-        definition.LastUpdated = { Value: this.computeStableLastUpdated(definition) };
-        return definition;
-    }
-
-    /**
-     * Gets the set of read model properties referenced by configured mappings.
-     * @returns Unique read model property names used by from/join/fromEvery mappings.
-     */
-    getMappedReadModelProperties(): string[] {
-        const mappedProperties = new Set<string>();
-
-        for (const from of this._from) {
-            for (const property of Object.keys(from.Value.Properties)) {
-                mappedProperties.add(property);
-            }
-        }
-
-        for (const join of this._join) {
-            for (const property of Object.keys(join.Value.Properties)) {
-                mappedProperties.add(property);
-            }
-        }
-
-        for (const property of Object.keys(this._all.Properties)) {
-            mappedProperties.add(property);
-        }
-
-        return Array.from(mappedProperties.values());
-    }
-
-    private toContractEventType(eventTypeConstructor: Function): ContractEventType {
-        const eventType = getEventTypeFor(eventTypeConstructor);
-        if (eventType.id.value === '') {
-            throw new Error(`Event type '${eventTypeConstructor.name}' is not decorated with @eventType().`);
-        }
-        return {
-            Id: eventType.id.value,
-            Generation: eventType.generation.value,
-            Tombstone: false
-        };
-    }
-
-    /**
-     * Computes a stable, deterministic ISO timestamp from the projection definition content,
-     * excluding the LastUpdated field itself. This ensures the server does not interpret
-     * a repeated registration of an unchanged definition as a definition change.
-     */
-    private computeStableLastUpdated(definition: Record<string, unknown>): string {
-        const { LastUpdated: _omit, ...rest } = definition;
-        const content = JSON.stringify(rest, Object.keys(rest).sort());
-        let hash = 5381;
-        for (let i = 0; i < content.length; i++) {
-            hash = ((hash << 5) + hash + content.charCodeAt(i)) >>> 0;
-        }
-        return new Date(hash * 1000).toISOString();
-    }
-}

package/Projections/modelBound/setFromContext.ts

@@ -1,59 +0,0 @@
-// Copyright (c) Cratis. All rights reserved.
-// Licensed under the MIT license. See LICENSE file in the project root for full license information.
-
-import 'reflect-metadata';
-import { PropertyAccessor, PropertyPathResolverProxyHandler } from '@cratis/fundamentals';
-import type { EventContext } from '../../Events';
-import { TypeIntrospector } from '../../types';
-
-/** Metadata stored by the setFromContext property decorator. */
-export interface SetFromContextMetadata {
-    /** The event constructor associated with this annotation. */
-    readonly eventType: Function;
-    /** The event context property name to read the value from. Defaults to the decorated property name. */
-    readonly contextPropertyName?: string;
-}
-
-const METADATA_KEY = 'chronicle:projection:setFromContext';
-
-/**
- * Property decorator that maps a value from an event context property onto the decorated read model property.
- * @param eventType - The event constructor.
- * @param contextPropertyOrAccessor - Optional event context property name or property accessor. Defaults to the property name.
- * @returns A property decorator.
- */
-export function setFromContext(eventType: Function, contextPropertyName?: string): PropertyDecorator;
-export function setFromContext(eventType: Function, contextPropertyAccessor?: PropertyAccessor<EventContext>): PropertyDecorator;
-export function setFromContext(
-    eventType: Function,
-    contextPropertyOrAccessor?: string | PropertyAccessor<EventContext>
-): PropertyDecorator {
-    return (target: object, propertyKey: string | symbol) => {
-        const key = propertyKey.toString();
-        TypeIntrospector.trackProperty((target as { constructor: Function }).constructor, key);
-        const existing: SetFromContextMetadata[] = Reflect.getMetadata(METADATA_KEY, target, key) ?? [];
-
-        let contextPropertyName: string | undefined;
-        if (typeof contextPropertyOrAccessor === 'string') {
-            contextPropertyName = contextPropertyOrAccessor;
-        } else if (typeof contextPropertyOrAccessor === 'function') {
-            const handler = new PropertyPathResolverProxyHandler();
-            const proxy = new Proxy({}, handler);
-            contextPropertyOrAccessor(proxy as EventContext);
-            contextPropertyName = handler.property;
-        }
-
-        const metadata: SetFromContextMetadata = { eventType, contextPropertyName };
-        Reflect.defineMetadata(METADATA_KEY, [...existing, metadata], target, key);
-    };
-}
-
-/**
- * Retrieves all setFromContext metadata stored on the given property.
- * @param target - The class prototype.
- * @param propertyKey - The property name.
- * @returns An array of setFromContext metadata entries.
- */
-export function getSetFromContextMetadata(target: object, propertyKey: string): SetFromContextMetadata[] {
-    return Reflect.getMetadata(METADATA_KEY, target, propertyKey) ?? [];
-}

package/Reactors/Reactors.ts

@@ -1,321 +0,0 @@
-// Copyright (c) Cratis. All rights reserved.
-// Licensed under the MIT license. See LICENSE file in the project root for full license information.
-
-import 'reflect-metadata';
-import { diag } from '@opentelemetry/api';
-import { Constructor } from '@cratis/fundamentals';
-import { ObservationState, ReactorMessage } from '@cratis/chronicle.contracts';
-import { IClientArtifactsProvider } from '../artifacts';
-import { ChronicleConnection } from '../connection';
-import { ConnectionLifecycle } from '../connection/ConnectionLifecycle';
-import { getEventTypeMetadata } from '../Events/eventTypeDecorator';
-import { EventContext } from '../Events/EventContext';
-import { EventTypeId } from '../Events/EventTypeId';
-import { EventTypeGeneration } from '../Events/EventTypeGeneration';
-import { EventSequenceId } from '../EventSequences/EventSequenceId';
-import { IReactors } from './IReactors';
-import { getReactorMetadata } from './reactor';
-
-/** Expression used to partition reactor observations by event source ID. */
-const EVENT_SOURCE_ID_KEY = '$eventSourceId';
-
-/** Sentinel sequence number sent back when no event was successfully processed. */
-const SEQUENCE_NUMBER_UNAVAILABLE = 4294967295;
-
-interface EventTypeEntry {
-    readonly id: string;
-    readonly generation: number;
-    readonly methodName: string;
-}
-
-/**
- * A push-based async queue that implements {@link AsyncIterable} for use with nice-grpc
- * bidirectional streaming. Values pushed via {@link send} are yielded in order to
- * any consumer that iterates the queue.
- */
-class AsyncQueue<T> {
-    private readonly _queue: T[] = [];
-    private _resolve: ((result: IteratorResult<T, undefined>) => void) | undefined = undefined;
-    private _done = false;
-
-    /** Pushes a value into the queue. No-op if the queue has been completed. */
-    send(value: T): void {
-        if (this._done) return;
-        if (this._resolve) {
-            const resolve = this._resolve;
-            this._resolve = undefined;
-            resolve({ value, done: false });
-        } else {
-            this._queue.push(value);
-        }
-    }
-
-    /** Signals that no more values will be pushed, causing consumers to finish iteration. */
-    complete(): void {
-        this._done = true;
-        if (this._resolve) {
-            this._resolve({ value: undefined, done: true });
-            this._resolve = undefined;
-        }
-    }
-
-    [Symbol.asyncIterator](): AsyncIterator<T, undefined> {
-        // eslint-disable-next-line @typescript-eslint/no-this-alias
-        const self = this;
-        return {
-            next(): Promise<IteratorResult<T, undefined>> {
-                if (self._queue.length > 0) {
-                    return Promise.resolve({ value: self._queue.shift()!, done: false });
-                }
-                if (self._done) {
-                    return Promise.resolve({ value: undefined, done: true });
-                }
-                return new Promise(resolve => {
-                    self._resolve = resolve as (result: IteratorResult<T, undefined>) => void;
-                });
-            },
-            return(): Promise<IteratorResult<T, undefined>> {
-                self._done = true;
-                if (self._resolve) {
-                    self._resolve({ value: undefined, done: true });
-                    self._resolve = undefined;
-                }
-                return Promise.resolve({ value: undefined, done: true });
-            }
-        };
-    }
-}
-
-/**
- * Implements {@link IReactors}, managing discovery and registration of reactors
- * with the Chronicle Kernel via bidirectional gRPC streaming.
- */
-export class Reactors implements IReactors {
-    private readonly _logger = diag.createComponentLogger({ namespace: '@cratis/chronicle/Reactors' });
-    private readonly _lifecycle: ConnectionLifecycle;
-    private readonly _reactors = new Map<string, Constructor>();
-    private readonly _queues = new Map<string, AsyncQueue<ReactorMessage>>();
-    private _registered = false;
-
-    /**
-     * Creates a new {@link Reactors} instance.
-     * @param _clientArtifacts - Provider for discovered client artifact types.
-     * @param _connection - The Chronicle gRPC connection.
-     * @param _eventStoreName - The name of the event store.
-     * @param _namespace - The namespace within the event store.
-     * @param lifecycle - The connection lifecycle used to react to disconnect events.
-     */
-    constructor(
-        private readonly _clientArtifacts: IClientArtifactsProvider,
-        private readonly _connection: ChronicleConnection,
-        private readonly _eventStoreName: string,
-        private readonly _namespace: string,
-        lifecycle: ConnectionLifecycle
-    ) {
-        this._lifecycle = lifecycle;
-        lifecycle.onDisconnected(async () => {
-            this._logger.info('Disconnected — stopping all reactor observations');
-            this._registered = false;
-            this.disconnectAll();
-        });
-    }
-
-    /** @inheritdoc */
-    async discover(): Promise<void> {
-        this._reactors.clear();
-        for (const type of this._clientArtifacts.reactors) {
-            const metadata = getReactorMetadata(type);
-            if (metadata) {
-                this._reactors.set(metadata.id.value, type);
-                this._logger.debug('Discovered reactor', { reactorId: metadata.id.value, type: (type as Function).name });
-            }
-        }
-    }
-
-    /** @inheritdoc */
-    async register(): Promise<void> {
-        if (this._registered) {
-            return;
-        }
-
-        if (this._reactors.size === 0) {
-            await this.discover();
-        }
-
-        this._logger.info('Registering reactors', { count: this._reactors.size });
-        for (const [id, reactorType] of this._reactors) {
-            this.startObservation(id, reactorType);
-        }
-
-        this._registered = true;
-    }
-
-    private startObservation(id: string, reactorType: Constructor): void {
-        const metadata = getReactorMetadata(reactorType)!;
-        const eventSequenceId = metadata.eventSequenceId ?? EventSequenceId.eventLog.value;
-        const eventTypes = this.getEventTypesFor(reactorType);
-
-        this._logger.info('Starting reactor observation', {
-            reactorId: id,
-            eventSequenceId,
-            handlerCount: eventTypes.length,
-            handlers: eventTypes.map(e => e.methodName)
-        });
-
-        this.observeReactor(id, reactorType, eventSequenceId, eventTypes).catch(err => {
-            this._logger.error('Reactor observation loop exited with error', { reactorId: id, error: String(err) });
-        });
-    }
-
-    private async observeReactor(
-        id: string,
-        reactorType: Constructor,
-        eventSequenceId: string,
-        eventTypes: EventTypeEntry[]
-    ): Promise<void> {
-        const queue = new AsyncQueue<ReactorMessage>();
-        this._queues.set(id, queue);
-
-        queue.send({
-            Content: {
-                Value0: {
-                    ConnectionId: this._lifecycle.connectionId,
-                    EventStore: this._eventStoreName,
-                    Namespace: this._namespace,
-                    Reactor: {
-                        ReactorId: id,
-                        EventSequenceId: eventSequenceId,
-                        EventTypes: eventTypes.map(et => ({
-                            EventType: { Id: et.id, Generation: et.generation, Tombstone: false },
-                            Key: EVENT_SOURCE_ID_KEY
-                        })),
-                        IsReplayable: false,
-                        Tags: [],
-                        Filters: {
-                            FilterTags: [],
-                            EventSourceType: '',
-                            EventStreamType: 'All'
-                        }
-                    }
-                },
-                Value1: undefined
-            }
-        });
-
-        try {
-            const reactorInstance = new (reactorType as new () => Record<string, Function>)();
-
-            for await (const eventsToObserve of this._connection.reactors.observe(queue)) {
-                let lastSuccessfullyObservedEvent = SEQUENCE_NUMBER_UNAVAILABLE;
-                let state = ObservationState.Success;
-                const exceptionMessages: string[] = [];
-                let exceptionStackTrace = '';
-
-                this._logger.debug('Received events to observe', {
-                    reactorId: id,
-                    partition: eventsToObserve.Partition,
-                    count: eventsToObserve.Events.length
-                });
-
-                for (const event of eventsToObserve.Events) {
-                    try {
-                        const eventTypeId = event.Context?.EventType?.Id;
-                        if (!eventTypeId) {
-                            this._logger.warn('Event missing event type context', { reactorId: id });
-                            continue;
-                        }
-
-                        const entry = eventTypes.find(et => et.id === eventTypeId);
-                        if (!entry) {
-                            this._logger.debug('No handler registered for event type — skipping', { reactorId: id, eventTypeId });
-                            lastSuccessfullyObservedEvent = event.Context!.SequenceNumber;
-                            continue;
-                        }
-
-                        const content = JSON.parse(event.Content) as Record<string, unknown>;
-                        this._logger.debug('Event content', { reactorId: id, eventTypeId, contentKeys: Object.keys(content), rawContent: event.Content.substring(0, 200) });
-                        const context: EventContext = {
-                            sequenceNumber: event.Context!.SequenceNumber,
-                            eventSourceId: event.Context!.EventSourceId,
-                            eventType: {
-                                id: new EventTypeId(event.Context!.EventType!.Id),
-                                generation: new EventTypeGeneration(event.Context!.EventType!.Generation),
-                                tombstone: event.Context!.EventType!.Tombstone
-                            },
-                            occurred: new Date(event.Context!.Occurred?.Value ?? ''),
-                            correlationId: event.Context?.CorrelationId ? `${event.Context.CorrelationId.lo}-${event.Context.CorrelationId.hi}` : '',
-                            causation: []
-                        };
-
-                        this._logger.info('Invoking reactor handler', {
-                            reactorId: id,
-                            method: entry.methodName,
-                            sequenceNumber: event.Context!.SequenceNumber,
-                            eventTypeId
-                        });
-
-                        await reactorInstance[entry.methodName](content, context);
-                        lastSuccessfullyObservedEvent = event.Context!.SequenceNumber;
-                    } catch (err) {
-                        this._logger.error('Error handling event in reactor', { reactorId: id, error: String(err) });
-                        exceptionMessages.push(String(err));
-                        exceptionStackTrace = err instanceof Error ? (err.stack ?? '') : '';
-                        state = ObservationState.Failed;
-                        break;
-                    }
-                }
-
-                queue.send({
-                    Content: {
-                        Value0: undefined,
-                        Value1: {
-                            Partition: eventsToObserve.Partition,
-                            State: state,
-                            LastSuccessfulObservation: lastSuccessfullyObservedEvent,
-                            ExceptionMessages: exceptionMessages,
-                            ExceptionStackTrace: exceptionStackTrace
-                        }
-                    }
-                });
-            }
-        } catch (err) {
-            if (!this._queues.has(id)) {
-                this._logger.debug('Reactor observation stream closed cleanly', { reactorId: id });
-            } else {
-                this._logger.error('Reactor observation stream ended unexpectedly', { reactorId: id, error: String(err) });
-            }
-        } finally {
-            this._queues.delete(id);
-        }
-    }
-
-    private getEventTypesFor(reactorType: Constructor): EventTypeEntry[] {
-        const proto = reactorType.prototype as Record<string, unknown>;
-        const entries: EventTypeEntry[] = [];
-
-        for (const eventTypeClass of this._clientArtifacts.eventTypes) {
-            const eventTypeMeta = getEventTypeMetadata(eventTypeClass);
-            if (!eventTypeMeta) continue;
-
-            const className = (eventTypeClass as Function).name;
-            const methodName = className.charAt(0).toLowerCase() + className.slice(1);
-
-            if (typeof proto[methodName] === 'function') {
-                entries.push({
-                    id: eventTypeMeta.eventType.id.value,
-                    generation: eventTypeMeta.eventType.generation.value,
-                    methodName
-                });
-            }
-        }
-
-        return entries;
-    }
-
-    private disconnectAll(): void {
-        for (const queue of this._queues.values()) {
-            queue.complete();
-        }
-        this._queues.clear();
-    }
-}