hydrate-mongodb/session.d.ts

An Object Document Mapper (ODM) for MongoDB.

/// <reference types="node" />
import { EventEmitter } from "events";
import { Callback } from "./core/callback";
import { Constructor } from "./index";
import { ResultCallback } from "./core/callback";
import { InternalSessionFactory, SessionFactory } from "./sessionFactory";
import { Persister } from "./persister";
import { EntityMapping } from "./mapping/entityMapping";
import { QueryBuilder, FindOneQuery } from "./query/queryBuilder";
import { QueryDefinition } from "./query/queryDefinition";
export interface Session {
    factory: SessionFactory;
    save(obj: Object, callback?: Callback): void;
    remove(obj: Object, callback?: Callback): void;
    detach(obj: Object, callback?: Callback): void;
    refresh(obj: Object, callback: Callback): void;
    flush(callback?: Callback): void;
    clear(callback?: Callback): void;
    find<T>(ctr: Constructor<T>, id: any, callback?: ResultCallback<T>): FindOneQuery<T>;
    exists<T>(ctr: Constructor<T>, id: any, callback: ResultCallback<boolean>): void;
    getReference<T>(ctr: Constructor<T>, id: any): T;
    fetch<T>(obj: T, callback?: ResultCallback<T>): void;
    fetch<T>(obj: T, path: string | string[], callback?: ResultCallback<T>): void;
    query<T>(ctr: Constructor<T>): QueryBuilder<T>;
    wait(callback?: Callback): void;
    close(callback?: Callback): void;
    contains(obj: Object): boolean;
    toDocument(obj: Object, callback?: ResultCallback<Object>): Object;
    isDirty(obj: Object, callback?: ResultCallback<boolean>): boolean;
    getVersion(obj: Object): number;
    getEntities(): Object[];
    on(event: string, listener: Function): EventEmitter;
}
export interface InternalSession extends Session {
    factory: InternalSessionFactory;
    getObject(id: any): any;
    registerManaged(persister: Persister, entity: Object, document: any): void;
    notifyRemoved(entity: Object): void;
    getPersister(mapping: EntityMapping): Persister;
    getReferenceInternal(mapping: EntityMapping, id: any): any;
    fetchInternal(entity: Object, paths: string[], callback: ResultCallback<any>): void;
    executeQuery(query: QueryDefinition, callback: ResultCallback<any>): void;
}
export declare class SessionImpl extends EventEmitter implements InternalSession {
    factory: InternalSessionFactory;
    private _persisters;
    private _objectLinksById;
    private _objectLinks;
    private _scheduleHead;
    private _scheduleTail;
    private _queue;
    private _traceEnabled;
    constructor(factory: InternalSessionFactory);
    save(obj: any, callback?: Callback): void;
    remove(obj: any, callback?: Callback): void;
    refresh(obj: any, callback?: Callback): void;
    detach(obj: any, callback?: Callback): void;
    clear(callback?: Callback): void;
    flush(callback?: Callback): void;
    wait(callback?: Callback): void;
    find<T>(ctr: Constructor<T>, id: any, callback?: ResultCallback<T>): FindOneQuery<T>;
    exists<T>(ctr: Constructor<T>, id: any, callback: ResultCallback<boolean>): void;
    fetch<T>(obj: T, pathsOrCallback: any, callback?: ResultCallback<T>): void;
    close(callback?: Callback): void;
    executeQuery(query: QueryDefinition, callback: ResultCallback<any>): void;
    contains(obj: any): boolean;
    getEntities(): Object[];
    getReference<T>(ctr: Constructor<T>, id: any): T;
    toDocument(obj: Object, callback?: ResultCallback<Object>): Object;
    isDirty(obj: Object, callback?: ResultCallback<boolean>): boolean;
    getVersion(obj: Object): number;
    getReferenceInternal(mapping: EntityMapping, id: any): any;
    getObject(id: any): any;
    registerManaged(persister: Persister, entity: any, document: any): void;
    private _trackChanges(links);
    private _stopWatching(links);
    getPersister(mapping: EntityMapping): Persister;
    query<T>(ctr: Constructor<T>): QueryBuilder<T>;
    private _execute(action, arg, callback);
    private _save(obj, callback);
    private _saveEntities(entities, callback);
    private _makeDirty(links);
    private _clearDirty(links);
    notifyRemoved(entity: Object): void;
    private _remove(obj, callback);
    private _removeEntities(entities, callback);
    private _removeEntity(obj, scheduleDelete);
    private _detach(obj, callback);
    private _detachEntities(entities, callback);
    private _refresh(obj, callback);
    private _refreshEntities(entities, callback);
    private _flush(callback);
    private _buildBatch(batch, links, callback);
    private _batchCompleted(head, duration, callback);
    private _logFlushStats(head, duration);
    private _close(callback);
    fetchInternal(obj: any, paths: string[], callback: ResultCallback<any>): void;
    private _fetchPaths(obj, paths, callback);
    private _clear(callback);
    private _getObjectLinks(obj);
    private _linkObject(obj, persister);
    private _unlinkObject(links);
    private _cleanupUnlinkedObject(links);
    private _scheduleOperation(links, operation);
    private _clearScheduledOperation(links);
    private _clearIdentifier(links);
    private _findReferencedEntities(obj, flags, callback);
    private _walk(mapping, entity, flags, entities, embedded, callback);
    private _createTaskQueue();
}