@magek/common 0.0.1

package/dist/app.d.ts

@@ -0,0 +1,17 @@
+import { MagekConfig, UUID, EntityInterface, Class, ReadModelInterface, Searcher, EventSearchParameters, EventSearchResponse, PaginatedEntitiesIdsResult, EventDeleteParameters } from '.';
+/**
+ * `MagekApp` is the interface of the user-facing functions that
+ * the framework provides.
+ */
+export interface MagekApp {
+    start(projectPath: string): void;
+    config: MagekConfig;
+    configure(environment: string, configurator: (config: MagekConfig) => void): void;
+    configureCurrentEnv(configurator: (config: MagekConfig) => void): void;
+    entity<TEntity extends EntityInterface>(entityName: Class<TEntity>, entityID: UUID): Promise<TEntity | undefined>;
+    readModel<TReadModel extends ReadModelInterface>(readModelClass: Class<TReadModel>): Searcher<TReadModel>;
+    events(request: EventSearchParameters): Promise<Array<EventSearchResponse>>;
+    entitiesIDs(entityTypeName: string, limit: number, afterCursor: Record<string, string> | undefined): Promise<PaginatedEntitiesIdsResult>;
+    deleteEvent(parameters: EventDeleteParameters): Promise<boolean>;
+    configuredEnvironments: Set<string>;
+}

package/dist/app.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/concepts/authorizers.d.ts

@@ -0,0 +1,7 @@
+import { EventSearchRequest, ReadModelRequestEnvelope, UserEnvelope, CommandEnvelope, QueryEnvelope, HealthEnvelope } from '../envelope';
+import { ReadModelInterface } from './read-model';
+export type CommandAuthorizer = (currentUser?: UserEnvelope, commandEnvelope?: CommandEnvelope) => Promise<void>;
+export type QueryAuthorizer = (currentUser?: UserEnvelope, queryEnvelope?: QueryEnvelope) => Promise<void>;
+export type HealthAuthorizer = (currentUser?: UserEnvelope, healthEnvelope?: HealthEnvelope) => Promise<void>;
+export type ReadModelAuthorizer = (currentUser?: UserEnvelope, readModelRequestEnvelope?: ReadModelRequestEnvelope<ReadModelInterface>) => Promise<void>;
+export type EventStreamAuthorizer = (currentUser?: UserEnvelope, eventSearchRequest?: EventSearchRequest) => Promise<void>;

package/dist/concepts/authorizers.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/concepts/command.d.ts

@@ -0,0 +1,14 @@
+import { Class } from '../typelevel';
+import { PropertyMetadata } from '../metadata-types';
+import { Register, CommandAuthorizer, CommandFilterHooks } from './.';
+export type CommandInput = Record<string, any>;
+export interface CommandInterface<TCommand = unknown, THandleResult = unknown> extends Class<TCommand> {
+    handle(command: TCommand, register: Register): Promise<THandleResult>;
+}
+export interface CommandMetadata<TCommand = unknown> {
+    readonly class: CommandInterface<TCommand>;
+    readonly properties: Array<PropertyMetadata>;
+    readonly methods: Array<PropertyMetadata>;
+    readonly authorizer: CommandAuthorizer;
+    readonly before: NonNullable<CommandFilterHooks['before']>;
+}

package/dist/concepts/command.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/concepts/data-migration.d.ts

@@ -0,0 +1,19 @@
+import { AnyClass } from '../typelevel';
+import { Register } from './register';
+import { DataMigrationParameters } from '../data-migration-parameters';
+export declare enum DataMigrationStatus {
+    'RUNNING' = 0,
+    'FINISHED' = 1
+}
+export interface DataMigrationInterface extends AnyClass {
+    start(register: Register): Promise<void>;
+}
+export interface DataMigrationMetadata {
+    readonly class: DataMigrationInterface;
+    migrationOptions: DataMigrationParameters;
+}
+export interface MagekDataMigrationEntityDuration {
+    start: string;
+    end?: string;
+    elapsedMilliseconds?: number;
+}

package/dist/concepts/data-migration.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataMigrationStatus = void 0;
+var DataMigrationStatus;
+(function (DataMigrationStatus) {
+    DataMigrationStatus[DataMigrationStatus["RUNNING"] = 0] = "RUNNING";
+    DataMigrationStatus[DataMigrationStatus["FINISHED"] = 1] = "FINISHED";
+})(DataMigrationStatus || (exports.DataMigrationStatus = DataMigrationStatus = {}));

package/dist/concepts/entity.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Holds information about a user class annotated with `@Entity`
+ */
+import { Class } from '../typelevel';
+import { EventStreamAuthorizer, UUID } from '.';
+export interface EntityInterface {
+    id: UUID;
+}
+export interface EntityMetadata {
+    readonly class: Class<EntityInterface>;
+    readonly eventStreamAuthorizer: EventStreamAuthorizer;
+}

package/dist/concepts/entity.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/concepts/event-handler.d.ts

@@ -0,0 +1,6 @@
+import { Register } from './register';
+import { EventInterface } from './event';
+import { NotificationInterface } from './notification';
+export interface EventHandlerInterface {
+    handle(event: EventInterface | NotificationInterface, register: Register): Promise<void>;
+}

package/dist/concepts/event-handler.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/concepts/event-stream-configuration.d.ts

@@ -0,0 +1,14 @@
+export type EventStreamConfiguration = {
+    enabled: true;
+    parameters: {
+        streamTopic: string;
+        partitionCount: number;
+        messageRetention: number;
+        dedupTtl?: number;
+        maxRetries?: number;
+        mode?: 'exponential' | 'fixed';
+    };
+} | {
+    enabled: false;
+    parameters?: never;
+};

package/dist/concepts/event-stream-configuration.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/concepts/event.d.ts

@@ -0,0 +1,12 @@
+import { UUID } from './uuid';
+import { Class } from '../typelevel';
+/**
+ * An `Event` is a fact that has happened in your system.
+ * All Event classes of your application must implement this interface.
+ */
+export interface EventInterface {
+    entityID: () => UUID;
+}
+export interface EventMetadata {
+    readonly class: Class<EventInterface>;
+}

package/dist/concepts/event.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/concepts/filter-hooks.d.ts

@@ -0,0 +1,15 @@
+import { QueryInput, ReadModelInterface } from '.';
+import { UserEnvelope, ReadModelRequestEnvelope } from '../envelope';
+import { CommandInput } from './command';
+export interface CommandFilterHooks {
+    readonly before?: Array<CommandBeforeFunction>;
+}
+export type CommandBeforeFunction = (input: CommandInput, currentUser?: UserEnvelope) => Promise<CommandInput>;
+export interface ReadModelFilterHooks<TReadModel extends ReadModelInterface = ReadModelInterface> {
+    readonly before?: Array<ReadModelBeforeFunction<TReadModel>>;
+}
+export type ReadModelBeforeFunction<TReadModel extends ReadModelInterface = ReadModelInterface> = (readModelRequestEnvelope: ReadModelRequestEnvelope<TReadModel>, currentUser?: UserEnvelope) => Promise<ReadModelRequestEnvelope<TReadModel>>;
+export interface QueryFilterHooks {
+    readonly before?: Array<QueryBeforeFunction>;
+}
+export type QueryBeforeFunction = (input: QueryInput, currentUser?: UserEnvelope) => Promise<QueryInput>;

package/dist/concepts/filter-hooks.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/concepts/global-error-handler-metadata.d.ts

@@ -0,0 +1,24 @@
+import { AnyClass } from '../typelevel';
+import { CommandEnvelope, EntitySnapshotEnvelope, EventEnvelope, NonPersistedEntitySnapshotEnvelope, QueryEnvelope, ScheduledCommandEnvelope } from '../envelope';
+import { EventInterface } from './event';
+import { ReadModelInterface } from './read-model';
+import { EntityInterface } from './entity';
+import { ReducerMetadata } from './reducer-metadata';
+import { ScheduledCommandMetadata } from './scheduled-command';
+import { CommandMetadata } from './command';
+import { ProjectionMetadata } from './projection-metadata';
+import { NotificationInterface } from './notification';
+export interface GlobalErrorHandlerInterface extends AnyClass {
+    onCommandHandlerError?(error: Error, commandEnvelope: CommandEnvelope, commandMetadata: CommandMetadata): Promise<Error | undefined>;
+    onQueryHandlerError?(error: Error, query: QueryEnvelope): Promise<Error | undefined>;
+    onScheduledCommandHandlerError?(error: Error, scheduledCommandEnvelope: ScheduledCommandEnvelope, scheduledCommandMetadata: ScheduledCommandMetadata): Promise<Error | undefined>;
+    onDispatchEventHandlerError?(error: Error, eventEnvelope: EventEnvelope | NotificationInterface, eventHandlerMetadata: unknown, eventInstance: EventInterface): Promise<Error | undefined>;
+    onReducerError?(error: Error, eventEnvelope: EventEnvelope, reducerMetadata: ReducerMetadata, eventInstance: EventInterface, snapshotInstance: EntityInterface | null): Promise<Error>;
+    onProjectionError?(error: Error, entityEnvelope: EntitySnapshotEnvelope, projectionMetadata: ProjectionMetadata<EntityInterface, ReadModelInterface>, entity: EntityInterface, readModel: ReadModelInterface | undefined): Promise<Error | undefined>;
+    onSnapshotPersistError?(error: Error, snapshot: NonPersistedEntitySnapshotEnvelope): Promise<Error | undefined>;
+    onEventError?(error: Error, eventEnvelope: EventEnvelope): Promise<Error | undefined>;
+    onError?(error: Error | undefined): Promise<Error | undefined>;
+}
+export interface GlobalErrorHandlerMetadata {
+    readonly class: GlobalErrorHandlerInterface;
+}

package/dist/concepts/global-error-handler-metadata.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/concepts/index.d.ts

@@ -0,0 +1,21 @@
+export * from './authorizers';
+export * from './command';
+export * from './query';
+export * from './data-migration';
+export * from './entity';
+export * from './event';
+export * from './event-handler';
+export * from './filter-hooks';
+export * from './global-error-handler-metadata';
+export * from './migration';
+export * from './notification';
+export * from './projection-metadata';
+export * from './read-model';
+export * from './reducer-metadata';
+export * from './register';
+export * from './role';
+export * from './scheduled-command';
+export * from './sequence-metadata';
+export * from './token-verifier';
+export * from './uuid';
+export * from './event-stream-configuration';

package/dist/concepts/index.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./authorizers"), exports);
+tslib_1.__exportStar(require("./command"), exports);
+tslib_1.__exportStar(require("./query"), exports);
+tslib_1.__exportStar(require("./data-migration"), exports);
+tslib_1.__exportStar(require("./entity"), exports);
+tslib_1.__exportStar(require("./event"), exports);
+tslib_1.__exportStar(require("./event-handler"), exports);
+tslib_1.__exportStar(require("./filter-hooks"), exports);
+tslib_1.__exportStar(require("./global-error-handler-metadata"), exports);
+tslib_1.__exportStar(require("./migration"), exports);
+tslib_1.__exportStar(require("./notification"), exports);
+tslib_1.__exportStar(require("./projection-metadata"), exports);
+tslib_1.__exportStar(require("./read-model"), exports);
+tslib_1.__exportStar(require("./reducer-metadata"), exports);
+tslib_1.__exportStar(require("./register"), exports);
+tslib_1.__exportStar(require("./role"), exports);
+tslib_1.__exportStar(require("./scheduled-command"), exports);
+tslib_1.__exportStar(require("./sequence-metadata"), exports);
+tslib_1.__exportStar(require("./token-verifier"), exports);
+tslib_1.__exportStar(require("./uuid"), exports);
+tslib_1.__exportStar(require("./event-stream-configuration"), exports);

package/dist/concepts/migration.d.ts

@@ -0,0 +1,8 @@
+import { AnyClass } from '../typelevel';
+export interface SchemaMigrationMetadata {
+    migrationClass: AnyClass;
+    methodName: string;
+    toVersion: number;
+    fromSchema: AnyClass;
+    toSchema: AnyClass;
+}

package/dist/concepts/migration.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/concepts/notification.d.ts

@@ -0,0 +1,12 @@
+import { Class } from '../typelevel';
+/**
+ * All Notification classes of your application must implement this interface.
+ */
+export type NotificationInterface = {
+    partitionId?: string;
+    topic?: string;
+    [key: string]: any;
+};
+export interface NotificationMetadata {
+    readonly class: Class<NotificationInterface>;
+}

package/dist/concepts/notification.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/concepts/projection-metadata.d.ts

@@ -0,0 +1,15 @@
+import { AnyClass } from '../typelevel';
+import { ReadModelInterface } from './read-model';
+import { EntityInterface } from './entity';
+import { FilterFor } from '../searcher';
+export type ReadModelJoinKeyFunction<TEntity extends EntityInterface, TReadModel extends ReadModelInterface> = (entity: TEntity) => FilterFor<TReadModel> | undefined;
+export interface ProjectionMetadata<TEntity extends EntityInterface, TReadModel extends ReadModelInterface> {
+    class: AnyClass;
+    methodName: string;
+    joinKey: keyof TEntity | ReadModelJoinKeyFunction<TEntity, TReadModel>;
+}
+export type ProjectionResult<TReadModel> = TReadModel | ReadModelAction;
+export declare enum ReadModelAction {
+    Delete = 0,
+    Nothing = 1
+}

package/dist/concepts/projection-metadata.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReadModelAction = void 0;
+var ReadModelAction;
+(function (ReadModelAction) {
+    ReadModelAction[ReadModelAction["Delete"] = 0] = "Delete";
+    ReadModelAction[ReadModelAction["Nothing"] = 1] = "Nothing";
+})(ReadModelAction || (exports.ReadModelAction = ReadModelAction = {}));

package/dist/concepts/query.d.ts

@@ -0,0 +1,21 @@
+import { Class } from '../typelevel';
+import { PropertyMetadata } from '../metadata-types';
+import { QueryAuthorizer, QueryFilterHooks, UUID } from './.';
+import { ContextEnvelope, UserEnvelope } from '../envelope';
+export type QueryInput = Record<string, any>;
+export interface QueryInterface<TQuery = unknown, THandleResult = unknown> extends Class<TQuery> {
+    handle(query: TQuery, queryInfo?: QueryInfo): Promise<THandleResult>;
+}
+export interface QueryMetadata<TCommand = unknown> {
+    readonly class: QueryInterface<TCommand>;
+    readonly properties: Array<PropertyMetadata>;
+    readonly methods: Array<PropertyMetadata>;
+    readonly authorizer: QueryAuthorizer;
+    readonly before: NonNullable<QueryFilterHooks['before']>;
+}
+export interface QueryInfo {
+    requestID: UUID;
+    responseHeaders: Record<string, string>;
+    currentUser?: UserEnvelope;
+    context?: ContextEnvelope;
+}

package/dist/concepts/query.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/concepts/read-model.d.ts

@@ -0,0 +1,33 @@
+import { ReadModelAuthorizer, ReadModelFilterHooks, UUID } from '.';
+import { Class } from '../typelevel';
+import { PropertyMetadata } from '../metadata-types';
+export interface MagekMetadata {
+    version: number;
+    schemaVersion: number;
+    optimisticConcurrencyValue?: string | number;
+    lastUpdateAt?: string;
+    lastProjectionInfo?: {
+        entityId: string;
+        entityName: string;
+        entityUpdatedAt: string;
+        projectionMethod: string;
+    };
+}
+export interface ReadModelInterface {
+    id: UUID;
+    magekMetadata?: MagekMetadata;
+    [key: string]: any;
+}
+export interface ReadModelMetadata<TReadModel extends ReadModelInterface = ReadModelInterface> {
+    readonly class: Class<ReadModelInterface>;
+    readonly properties: Array<PropertyMetadata>;
+    readonly authorizer: ReadModelAuthorizer;
+    readonly before: NonNullable<ReadModelFilterHooks<TReadModel>['before']>;
+}
+export declare enum ProjectionInfoReason {
+    ENTITY_PROJECTED = 0,
+    ENTITY_DELETED = 1
+}
+export interface ProjectionInfo {
+    reason: ProjectionInfoReason;
+}

package/dist/concepts/read-model.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectionInfoReason = void 0;
+var ProjectionInfoReason;
+(function (ProjectionInfoReason) {
+    ProjectionInfoReason[ProjectionInfoReason["ENTITY_PROJECTED"] = 0] = "ENTITY_PROJECTED";
+    ProjectionInfoReason[ProjectionInfoReason["ENTITY_DELETED"] = 1] = "ENTITY_DELETED";
+})(ProjectionInfoReason || (exports.ProjectionInfoReason = ProjectionInfoReason = {}));

package/dist/concepts/reducer-metadata.d.ts

@@ -0,0 +1,5 @@
+import { AnyClass } from '..';
+export interface ReducerMetadata {
+    class: AnyClass;
+    methodName: string;
+}

package/dist/concepts/reducer-metadata.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/concepts/register.d.ts

@@ -0,0 +1,91 @@
+import { EventInterface } from './event';
+import { UserEnvelope, ContextEnvelope } from '../envelope';
+import { UUID } from './uuid';
+import { NotificationInterface } from './notification';
+export type FlusherFunction = (record: Register) => Promise<void>;
+/**
+ * Object injected by Magek in all command or event handlers to interact with the execution
+ * context. By default, the events registered won't be stored until the handler has finished,
+ * but you can force the storage by calling the `register.flush()` method.
+ *
+ * Example:
+ * ```typescript
+ *  public handle(register: Register): void {
+ *    //...
+ *    register.events(new CartItemChanged(cart, this.sku, this.quantity))
+ *    if (this.hasPromotion()) {
+ *      if (this.isEmpty()) {
+ *        throw new Error("Added a promotion to an empty cart")
+ *      } else {
+ *        register.commands(new ApplyPromoToCart(this.promo, cart)
+ *      }
+ *    }
+ *    // ...
+ *  }
+ * ```
+ */
+export declare class Register {
+    /** Unique request identifier. This identifier is propagated automatically by Magek
+     * to all the events generated during a request, as well as all subsequent events
+     * generated by event handlers. This identifier can be used as a correlation
+     * identifier to build the event tree coming from a single request. */
+    readonly requestID: UUID;
+    /** In the context of a command handler, the `responseHeaders` object contains the headers
+     * that will be returned to the client in the response. You can use this object to set
+     * custom headers or alter the default ones. */
+    readonly responseHeaders: Record<string, string>;
+    /** Private flusher function that will be called when the flush method is called. This property
+     * is reserved to be used internally by Magek. */
+    private flusher;
+    /** Object that references the current user. This property is initialized by Magek in a command,
+     * and in the same way as the `requestID` property, it is propagated to all the events generated
+     * afterwards. */
+    readonly currentUser?: UserEnvelope | undefined;
+    /** In the context of a command handler, the `context` object contains the context of the request. */
+    readonly context?: ContextEnvelope | undefined;
+    readonly eventList: Array<EventInterface | NotificationInterface>;
+    /**
+     * Creates a new instance of Register
+     *
+     * @param {UUID} requestID - The ID of the current request
+     * @param {Record<string, string>} responseHeaders - The response headers object. It can be changed by the user.
+     * @param {FlusherFunction} flusher - The provider-dependent function used to flush the events to the event store.
+     * @param {UserEnvelope} [currentUser] - The current user envelope, if available
+     * @param {ContextEnvelope} [context] - The current context envelope, if available
+     */
+    constructor(
+    /** Unique request identifier. This identifier is propagated automatically by Magek
+     * to all the events generated during a request, as well as all subsequent events
+     * generated by event handlers. This identifier can be used as a correlation
+     * identifier to build the event tree coming from a single request. */
+    requestID: UUID, 
+    /** In the context of a command handler, the `responseHeaders` object contains the headers
+     * that will be returned to the client in the response. You can use this object to set
+     * custom headers or alter the default ones. */
+    responseHeaders: Record<string, string>, 
+    /** Private flusher function that will be called when the flush method is called. This property
+     * is reserved to be used internally by Magek. */
+    flusher: FlusherFunction, 
+    /** Object that references the current user. This property is initialized by Magek in a command,
+     * and in the same way as the `requestID` property, it is propagated to all the events generated
+     * afterwards. */
+    currentUser?: UserEnvelope | undefined, 
+    /** In the context of a command handler, the `context` object contains the context of the request. */
+    context?: ContextEnvelope | undefined);
+    /**
+     * Register a list of events to be added to the event-store on handler completion
+     *
+     * @param {...Array<EventInterface|NotificationInterface>} events - The events to register
+     * @returns {Register} The current Register instance, so the calls to events and/or flush can be chained.
+     */
+    events(...events: Array<EventInterface | NotificationInterface>): Register;
+    /**
+     * Flushes the accumulated events and commands to the event store using the provider-depdent flusher function.
+     * This method can be called from a command or event handler to force the persistion of the events
+     * to the event store. After the events have been flushed, the eventList is cleared, so the same
+     * register instance can be used to register more events.
+     *
+     * @returns {Promise<void>} A Promise that resolves when the flush operation is complete
+     */
+    flush(): Promise<void>;
+}

package/dist/concepts/register.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Register = void 0;
+/**
+ * Object injected by Magek in all command or event handlers to interact with the execution
+ * context. By default, the events registered won't be stored until the handler has finished,
+ * but you can force the storage by calling the `register.flush()` method.
+ *
+ * Example:
+ * ```typescript
+ *  public handle(register: Register): void {
+ *    //...
+ *    register.events(new CartItemChanged(cart, this.sku, this.quantity))
+ *    if (this.hasPromotion()) {
+ *      if (this.isEmpty()) {
+ *        throw new Error("Added a promotion to an empty cart")
+ *      } else {
+ *        register.commands(new ApplyPromoToCart(this.promo, cart)
+ *      }
+ *    }
+ *    // ...
+ *  }
+ * ```
+ */
+class Register {
+    /**
+     * Creates a new instance of Register
+     *
+     * @param {UUID} requestID - The ID of the current request
+     * @param {Record<string, string>} responseHeaders - The response headers object. It can be changed by the user.
+     * @param {FlusherFunction} flusher - The provider-dependent function used to flush the events to the event store.
+     * @param {UserEnvelope} [currentUser] - The current user envelope, if available
+     * @param {ContextEnvelope} [context] - The current context envelope, if available
+     */
+    constructor(
+    /** Unique request identifier. This identifier is propagated automatically by Magek
+     * to all the events generated during a request, as well as all subsequent events
+     * generated by event handlers. This identifier can be used as a correlation
+     * identifier to build the event tree coming from a single request. */
+    requestID, 
+    /** In the context of a command handler, the `responseHeaders` object contains the headers
+     * that will be returned to the client in the response. You can use this object to set
+     * custom headers or alter the default ones. */
+    responseHeaders, 
+    /** Private flusher function that will be called when the flush method is called. This property
+     * is reserved to be used internally by Magek. */
+    flusher, 
+    /** Object that references the current user. This property is initialized by Magek in a command,
+     * and in the same way as the `requestID` property, it is propagated to all the events generated
+     * afterwards. */
+    currentUser, 
+    /** In the context of a command handler, the `context` object contains the context of the request. */
+    context) {
+        this.requestID = requestID;
+        this.responseHeaders = responseHeaders;
+        this.flusher = flusher;
+        this.currentUser = currentUser;
+        this.context = context;
+        this.eventList = [];
+    }
+    /**
+     * Register a list of events to be added to the event-store on handler completion
+     *
+     * @param {...Array<EventInterface|NotificationInterface>} events - The events to register
+     * @returns {Register} The current Register instance, so the calls to events and/or flush can be chained.
+     */
+    events(...events) {
+        this.eventList.push(...events);
+        return this;
+    }
+    /**
+     * Flushes the accumulated events and commands to the event store using the provider-depdent flusher function.
+     * This method can be called from a command or event handler to force the persistion of the events
+     * to the event store. After the events have been flushed, the eventList is cleared, so the same
+     * register instance can be used to register more events.
+     *
+     * @returns {Promise<void>} A Promise that resolves when the flush operation is complete
+     */
+    async flush() {
+        await this.flusher(this);
+        this.eventList.length = 0;
+    }
+}
+exports.Register = Register;

package/dist/concepts/role.d.ts

@@ -0,0 +1,27 @@
+import { Class } from '../typelevel';
+import { CommandAuthorizer, EventStreamAuthorizer, HealthAuthorizer, QueryAuthorizer, ReadModelAuthorizer } from './authorizers';
+export interface RoleInterface {
+}
+export interface RoleMetadata {
+    readonly auth: AuthMetadata;
+}
+export type SignUpMethod = 'email' | 'phone';
+export interface AuthMetadata {
+    readonly signUpMethods?: Array<SignUpMethod>;
+    readonly skipConfirmation?: boolean;
+}
+export interface CommandRoleAccess {
+    readonly authorize?: 'all' | Array<Class<RoleInterface>> | CommandAuthorizer;
+}
+export interface QueryRoleAccess {
+    readonly authorize?: 'all' | Array<Class<RoleInterface>> | QueryAuthorizer;
+}
+export interface HealthRoleAccess {
+    authorize?: 'all' | Array<Class<RoleInterface>> | HealthAuthorizer;
+}
+export interface ReadModelRoleAccess {
+    readonly authorize?: 'all' | Array<Class<RoleInterface>> | ReadModelAuthorizer;
+}
+export interface EventStreamRoleAccess {
+    readonly authorizeReadEvents: 'all' | Array<Class<RoleInterface>> | EventStreamAuthorizer;
+}

package/dist/concepts/role.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/concepts/scheduled-command.d.ts

@@ -0,0 +1,10 @@
+import { AnyClass } from '../typelevel';
+import { ScheduleInterface } from '../schedule';
+import { Register } from './register';
+export interface ScheduledCommandInterface extends AnyClass {
+    handle(register: Register): Promise<void>;
+}
+export interface ScheduledCommandMetadata {
+    readonly class: ScheduledCommandInterface;
+    readonly scheduledOn: ScheduleInterface;
+}

package/dist/concepts/scheduled-command.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/concepts/sequence-metadata.d.ts

@@ -0,0 +1,5 @@
+import { TimeKey } from './uuid';
+export interface SequenceKey {
+    name: string;
+    value: TimeKey;
+}

package/dist/concepts/sequence-metadata.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });