vulcain-corejs
Version:
Vulcain micro-service framework
231 lines (229 loc) • 7.73 kB
JavaScript
;
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments)).next());
});
};
const fs = require("fs");
const mongoQueryParser_1 = require("./mongoQueryParser");
/**
* Default memory provider
*/
class MemoryProvider {
/**
* Create a memory provider instance.
* @param dataFolder : (optional) if provided, data will be persisted on disk on EVERY create, update or delete
*/
constructor(dataFolder) {
this.dataFolder = dataFolder;
}
get address() {
return "memory";
}
initializeTenantAsync(tenant) {
if (!tenant)
throw new Error("Tenant can not be null");
let folder = this.dataFolder;
if (this.dataFolder) {
if (!fs.existsSync(folder))
fs.mkdirSync(folder);
folder = folder + '/' + tenant;
if (!fs.existsSync(folder))
fs.mkdirSync(folder);
}
this.state = { schemas: new Map(), folder };
return Promise.resolve(() => { this.state = null; });
}
ensureSchema(schema) {
let schemaInfo = this.state.schemas.get(schema.name);
if (!schemaInfo) {
schemaInfo = { data: {} };
if (this.state.folder) {
schemaInfo.saveToFile = this.state.folder + "/" + schema.description.storageName + ".json";
if (fs.existsSync(schemaInfo.saveToFile)) {
schemaInfo.data = JSON.parse(fs.readFileSync(schemaInfo.saveToFile, "UTF-8"));
}
}
this.state.schemas.set(schema.name, schemaInfo);
}
return schemaInfo.data;
}
save(schema) {
let schemaInfo = this.state.schemas.get(schema.name);
if (!schemaInfo.saveToFile)
return;
fs.writeFileSync(schemaInfo.saveToFile, JSON.stringify(schemaInfo.data), "UTF-8");
}
static clone(obj) {
return obj && Object.assign({}, obj);
}
/**
* Return a list of entities
* @param options
* @returns {Promise}
*/
getAllAsync(schema, options) {
let data = this.ensureSchema(schema);
options = options || { maxByPage: -1 };
return new Promise((resolve, reject) => {
try {
let result = Array.from(this.take(schema, data[schema.description.storageName], options));
options.length = result.length;
resolve(result);
}
catch (err) {
reject(err);
}
});
}
*take(schema, list, options) {
let take = options.maxByPage || -1;
let skip = take * (options.page || 0);
let cx = 0;
let query = new mongoQueryParser_1.MongoQueryParser(options.query.filter || options.query);
if (list) {
for (let k in list) {
let v = list[k];
if (!v || !query.execute(v))
continue;
if (cx < skip) {
cx++;
continue;
}
if (take < 0 || cx < skip + take) {
cx++;
yield MemoryProvider.clone(v);
}
else
break;
}
}
}
findOneAsync(schema, query) {
return __awaiter(this, void 0, void 0, function* () {
let options = {};
options.query = query;
let list = yield this.getAllAsync(schema, options);
return list && list.length > 0 ? list[0] : null;
});
}
/**
* Read an entity
* @param name
* @returns {Promise}
*/
getAsync(schema, name) {
let data = this.ensureSchema(schema);
const self = this;
return new Promise((resolve, reject) => {
try {
let list = data[schema.description.storageName];
resolve(list && MemoryProvider.clone(list[name] || []));
}
catch (err) {
reject(err);
}
});
}
/**
* Delete an entity
* @param id
* @returns {Promise}
*/
deleteAsync(schema, old) {
if (!old)
throw new Error("Argument is required");
let data = this.ensureSchema(schema);
let self = this;
return new Promise((resolve, reject) => {
try {
let id;
if (typeof old === "string")
id = old;
else
id = schema.getId(old);
let list = data[schema.description.storageName];
if (list && list[id]) {
delete list[id];
self.save(schema);
resolve(true);
}
else {
resolve(false);
}
}
catch (err) {
reject(err);
}
});
}
/**
* Persist an entity
* @param entity
* @returns {Promise}
*/
createAsync(schema, entity) {
if (!entity)
throw new Error("Entity is required");
let data = this.ensureSchema(schema);
const self = this;
entity._created = new Date().toUTCString();
return new Promise((resolve, reject) => {
try {
let list = data[schema.description.storageName];
if (!list) {
list = {};
data[schema.description.storageName] = list;
}
let name = schema.getId(entity);
if (!name)
throw new Error(`Can not create a ${schema.name} entity with undefined id ${schema.getIdProperty()} `);
if (list[name]) {
reject(new Error(`Can not add existing ${schema.name} ${name}`));
return;
}
list[name] = MemoryProvider.clone(entity);
self.save(schema);
resolve(entity);
}
catch (err) {
reject(err);
}
});
}
/**
* Update an entity
* @param entity
* @param old
* @returns {Promise<T>}
*/
updateAsync(schema, entity, old) {
if (!entity)
throw new Error("Entity is required");
let data = this.ensureSchema(schema);
entity._updated = new Date().toUTCString();
let self = this;
return new Promise((resolve, reject) => {
try {
let list = data[schema.description.storageName];
let name = schema.getId(entity);
if (!list || !list[name]) {
reject("Entity doesn't exist. " + name);
return;
}
entity = schema.deepAssign(list[name], entity);
list[name] = MemoryProvider.clone(entity);
self.save(schema);
resolve(entity);
}
catch (err) {
reject(err);
}
});
}
}
exports.MemoryProvider = MemoryProvider;
//# sourceMappingURL=provider.js.map