@syncable/server/bld/library/server/server.d.ts

Syncable.

/// <reference types="node" />
import { EventEmitter } from 'events';
import { ChangePlantBlueprint, ChangePlantProcessingResultWithClock, IChangePlantBlueprintGenericParams, IContext, IRPCDefinition, ISyncable, ISyncableAdapter, ISyncableObject, IViewQuery, RefDictToSyncableObjectDict, ViewQueryFilter, ViewQueryUpdateObject } from '@syncable/core';
import { Dict, OmitValueOfKey } from 'tslang';
import { IServerAdapter } from './server-adapter';
export interface LoadOptions {
    context?: IContext;
    loadRequisiteDependencyOnly?: boolean;
}
export interface LoadSyncablesByRefsOptions {
    loadedKeySet?: Set<string>;
    changeType?: string;
    loadRequisiteDependencyOnly?: boolean;
    skipReadableFilter?: boolean;
}
export interface LoadDependentSyncablesOptions {
    loadedKeySet?: Set<string>;
    changeType?: string;
    requisiteOnly?: boolean;
    skipReadableFilter?: boolean;
}
export interface IServerGenericParams extends IChangePlantBlueprintGenericParams {
    syncableObject: ISyncableObject;
    viewQueryDict: object;
    customClientRPCDefinition: IRPCDefinition;
}
export declare type SyncableTypeToSyncableObjectsDict<TSyncableObject extends ISyncableObject> = {
    [TKey in TSyncableObject['ref']['type']]?: Extract<TSyncableObject, {
        ref: {
            type: TKey;
        };
    }>[];
};
export interface ViewQueryInfo {
    filter: ViewQueryFilter;
    query: IViewQuery;
}
export interface ServerApplyChangeResult extends OmitValueOfKey<ChangePlantProcessingResultWithClock, 'changes'> {
    subsequent?: Promise<ServerApplyChangeResult>[];
}
export declare class Server<TGenericParams extends IServerGenericParams> extends EventEmitter {
    private context;
    private serverAdapter;
    private syncableAdapter;
    private groupToConnectionSetMap;
    private changePlant;
    constructor(
    /**
     * Non-user context for server-side initiated changes.
     */
    context: TGenericParams['context'], serverAdapter: IServerAdapter<TGenericParams>, syncableAdapter: ISyncableAdapter<TGenericParams>, blueprint: ChangePlantBlueprint<TGenericParams>);
    load<TRefDict extends object>(group: string, refDict: TRefDict, { context, loadRequisiteDependencyOnly, }?: LoadOptions): Promise<RefDictToSyncableObjectDict<TRefDict>>;
    query(group: string, update: ViewQueryUpdateObject<TGenericParams['viewQueryDict']>): Promise<SyncableTypeToSyncableObjectsDict<TGenericParams['syncableObject']>>;
    applyChange(group: string, change: TGenericParams['change'], context?: IContext<ISyncableObject<ISyncable<string>>, Dict<unknown>>): Promise<ServerApplyChangeResult>;
    protected log(event: string, data: object): void;
    private onConnection;
    private onBroadcast;
    private addConnection;
    private removeConnection;
    private broadcastChangeResult;
}