mongodb-livedata-server 0.0.4 → 0.0.6

package/dist/meteor/id-map/id_map.d.ts

@@ -0,0 +1,16 @@
+export declare class IdMap {
+    private _map;
+    private _idStringify;
+    private _idParse;
+    constructor(idStringify?: (obj: any) => string, idParse?: (str: string) => any);
+    get(id: any): any;
+    set(id: any, value: any): void;
+    remove(id: any): void;
+    has(id: any): boolean;
+    empty(): boolean;
+    clear(): void;
+    forEach(iterator: any): void;
+    size(): number;
+    setDefault(id: any, def: any): any;
+    clone(): IdMap;
+}

package/dist/meteor/mongo/caching_change_observer.d.ts

@@ -0,0 +1,16 @@
+import { OrderedDict } from "../ordered-dict/ordered_dict";
+export declare class _CachingChangeObserver {
+    docs: OrderedDict | Map<string, any>;
+    applyChange: {
+        added?: (id: string, fields: any) => void;
+        changed?: (id: string, fields: any) => void;
+        removed?: (id: string) => void;
+        addedBefore?: (id: string, fields: any, before: any) => void;
+        movedBefore?: (id: string, before: any) => void;
+    };
+    private ordered;
+    constructor(options?: {
+        callbacks?: any;
+        ordered?: boolean;
+    });
+}

package/dist/meteor/mongo/doc_fetcher.d.ts

@@ -0,0 +1,7 @@
+import MongoDB from "mongodb";
+export declare class DocFetcher {
+    private db;
+    private _callbacksForOp;
+    constructor(db: MongoDB.Db);
+    fetch(collectionName: string, id: string, op: Object, callback: Function): Promise<void>;
+}

package/dist/meteor/mongo/geojson_utils.d.ts

@@ -0,0 +1,3 @@
+export declare function numberToRadius(number: any): number;
+export declare function pointDistance(pt1: any, pt2: any): number;
+export declare function geometryWithinRadius(geometry: any, center: any, radius: any): boolean;

package/dist/meteor/mongo/live_connection.d.ts

@@ -0,0 +1,27 @@
+import { Db } from "mongodb";
+import { CursorDescription } from "./live_cursor";
+import { OplogHandle } from "./oplog_tailing";
+import { DocFetcher } from "./doc_fetcher";
+export declare class LiveMongoConnection {
+    private client;
+    db: Db;
+    _oplogHandle: OplogHandle;
+    _docFetcher: DocFetcher;
+    private _observeMultiplexers;
+    private _onFailoverHook;
+    constructor(url: string, options?: any);
+    close(): void;
+    tail<T>(cursorDescription: CursorDescription<T>, docCallback: (doc: T) => void, timeoutMS?: number): {
+        stop: () => void;
+    };
+    _observeChanges(cursorDescription: CursorDescription<any>, ordered: boolean, callbacks: any, nonMutatingCallbacks: boolean): {
+        stop: () => void;
+    };
+    _observeChangesTailable(cursorDescription: CursorDescription<any>, ordered: boolean, callbacks: any): {
+        stop: () => void;
+    };
+    _onFailover(callback: Function): {
+        callback: any;
+        stop: () => void;
+    };
+}

package/dist/meteor/mongo/live_cursor.d.ts

@@ -0,0 +1,25 @@
+import { Subscription } from "../ddp/subscription";
+import MongoDB, { WithId } from "mongodb";
+import { LiveMongoConnection } from "./live_connection";
+interface CustomFindOptions<T> extends MongoDB.FindOptions<WithId<T>> {
+    pollingThrottleMs?: number;
+    pollingIntervalMs?: number;
+    transform?: (doc: T) => T;
+    maxTimeMs?: number;
+    disableOplog?: boolean;
+}
+export declare class CursorDescription<T> {
+    collectionName: string;
+    selector: MongoDB.Filter<WithId<T>>;
+    options: CustomFindOptions<WithId<T>>;
+    constructor(collectionName: string, selector: MongoDB.Filter<WithId<T>>, options?: CustomFindOptions<WithId<T>>);
+}
+export declare class LiveCursor<T> {
+    mongo: LiveMongoConnection;
+    cursorDescription: CursorDescription<T>;
+    constructor(mongo: LiveMongoConnection, collectionName: string, selector: MongoDB.Filter<WithId<T>>, options: CustomFindOptions<WithId<T>>);
+    _publishCursor(sub: Subscription): {
+        stop: () => void;
+    };
+}
+export {};

package/dist/meteor/mongo/minimongo_common.d.ts

@@ -0,0 +1,84 @@
+export declare const hasOwn: (v: PropertyKey) => boolean;
+export declare const ELEMENT_OPERATORS: {
+    $lt: {
+        compileElementSelector(operand: any): (value: any) => any;
+    };
+    $gt: {
+        compileElementSelector(operand: any): (value: any) => any;
+    };
+    $lte: {
+        compileElementSelector(operand: any): (value: any) => any;
+    };
+    $gte: {
+        compileElementSelector(operand: any): (value: any) => any;
+    };
+    $mod: {
+        compileElementSelector(operand: any): (value: any) => boolean;
+    };
+    $in: {
+        compileElementSelector(operand: any): (value: any) => boolean;
+    };
+    $size: {
+        dontExpandLeafArrays: boolean;
+        compileElementSelector(operand: any): (value: any) => boolean;
+    };
+    $type: {
+        dontIncludeLeafArrays: boolean;
+        compileElementSelector(operand: any): (value: any) => boolean;
+    };
+    $bitsAllSet: {
+        compileElementSelector(operand: any): (value: any) => boolean;
+    };
+    $bitsAnySet: {
+        compileElementSelector(operand: any): (value: any) => boolean;
+    };
+    $bitsAllClear: {
+        compileElementSelector(operand: any): (value: any) => boolean;
+    };
+    $bitsAnyClear: {
+        compileElementSelector(operand: any): (value: any) => boolean;
+    };
+    $regex: {
+        compileElementSelector(operand: any, valueSelector: any): (value: any) => any;
+    };
+    $elemMatch: {
+        dontExpandLeafArrays: boolean;
+        compileElementSelector(operand: any, valueSelector: any, matcher: any): (value: any) => number | false;
+    };
+};
+export declare function compileDocumentSelector(docSelector: any, matcher: any, options?: {
+    isRoot?: boolean;
+    inElemMatch?: boolean;
+}): any;
+export declare function equalityElementMatcher(elementSelector: any): (value: any) => any;
+export declare function expandArraysInBranches(branches: any, skipTheArrays?: boolean): any[];
+export declare function isIndexable(obj: any): boolean;
+export declare function isNumericKey(s: any): boolean;
+export declare function isOperatorObject(valueSelector: any, inconsistentOK?: any): boolean;
+export declare function makeLookupFunction(key: any, options?: {
+    forSort?: boolean;
+}): (doc: any, arrayIndices?: any[]) => any[];
+export declare function nothingMatcher(docOrBranchedValues: any): {
+    result: boolean;
+};
+export declare function pathsToTree(paths: any, newLeafFn: any, conflictFn: any, root?: {}): {};
+export declare function populateDocumentWithQueryFields(query: any, document?: {}): {};
+export declare function projectionDetails(fields: any): {
+    including: any;
+    tree: {};
+};
+export declare function regexpElementMatcher(regexp: any): (value: any) => any;
+export declare const _f: {
+    _type(v: any): 1 | 2 | 3 | 4 | 5 | 7 | 8 | 9 | 10 | 11 | 13;
+    _equal(a: any, b: any): any;
+    _typeorder(t: any): number;
+    _cmp(a: any, b: any): any;
+};
+export declare function _checkSupportedProjection(fields: any): void;
+export declare function _modify(doc: any, modifier: any, options?: {
+    isInsert?: boolean;
+    arrayIndices?: number[];
+}): void;
+export declare function combineImportantPathsIntoProjection(paths: any, projection: any): {};
+export declare function _pathsElidingNumericKeys(paths: any): any;
+export declare function _compileProjection(fields: any): (doc: any) => any;

package/dist/meteor/mongo/minimongo_matcher.d.ts

@@ -0,0 +1,22 @@
+import { Filter } from 'mongodb';
+export declare class MinimongoMatcher {
+    private _paths;
+    private _hasGeoQuery;
+    private _hasWhere;
+    private _isSimple;
+    private _matchingDocument;
+    private _selector;
+    private _docMatcher;
+    private _isUpdate;
+    constructor(selector: Filter<any>, isUpdate?: boolean);
+    documentMatches(doc: any): any;
+    hasGeoQuery(): boolean;
+    hasWhere(): boolean;
+    isSimple(): boolean;
+    _compileSelector(selector: Filter<any>): any;
+    affectedByModifier(modifier: any): boolean;
+    canBecomeTrueByModifier: (modifier: any) => any;
+    combineIntoProjection(projection: any): {};
+    _getPaths(): string[];
+    _recordPathUsed(path: any): void;
+}

package/dist/meteor/mongo/minimongo_sorter.d.ts

@@ -0,0 +1,16 @@
+export default class MinimongoSorter {
+    private _sortSpecParts;
+    private _sortFunction;
+    private _keyComparator;
+    private _selectorForAffectedByModifier;
+    constructor(spec: any);
+    affectedByModifier(modifier: any): boolean;
+    getComparator(options?: any): (a: any, b: any) => number;
+    _compareKeys(key1: any, key2: any): number;
+    _generateKeysFromDoc(doc: any, cb: any): void;
+    _getBaseComparator(): (a: any, b: any) => number;
+    _getMinKeyFromDoc(doc: any): any;
+    _getPaths(): string[];
+    _keyFieldComparator(i: number): (key1: any, key2: any) => any;
+    combineIntoProjection: (projection: any) => {};
+}

package/dist/meteor/mongo/observe_driver_utils.d.ts

@@ -0,0 +1,9 @@
+import MongoDB from "mongodb";
+import { CursorDescription } from "./live_cursor";
+export declare function listenAll(cursorDescription: CursorDescription<any>, listenCallback: Function): {
+    stop: () => void;
+};
+export declare function forEachTrigger(cursorDescription: CursorDescription<any>, triggerCallback: Function): void;
+export declare function _idsMatchedBySelector(selector: MongoDB.Filter<{
+    _id: string;
+}>): any;

package/dist/meteor/mongo/observe_multiplexer.d.ts

@@ -0,0 +1,36 @@
+export declare class ObserveMultiplexer {
+    private _ordered;
+    private _onStop;
+    private _queue;
+    private _handles;
+    private _readyFuture;
+    private _cache;
+    private _addHandleTasksScheduledButNotPerformed;
+    added: (id: string, fields: Record<string, any>) => void;
+    changed: (id: string, fields: Record<string, any>) => void;
+    removed: (id: string) => void;
+    constructor(options: any);
+    addHandleAndSendInitialAdds(handle: ObserveHandle): Promise<void>;
+    removeHandle(id: number): void;
+    _stop(options?: any): void;
+    ready(): void;
+    queryError(err: Error): void;
+    onFlush(cb: any): void;
+    callbackNames(): string[];
+    _ready(): boolean;
+    _applyCallback(callbackName: string, args: any): void;
+    _sendAdds(handle: ObserveHandle): void;
+}
+export declare class ObserveHandle {
+    private _multiplexer;
+    nonMutatingCallbacks: boolean;
+    _id: number;
+    _addedBefore: Function;
+    _movedBefore: Function;
+    _added: Function;
+    _changed: Function;
+    _removed: Function;
+    private _stopped;
+    constructor(_multiplexer: ObserveMultiplexer, callbacks: Record<string, Function>, nonMutatingCallbacks?: boolean);
+    stop(): void;
+}

package/dist/meteor/mongo/oplog-observe-driver.d.ts

@@ -0,0 +1,67 @@
+import { LiveMongoConnection } from "./live_connection";
+import { MinimongoMatcher } from "./minimongo_matcher";
+import MinimongoSorter from "./minimongo_sorter";
+import { ObserveMultiplexer } from "./observe_multiplexer";
+import { CursorDescription } from "./live_cursor";
+import { IdMap } from "../id-map/id_map";
+import { SynchronousCursor } from "./synchronous-cursor";
+interface OplogObserveDriverOptions {
+    cursorDescription: CursorDescription<any>;
+    mongoHandle: LiveMongoConnection;
+    ordered: boolean;
+    multiplexer: ObserveMultiplexer;
+    matcher: MinimongoMatcher;
+    sorter: MinimongoSorter;
+}
+export declare class OplogObserveDriver {
+    private _usesOplog;
+    private _id;
+    private _cursorDescription;
+    private _mongoHandle;
+    private _multiplexer;
+    private _safeAppendToBuffer;
+    private _stopped;
+    private _stopHandles;
+    private _matcher;
+    private _projectionFn;
+    private _sharedProjection;
+    private _sharedProjectionFn;
+    private _limit;
+    private _comparator;
+    private _sorter;
+    private _unpublishedBuffer;
+    private _published;
+    private _needToFetch;
+    private _currentlyFetching;
+    private _fetchGeneration;
+    private _requeryWhenDoneThisQuery;
+    private _writesToCommitWhenWeReachSteady;
+    private _phase;
+    private _phaseStartTime;
+    constructor(options: OplogObserveDriverOptions);
+    _addPublished(id: any, doc: any): void;
+    _removePublished(id: any): void;
+    _changePublished(id: any, oldDoc: any, newDoc: any): void;
+    _addBuffered(id: any, doc: any): void;
+    _removeBuffered(id: any): void;
+    _addMatching(doc: any): void;
+    _removeMatching(id: any): void;
+    _handleDoc(id: any, newDoc: any): void;
+    _fetchModifiedDocuments(): void;
+    _beSteady(): void;
+    _handleOplogEntryQuerying(op: any): void;
+    _handleOplogEntrySteadyOrFetching(op: any): void;
+    _runInitialQuery(): void;
+    _pollQuery(): void;
+    _runQuery(options?: any): Promise<void>;
+    _needToPollQuery(): void;
+    _doneQuerying(): Promise<void>;
+    _cursorForQuery(optionsOverwrite: {
+        limit: number;
+    }): SynchronousCursor;
+    _publishNewResults(newResults: IdMap, newBuffer: IdMap): void;
+    stop(): void;
+    _registerPhaseChange(phase: any): void;
+    static cursorSupported(cursorDescription: CursorDescription<any>, matcher: MinimongoMatcher): boolean;
+}
+export {};

package/dist/meteor/mongo/oplog_tailing.d.ts

@@ -0,0 +1,35 @@
+export declare const OPLOG_COLLECTION = "oplog.rs";
+export declare function idForOp(op: any): any;
+export declare class OplogHandle {
+    private _oplogUrl;
+    private _dbName;
+    private _oplogLastEntryConnection;
+    private _oplogTailConnection;
+    private _stopped;
+    private _tailHandle;
+    private _crossbar;
+    private _baseOplogSelector;
+    private _catchingUpFutures;
+    private _onSkippedEntriesHook;
+    private _entryQueue;
+    private _workerActive;
+    private _lastProcessedTS;
+    private _readyFuture;
+    constructor(oplogUrl: string, dbName: string);
+    stop(): void;
+    onOplogEntry(trigger: Record<string, any>, callback: (notification: Record<string, any>) => void): Promise<{
+        stop: () => void;
+    }>;
+    onSkippedEntries(callback: any): {
+        callback: any;
+        stop: () => void;
+    };
+    waitUntilCaughtUp(): Promise<void>;
+    _startTailing(): Promise<void>;
+    _maybeStartWorker(): void;
+    _setLastProcessedTS(ts: any): void;
+    _defineTooFarBehind(value: any): void;
+    _resetTooFarBehind(): void;
+}
+export declare function _sleepForMs(ms: number): Promise<unknown>;
+export declare function _escapeRegExp(s: string): string;

package/dist/meteor/mongo/oplog_v2_converter.d.ts

@@ -0,0 +1 @@
+export declare function oplogV2V1Converter(oplogEntry: any): any;

package/dist/meteor/mongo/polling_observe_driver.d.ts

@@ -0,0 +1,30 @@
+import { LiveMongoConnection } from "./live_connection";
+import { ObserveMultiplexer } from "./observe_multiplexer";
+import { CursorDescription } from "./live_cursor";
+interface PollingObserveDriverOptions<TOrdered extends boolean> {
+    cursorDescription: CursorDescription<any>;
+    mongoHandle: LiveMongoConnection;
+    ordered: TOrdered;
+    multiplexer: ObserveMultiplexer;
+    stopCallbacks?: (() => void)[];
+    matcher?: any;
+    sorter?: any;
+}
+export declare class PollingObserveDriver<TOrdered extends boolean> {
+    private _cursorDescription;
+    private _mongoHandle;
+    private _ordered;
+    private _multiplexer;
+    private _stopCallbacks;
+    private _stopped;
+    private _results;
+    private _pollsScheduledButNotStarted;
+    private _pendingWrites;
+    private _ensurePollIsScheduled;
+    private _taskQueue;
+    constructor(options: PollingObserveDriverOptions<TOrdered>);
+    _unthrottledEnsurePollIsScheduled(): void;
+    _pollMongo(): Promise<void>;
+    stop(): void;
+}
+export {};

package/dist/meteor/mongo/synchronous-cursor.d.ts

@@ -0,0 +1,17 @@
+import MongoDB from "mongodb";
+import { CursorDescription } from "./live_cursor";
+export declare function _createSynchronousCursor(db: MongoDB.Db, cursorDescription: CursorDescription<any>, options?: any): SynchronousCursor;
+export declare class SynchronousCursor {
+    private _dbCursor;
+    private _cursorDescription;
+    private _transform;
+    private _visitedIds;
+    constructor(_dbCursor: MongoDB.FindCursor, _cursorDescription: CursorDescription<any>, options: {
+        useTransform?: boolean;
+    });
+    _nextObjectPromise(): Promise<any>;
+    _nextObjectPromiseWithTimeout(timeoutMS: number): Promise<any>;
+    close(): void;
+    forEach(callback: (doc: any, index: number, cursor: SynchronousCursor) => void, thisArg?: any): Promise<void>;
+    _rewind(): void;
+}

package/dist/meteor/mongo/synchronous-queue.d.ts

@@ -0,0 +1,14 @@
+declare type AsyncFunction = (...args: any[]) => Promise<any>;
+export declare class _SynchronousQueue {
+    private _taskHandles;
+    private _runningOrRunScheduled;
+    private _draining;
+    constructor();
+    runTask(task: AsyncFunction): Promise<unknown>;
+    queueTask(task: AsyncFunction): void;
+    flush(): Promise<void>;
+    drain(): Promise<void>;
+    _scheduleRun(): void;
+    _run(): Promise<void>;
+}
+export {};

package/dist/meteor/ordered-dict/ordered_dict.d.ts

@@ -0,0 +1,31 @@
+export declare class OrderedDict {
+    static BREAK: {
+        break: boolean;
+    };
+    private _dict;
+    private _first;
+    private _last;
+    private _size;
+    private _stringify;
+    constructor(...args: any[]);
+    _k(key: any): string;
+    empty(): boolean;
+    size(): number;
+    _linkEltIn(elt: any): void;
+    _linkEltOut(elt: any): void;
+    putBefore(key: any, item: any, before: any): void;
+    append(key: any, item: any): void;
+    remove(key: any): any;
+    get(key: any): any;
+    has(key: any): any;
+    forEach(iter: any, context?: any): void;
+    first(): any;
+    firstValue(): any;
+    last(): any;
+    lastValue(): any;
+    prev(key: any): any;
+    next(key: any): any;
+    moveBefore(key: any, before: any): void;
+    indexOf(key: any): any;
+    _checkRep(): void;
+}

package/dist/meteor/random/AbstractRandomGenerator.d.ts

@@ -0,0 +1,42 @@
+export default class RandomGenerator {
+    /**
+     * @name Random.fraction
+     * @summary Return a number between 0 and 1, like `Math.random`.
+     * @locus Anywhere
+     */
+    fraction(): number;
+    /**
+     * @name Random.hexString
+     * @summary Return a random string of `n` hexadecimal digits.
+     * @locus Anywhere
+     * @param {Number} n Length of the string
+     */
+    hexString(digits: any): string;
+    _randomString(charsCount: any, alphabet: any): string;
+    /**
+     * @name Random.id
+     * @summary Return a unique identifier, such as `"Jjwjg6gouWLXhMGKW"`, that is
+     * likely to be unique in the whole world.
+     * @locus Anywhere
+     * @param {Number} [n] Optional length of the identifier in characters
+     *   (defaults to 17)
+     */
+    id(charsCount: any): string;
+    /**
+     * @name Random.secret
+     * @summary Return a random string of printable characters with 6 bits of
+     * entropy per character. Use `Random.secret` for security-critical secrets
+     * that are intended for machine, rather than human, consumption.
+     * @locus Anywhere
+     * @param {Number} [n] Optional length of the secret string (defaults to 43
+     *   characters, or 256 bits of entropy)
+     */
+    secret(charsCount: any): string;
+    /**
+     * @name Random.choice
+     * @summary Return a random element of the given array or string.
+     * @locus Anywhere
+     * @param {Array|String} arrayOrString Array or string to choose from
+     */
+    choice(arrayOrString: any): any;
+}

package/dist/meteor/random/AleaRandomGenerator.d.ts

@@ -0,0 +1,13 @@
+import RandomGenerator from './AbstractRandomGenerator';
+export default class AleaRandomGenerator extends RandomGenerator {
+    private alea;
+    constructor({ seeds }?: {
+        seeds?: any[];
+    });
+    /**
+     * @name Random.fraction
+     * @summary Return a number between 0 and 1, like `Math.random`.
+     * @locus Anywhere
+     */
+    fraction(): number;
+}

package/dist/meteor/random/NodeRandomGenerator.d.ts

@@ -0,0 +1,16 @@
+import RandomGenerator from './AbstractRandomGenerator';
+export default class NodeRandomGenerator extends RandomGenerator {
+    /**
+     * @name Random.fraction
+     * @summary Return a number between 0 and 1, like `Math.random`.
+     * @locus Anywhere
+     */
+    fraction(): number;
+    /**
+     * @name Random.hexString
+     * @summary Return a random string of `n` hexadecimal digits.
+     * @locus Anywhere
+     * @param {Number} n Length of the string
+     */
+    hexString(digits: any): any;
+}

package/dist/meteor/random/createAleaGenerator.d.ts

@@ -0,0 +1,2 @@
+import AleaRandomGenerator from './AleaRandomGenerator';
+export default function createAleaGenerator(): AleaRandomGenerator;

package/dist/meteor/random/createRandom.d.ts

@@ -0,0 +1 @@
+export default function createRandom(generator: any): any;

package/dist/meteor/random/main.d.ts

@@ -0,0 +1 @@
+export declare const Random: any;

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "mongodb-livedata-server",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "description": "MongoDB live data server, extracted from Meteor, Fibers removed and converted to TypeScript",
   "main": "dist/livedata_server.js",
-  "types": "livedata_server.ts",
+  "types": "dist/livedata_server.d.ts",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"
   },

package/meteor/LICENSE

@@ -1,28 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2011 - present Meteor Software Ltd.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-
-
-====================================================================
-This license applies to all code in Meteor that is not an externally
-maintained library. Externally maintained libraries have their own
-licenses, included in the LICENSES directory.
-====================================================================