iridium
Version:
A custom lightweight ORM for MongoDB designed for power-users
156 lines • 7.27 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
const MongoDB = require("mongodb");
const _ = require("lodash");
const Skmatc = require("skmatc");
const Instance_1 = require("./Instance");
const Transforms_1 = require("./Transforms");
/**
* Specifies the name of the collection to which this instance's documents should be sent.
* @param {string} name The name of the MongoDB collection to store the documents in.
*
* This decorator replaces the use of the static collection property on instance implementation
* classes. If your transpiler does not support decorators then you are free to make use of the
* property instead.
*/
function Collection(name) {
return function (target) {
target.collection = name;
};
}
exports.Collection = Collection;
/**
* Specifies a MongoDB collection level index to be managed by Iridium for this instance type.
* More than one instance of this decorator may be used if you wish to specify multiple indexes.
* @param {IndexSpecification} spec The formal index specification which defines the properties and ordering used in the index.
* @param {MongoDB.IndexOptions} options The options dictating the way in which the index behaves.
*
* This decorator replaces the use of the static indexes property on instance implementation
* classes. If your transpiler does not support decorators then you are free to make use of the
* property instead.
*/
function Index(spec, options) {
return function (target) {
target.indexes = (target.indexes || []).concat({ spec: spec, options: options || {} });
};
}
exports.Index = Index;
/**
* Specifies a custom validator to be made available for this collection's schema.
* More than one instance of this decorator may be used if you wish to specify multiple validators.
* @param {Object} forType The value in the schema which will be delegated to this function for validation.
* @param {function} validate A function which calls this.assert(condition) to determine whether a schema node is valid or not.
*
* This decorator replaces the use of the static validators property on instance implementation
* classes. If your transpiler does not support decorators then you are free to make use of the
* property instead.
*
* @example
* @Iridium.Validate('everything', function(schema, data, path) {
* return this.assert(data == 42, "Expected the answer to life, the universe and everything.");
* })
*/
function Validate(forType, validate) {
return function (target) {
target.validators = (target.validators || []).concat(Skmatc.create(schema => schema === forType, validate));
};
}
exports.Validate = Validate;
function Property(...args) {
let name = undefined, asType = false, required = true;
if (args.length > 1 && typeof args[args.length - 1] === "boolean")
required = args.pop();
return function (target, property) {
let staticTarget = target;
if (!property)
name = args.shift();
else {
name = property;
staticTarget = target.constructor;
}
asType = args.pop() || false;
staticTarget.schema = _.clone(staticTarget.schema || { _id: false });
if (!required && typeof asType !== "boolean")
staticTarget.schema[name] = { $required: required, $type: asType };
else
staticTarget.schema[name] = asType;
};
}
exports.Property = Property;
/**
* Specifies a custom transform to be applied to the property this decorator is applied to.
*
* @param {function} fromDB The function used to convert values from the database for the application.
* @param {function} toDB The function used to convert values from the application to the form used in the database.
*
* Property transforms are lazily evaluated when their fields are accessed for performance reasons.
* Modifying the values of an array or object will *not* trigger its transform function unless the
* document level property is re-assigned.
*
* This decorator can either compliment or replace the static transforms property on your instance
* class, however only one transform can be applied to any property at a time.
* If your transpiler does not support decorators then you are free to make use of the
* property instead.
*
* If this decorator is applied to the instance class itself, as opposed to a property, then
* it will be treated as a $document transformer - and will receive the full document as opposed
* to individual property values. Similarly, it is expected to return a full document when either
* fromDB or toDB is called.
*/
function Transform(fromDB, toDB) {
return function (target, property = "$document") {
let staticTarget = (target instanceof Instance_1.Instance && target.constructor || target);
staticTarget.transforms = _.clone(staticTarget.transforms || {});
staticTarget.transforms[property] = {
fromDB: fromDB,
toDB: toDB
};
};
}
exports.Transform = Transform;
/**
* Specifies that this property should be treated as an ObjectID, with the requisite validator and transforms.
*
* This decorator applies an ObjectID validator to the property, which ensures that values sent to the database
* are instances of the MongoDB ObjectID type, as well as applying a transform operation which converts ObjectIDs
* to strings for your application, and then converts strings back to ObjectIDs for the database.
*/
function ObjectID(target, name) {
Property(MongoDB.ObjectID)(target, name);
Transform(Transforms_1.DefaultTransforms.ObjectID.fromDB, Transforms_1.DefaultTransforms.ObjectID.toDB)(target, name);
}
exports.ObjectID = ObjectID;
/**
* Specifies that this property should be stored using the MongoDB binary type and represented as a Buffer.
*
* This decorator applies a Buffer validator to the property, which ensures that values you send to the database
* are well formatted Buffer objects represented using the BSON Binary datatype. In addition to this, it will
* apply a transform which ensures you only work with Buffer objects and that data is always stored in Binary
* format.
*/
function Binary(target, name) {
Property(Buffer)(target, name);
Transform(Transforms_1.DefaultTransforms.Binary.fromDB, Transforms_1.DefaultTransforms.Binary.toDB)(target, name);
}
exports.Binary = Binary;
/**
* Specifies that the instance is a result of a mapReduce operation and functions of that operation.
*
* @param TDocument Interface of the document on which the operation will run
* @param Key Type of the mapped keys
* @param Value Type of the mapped values
*
* @param {MapReduce.MapFunction<TDocument>} map A function which maps documents.
* @param {MapReduce.ReduceFunction<Key, Value>} reduce A function which reduces mapped pairs.
*
* This decorator replaces the use of the static mapReduce property on instance implementation
* classes. If your transpiler does not support decorators then you are free to make use of the
* property instead.
*/
function MapReduce(map, reduce) {
return function (target) {
target.mapReduceOptions = { map: map, reduce: reduce };
};
}
exports.MapReduce = MapReduce;
//# sourceMappingURL=Decorators.js.map