@jokio/datastore/dist/db-aggregate.d.ts

Helper library for Google Cloud Datastore

/// <reference types="google-cloud__datastore" />
import * as Datastore from '@google-cloud/datastore';
import { QueryOptions, QueryInfo } from '@google-cloud/datastore/query';
import { DatastoreTransaction } from '@google-cloud/datastore/transaction';
import { Entity } from './types';
import { ProcessDbTransaction } from './db-transaction';
import { QueryProcessor } from './db-set-base';
import { Event } from './event';
export declare type DomainEventAction<TData> = (data: TData) => Promise<void>;
export declare class DomainEvent<TData> extends Event<DomainEventData<TData>> {
}
export declare abstract class AggregateRoot<TState extends Entity> {
    private kind;
    private datastore;
    protected parentTransaction: DatastoreTransaction;
    protected state: TState;
    private db;
    protected aggregates: {
        [key: string]: Aggregate<any>;
    };
    private doTransaction;
    constructor(kind: string, datastore: Datastore, parentTransaction?: DatastoreTransaction);
    load(id: any): Promise<TState>;
    protected stateLoaded(state: TState): void;
    protected save<T>(Event: DomainEvent<T>, data: T): Promise<TState>;
    query(queryProcessor?: QueryProcessor, options?: QueryOptions): Promise<TState[]>;
    queryWithMetadata(queryProcessor?: QueryProcessor, options?: QueryOptions): Promise<{
        result: TState[];
        queryInfo: QueryInfo;
    }>;
    protected transaction(process: ProcessDbTransaction<TState>): Promise<void>;
    private updateToAggregateStates();
    private updateFromAggregateStates();
}
export declare abstract class Aggregate<TState> {
    abstract defaultState: TState;
    private _state;
    state: TState;
    constructor();
}
export declare class AggregateRootResolver {
    private datastore;
    constructor(datastore: Datastore);
    get<T>(aggregateType: AggregateConstructor<T>, transaction?: DatastoreTransaction): T;
}
export interface AggregateConstructor<T> {
    new (datastore: Datastore, transaction?: DatastoreTransaction): T;
}
export interface DomainEventData<TData> {
    transaction: DatastoreTransaction;
    data: TData;
}