332 lines
9.1 KiB
TypeScript
332 lines
9.1 KiB
TypeScript
declare namespace mingo {
|
|
export const VERSION: string;
|
|
export const OP_EXPRESSION: 'expression';
|
|
export const OP_GROUP: 'group';
|
|
export const OP_PIPELINE: 'pipeline';
|
|
export const OP_PROJECTION: 'projection';
|
|
export const OP_QUERY: 'query';
|
|
|
|
export type OperatorClass =
|
|
| 'expression'
|
|
| 'group'
|
|
| 'pipeline'
|
|
| 'projection'
|
|
| 'query';
|
|
|
|
export interface MingoOptions {
|
|
key: string;
|
|
}
|
|
|
|
// export interface StreamOptions {
|
|
// objectMode?: boolean;
|
|
// }
|
|
|
|
export interface MingoInternal {
|
|
/**
|
|
* Shallow clone an object
|
|
*/
|
|
clone<T>(obj: T): T;
|
|
|
|
/**
|
|
* Deep clone an object
|
|
*/
|
|
cloneDeep<T>(obj: T): T;
|
|
|
|
/**
|
|
* Computes the actual value of the expression using the given object as context
|
|
*
|
|
* @param obj The current object from the collection
|
|
* @param expr The expression for the given field
|
|
* @param operator The operator to resolve the field with
|
|
* @param opt {Object} extra options
|
|
*/
|
|
computeValue(
|
|
obj: any,
|
|
expr: any,
|
|
operator?: string,
|
|
opt?: { root?: any }
|
|
): any;
|
|
|
|
/**
|
|
* Iterate over an array or object.
|
|
* @param obj An object-like value.
|
|
* @param fn The callback to run per item.
|
|
* @param ctx The object to use a context.
|
|
*/
|
|
each(obj: object, fn: Function, ctx?: any): void;
|
|
|
|
/**
|
|
* Generate hash code
|
|
* This selected function is the result of benchmarking various hash functions.
|
|
* This version performs well and can hash 10^6 documents in ~3s with on average 100 collisions.
|
|
*/
|
|
getHash(value: any): number;
|
|
|
|
/**
|
|
* Returns the key used as the collection's objects ids
|
|
*/
|
|
idKey(): string;
|
|
|
|
/**
|
|
* Transform values in a collection.
|
|
* @param obj An array/object whose values to transform.
|
|
* @param fn The transform function.
|
|
* @param ctx The value to use as the "this" context for the transform.
|
|
* @return Result object after applying the transform.
|
|
*/
|
|
map<T>(
|
|
obj: any,
|
|
fn: (value: any, index: any, obj: any) => T,
|
|
ctx?: any
|
|
): Array<T>;
|
|
|
|
/**
|
|
* Returns the operators defined for the given operator classes.
|
|
*/
|
|
ops(...args: string[]): Array<any>;
|
|
|
|
/**
|
|
* Reduce any array-like object.
|
|
*/
|
|
reduce<T>(
|
|
obj: any,
|
|
fn: (memo: T, value: any, index: any, obj: any) => T,
|
|
accumulator: T
|
|
): T;
|
|
|
|
/**
|
|
* Resolve the value of the field (dot separated) on the given object
|
|
* @param obj The object context.
|
|
* @param selector Dot separated path to field.
|
|
*/
|
|
resolve(obj: any, selector: string): any;
|
|
resolve(
|
|
obj: any,
|
|
selector: string,
|
|
opt: { meta: true }
|
|
): { result: any; depth: number };
|
|
|
|
/**
|
|
* Returns the full object to the resolved value given by the selector.
|
|
* This function excludes empty values as they aren't practically useful.
|
|
*
|
|
* @param obj The object context
|
|
* @param selector Dot separated path to field.
|
|
*/
|
|
resolveObj(obj: any, selector: string): any;
|
|
|
|
assert(condition: any, message: string): void;
|
|
err(s: string): void;
|
|
getType(v: any): string;
|
|
has(obj: any, prop: string): boolean;
|
|
includes(arr: Array<any>, item: any): boolean;
|
|
isArray(v: any): boolean;
|
|
isBoolean(v: any): boolean;
|
|
isDate(v: any): boolean;
|
|
isEmpty(v: any): boolean;
|
|
isEqual(v: any): boolean;
|
|
isFunction(v: any): boolean;
|
|
isNil(v: any): boolean;
|
|
isNull(v: any): boolean;
|
|
isNumber(v: any): boolean;
|
|
isObject(v: any): boolean;
|
|
isRegExp(v: any): boolean;
|
|
isString(v: any): boolean;
|
|
isUndefined(v: any): boolean;
|
|
keys(o: {}): string[];
|
|
}
|
|
|
|
/**
|
|
* Exported to the users to allow writing custom operators.
|
|
*/
|
|
export function _internal(): MingoInternal;
|
|
|
|
/**
|
|
* Register new operators for the given operator category type.
|
|
* @param opClass The operator class to extend.
|
|
* @param fn A function returning an object of new operators.
|
|
*/
|
|
export function addOperators(
|
|
opClass: OperatorClass,
|
|
fn: (internal: MingoInternal) => { [op: string]: Function }
|
|
): void;
|
|
|
|
/**
|
|
* Performs aggregation operation using the aggregation pipeline.
|
|
*/
|
|
export function aggregate<T>(collection: T[], expressions: any): T[];
|
|
|
|
/**
|
|
* Performs a query on a collection and returns a cursor object.
|
|
*/
|
|
export function find<T>(collection: T[], criteria: any): Cursor<T>;
|
|
export function find<P>(
|
|
collection: Array<any>,
|
|
criteria: any,
|
|
projection: any
|
|
): Cursor<P>;
|
|
|
|
/**
|
|
* Returns the non-matched objects as a collection from executing a Mingo.Query with the given criteria
|
|
*/
|
|
export function remove<T>(collection: T[], criteria: any): T[];
|
|
|
|
/**
|
|
* Setup default settings for Mingo
|
|
*/
|
|
export function setup(options: Partial<MingoOptions>): void;
|
|
|
|
/**
|
|
* Query object to test collection elements with.
|
|
*/
|
|
export class Query {
|
|
/**
|
|
* Creates a Query object with the given query criteria.
|
|
* @param criteria The pass criteria for the query.
|
|
* @param projection Optional projection specifiers.
|
|
*/
|
|
constructor(criteria: any, projection?: any);
|
|
|
|
/**
|
|
* Checks if the object passes the query criteria. Returns true if so, false otherwise.
|
|
*/
|
|
test(obj: any): boolean;
|
|
|
|
/**
|
|
* Performs a query on a collection and returns a Cursor object.
|
|
*/
|
|
find<T>(collection: T[]): Cursor<T>;
|
|
find<P>(collection: Array<any>, projection: any): Cursor<P>;
|
|
|
|
/**
|
|
* Remove matching documents from the collection and return the remainder.
|
|
*/
|
|
remove<T>(collection: T[]): T[];
|
|
|
|
/**
|
|
* Return a Mingo.Stream to filter and transform JSON objects from a readable stream. Use via mingo-stream.
|
|
*/
|
|
// stream(options?: StreamOptions): Stream;
|
|
}
|
|
|
|
/**
|
|
* A Transform stream that can be piped from/to any readable/writable JSON stream.
|
|
*/
|
|
// export class Stream extends Transform {
|
|
// constructor(query: Query, options?: StreamOptions);
|
|
// }
|
|
|
|
/**
|
|
* Aggregator for defining filter using mongoDB aggregation pipeline syntax.
|
|
*/
|
|
export class Aggregator {
|
|
/**
|
|
* Creates a Mingo.Aggregator object with a collection of aggregation pipeline expressions.
|
|
* @param operators An array of pipeline operators.
|
|
*/
|
|
constructor(operators: Array<any>);
|
|
|
|
/**
|
|
* Apply the pipeline operations over the collection by order of the sequence added
|
|
* @param collection an array of objects to process
|
|
* @param query the `Query` object to use as context
|
|
*/
|
|
run<P>(collection: Array<any>, query?: Query): P[];
|
|
}
|
|
|
|
/**
|
|
* Cursor to iterate and perform filtering on matched objects.
|
|
*/
|
|
export class Cursor<T> {
|
|
/**
|
|
* Creates a Mingo.Cursor object which holds the result of applying the query over the collection.
|
|
*/
|
|
constructor(collection: T[], query: Query, projection?: any);
|
|
|
|
/**
|
|
* Returns all the matched documents in a cursor as a collection.
|
|
*/
|
|
all(): T[];
|
|
|
|
/**
|
|
* Returns the first documents in a cursor.
|
|
*/
|
|
first(): T;
|
|
|
|
/**
|
|
* Returns the last document in a cursor
|
|
*/
|
|
last(): T;
|
|
|
|
/**
|
|
* Returns a count of the documents in a cursor.
|
|
*/
|
|
count(): number;
|
|
|
|
/**
|
|
* Constrains the size of a cursor's result set.
|
|
* @param n The number of results to limit to.
|
|
* @return Returns the cursor, so you can chain this call.
|
|
*/
|
|
limit(n: number): this;
|
|
|
|
/**
|
|
* Returns a cursor that begins returning results only after passing or skipping a number of documents.
|
|
* @param n The number of results to skip.
|
|
* @return Returns the cursor, so you can chain this call.
|
|
*/
|
|
skip(n: number): this;
|
|
|
|
/**
|
|
* Returns results ordered according to a sort specification.
|
|
* @param modifier An object of key and values specifying the sort order. 1 for ascending and -1 for descending.
|
|
* @return Returns the cursor, so you can chain this call.
|
|
*/
|
|
sort(modifier: any): this;
|
|
|
|
/**
|
|
* Returns the next document in a cursor.
|
|
*/
|
|
next(): T | null;
|
|
|
|
/**
|
|
* Returns true if the cursor has documents and can be iterated.
|
|
*/
|
|
hasNext(): boolean;
|
|
|
|
/**
|
|
* Applies a function to each document in a cursor and collects the return values in an array.
|
|
* @param callback
|
|
*/
|
|
map<P>(callback: { (document: T, index: number): P }): P[];
|
|
|
|
/**
|
|
* Applies a JavaScript function for every document in a cursor.
|
|
*/
|
|
forEach(callback: { (document: T, index: number): void }): void;
|
|
}
|
|
|
|
/**
|
|
* A mixin object for Backbone.Collection which adds query() and aggregate() methods.
|
|
*/
|
|
export interface CollectionMixinInterface<T = object> {
|
|
/**
|
|
* Performs a query on the collection and returns a Mingo.Cursor object.
|
|
*/
|
|
query(criteria: any): T[];
|
|
query<P>(criteria: any, projection: any): Array<P>;
|
|
|
|
/**
|
|
* Performs aggregation operation using the aggregation pipeline.
|
|
*/
|
|
aggregate<P>(expressions: Array<any>): Array<P>;
|
|
}
|
|
|
|
/**
|
|
* A mixin object for Backbone.Collection which adds query() and aggregate() methods.
|
|
*/
|
|
export const CollectionMixin: CollectionMixinInterface;
|
|
}
|
|
|
|
export default mingo;
|