Socket
Socket
Sign inDemoInstall

ts-redis-orm

Package Overview
Dependencies
Maintainers
1
Versions
26
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

ts-redis-orm - npm Package Compare versions

Comparing version 0.1.8 to 0.1.9

src/@types/clone/index.d.ts

872

build/BaseEntity.js

@@ -11,46 +11,12 @@ "use strict";

};
var __generator = (this && this.__generator) || function (thisArg, body) {
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
function verb(n) { return function (v) { return step([n, v]); }; }
function step(op) {
if (f) throw new TypeError("Generator is already executing.");
while (_) try {
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
if (y = 0, t) op = [op[0] & 2, t.value];
switch (op[0]) {
case 0: case 1: t = op; break;
case 4: _.label++; return { value: op[1], done: false };
case 5: _.label++; y = op[1]; op = [0]; continue;
case 7: op = _.ops.pop(); _.trys.pop(); continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
if (t[2]) _.ops.pop();
_.trys.pop(); continue;
}
op = body.call(thisArg, _);
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
}
};
var __spreadArrays = (this && this.__spreadArrays) || function () {
for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
for (var r = Array(s), k = 0, i = 0; i < il; i++)
for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
r[k] = a[j];
return r;
};
Object.defineProperty(exports, "__esModule", { value: true });
var entityExporter_1 = require("./entityExporter");
var RedisOrmEntityError_1 = require("./errors/RedisOrmEntityError");
var RedisOrmSchemaError_1 = require("./errors/RedisOrmSchemaError");
var eventEmitters_1 = require("./eventEmitters");
var parser_1 = require("./parser");
var Query_1 = require("./Query");
var serviceInstance_1 = require("./serviceInstance");
var BaseEntity = /** @class */ (function () {
function BaseEntity() {
const entityExporter_1 = require("./entityExporter");
const RedisOrmEntityError_1 = require("./errors/RedisOrmEntityError");
const RedisOrmSchemaError_1 = require("./errors/RedisOrmSchemaError");
const eventEmitters_1 = require("./eventEmitters");
const parser_1 = require("./parser");
const Query_1 = require("./Query");
const serviceInstance_1 = require("./serviceInstance");
class BaseEntity {
constructor() {
// endregion

@@ -66,3 +32,3 @@ // region constructor / variables

this._increments = {};
var now = new Date();
const now = new Date();
this.createdAt = now;

@@ -72,166 +38,112 @@ this.updatedAt = now;

// region static methods
BaseEntity.connect = function () {
return __awaiter(this, void 0, void 0, function () {
var schemaErrors;
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4 /*yield*/, serviceInstance_1.serviceInstance.compareSchemas(this)];
case 1:
schemaErrors = _a.sent();
if (schemaErrors.length) {
throw new RedisOrmSchemaError_1.RedisOrmSchemaError("(" + this.name + ") Invalid Schemas", schemaErrors);
}
return [4 /*yield*/, serviceInstance_1.serviceInstance.getRedis(this)];
case 2: return [2 /*return*/, _a.sent()];
}
});
static connect() {
return __awaiter(this, void 0, void 0, function* () {
// validate the schema
const schemaErrors = yield serviceInstance_1.serviceInstance.compareSchemas(this);
if (schemaErrors.length) {
throw new RedisOrmSchemaError_1.RedisOrmSchemaError(`(${this.name}) Invalid Schemas`, schemaErrors);
}
return yield serviceInstance_1.serviceInstance.getRedis(this);
});
};
BaseEntity.newFromStorageStrings = function (storageStrings) {
var entity = this.create({});
}
static newFromStorageStrings(storageStrings) {
const entity = this.create({});
entity.assignStorageStrings(storageStrings);
return entity;
};
BaseEntity.query = function () {
}
static query() {
return new Query_1.Query(this);
};
BaseEntity.find = function (id) {
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4 /*yield*/, this.query().find(id)];
case 1: return [2 /*return*/, _a.sent()];
}
});
}
static find(id) {
return __awaiter(this, void 0, void 0, function* () {
return yield this.query().find(id);
});
};
BaseEntity.findMany = function (idObjects) {
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4 /*yield*/, this.query().findMany(idObjects)];
case 1: return [2 /*return*/, _a.sent()];
}
});
}
static findMany(idObjects) {
return __awaiter(this, void 0, void 0, function* () {
return yield this.query().findMany(idObjects);
});
};
BaseEntity.create = function (values) {
}
static create(values) {
return new this().set(values);
};
BaseEntity.all = function () {
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4 /*yield*/, this.query().get()];
case 1: return [2 /*return*/, _a.sent()];
}
});
}
static all() {
return __awaiter(this, void 0, void 0, function* () {
return yield this.query().get();
});
};
BaseEntity.count = function () {
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4 /*yield*/, this.query().count()];
case 1: return [2 /*return*/, _a.sent()];
}
});
}
static count() {
return __awaiter(this, void 0, void 0, function* () {
return yield this.query().count();
});
};
}
// get the current redis instance, do not use internally
BaseEntity.getRedis = function () {
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4 /*yield*/, serviceInstance_1.serviceInstance.getRedis(this, false)];
case 1: return [2 /*return*/, _a.sent()];
}
});
static getRedis() {
return __awaiter(this, void 0, void 0, function* () {
return yield serviceInstance_1.serviceInstance.getRedis(this, false);
});
};
BaseEntity.resyncDb = function () {
return __awaiter(this, void 0, void 0, function () {
var redis, remoteSchemas, tableName, keys, params, commandResult, saveResult;
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4 /*yield*/, serviceInstance_1.serviceInstance.getRedis(this)];
case 1:
redis = _a.sent();
return [4 /*yield*/, serviceInstance_1.serviceInstance.getRemoteSchemas(this, redis)];
case 2:
remoteSchemas = _a.sent();
if (!remoteSchemas) return [3 /*break*/, 4];
tableName = serviceInstance_1.serviceInstance.getTable(this);
keys = [];
params = [
serviceInstance_1.serviceInstance.getSchemasJson(this),
tableName,
];
return [4 /*yield*/, redis.commandAtomicResyncDb(keys, params)];
case 3:
commandResult = _a.sent();
saveResult = JSON.parse(commandResult);
if (saveResult.error) {
throw new RedisOrmEntityError_1.RedisOrmEntityError("(" + this.name + ") " + saveResult.error);
}
_a.label = 4;
case 4: return [2 /*return*/];
}
static resyncDb() {
return __awaiter(this, void 0, void 0, function* () {
// get redis,
const redis = yield serviceInstance_1.serviceInstance.getRedis(this);
const remoteSchemas = yield serviceInstance_1.serviceInstance.getRemoteSchemas(this, redis);
// we resync only if we found any schema exist
if (remoteSchemas) {
// prepare arguments
const tableName = serviceInstance_1.serviceInstance.getTable(this);
const keys = [];
const params = [
serviceInstance_1.serviceInstance.getSchemasJson(this),
tableName,
];
// remove everything
const commandResult = yield redis.commandAtomicResyncDb(keys, params);
const saveResult = JSON.parse(commandResult);
if (saveResult.error) {
throw new RedisOrmEntityError_1.RedisOrmEntityError(`(${this.name}) ${saveResult.error}`);
}
});
}
});
};
BaseEntity.truncate = function (className) {
return __awaiter(this, void 0, void 0, function () {
var redis, remoteSchemas, tableName, keys, params;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
if (className !== this.name) {
throw new RedisOrmEntityError_1.RedisOrmEntityError("(" + this.name + ") You need to provide the class name for truncate");
}
return [4 /*yield*/, serviceInstance_1.serviceInstance.getRedis(this)];
case 1:
redis = _a.sent();
return [4 /*yield*/, serviceInstance_1.serviceInstance.getRemoteSchemas(this, redis)];
case 2:
remoteSchemas = _a.sent();
if (!remoteSchemas) return [3 /*break*/, 4];
tableName = serviceInstance_1.serviceInstance.getTable(this);
keys = [];
params = [
tableName,
];
// remove everything
return [4 /*yield*/, redis.commandAtomicTruncate(keys, params)];
case 3:
// remove everything
_a.sent();
_a.label = 4;
case 4: return [2 /*return*/];
}
});
}
static truncate(className) {
return __awaiter(this, void 0, void 0, function* () {
if (className !== this.name) {
throw new RedisOrmEntityError_1.RedisOrmEntityError(`(${this.name}) You need to provide the class name for truncate`);
}
// get redis,
const redis = yield serviceInstance_1.serviceInstance.getRedis(this);
const remoteSchemas = yield serviceInstance_1.serviceInstance.getRemoteSchemas(this, redis);
// we truncate only if we found any schema exist
if (remoteSchemas) {
// prepare arguments
const tableName = serviceInstance_1.serviceInstance.getTable(this);
const keys = [];
const params = [
tableName,
];
// remove everything
yield redis.commandAtomicTruncate(keys, params);
}
});
};
BaseEntity.getEventEmitter = function () {
}
static getEventEmitter() {
return eventEmitters_1.eventEmitters.getEventEmitter(this);
};
BaseEntity.getSchemas = function () {
var schemas = serviceInstance_1.serviceInstance.getSchemas(this);
var indexKeys = serviceInstance_1.serviceInstance.getIndexKeys(this);
var uniqueKeys = serviceInstance_1.serviceInstance.getUniqueKeys(this);
var primaryKeys = serviceInstance_1.serviceInstance.getPrimaryKeys(this);
var autoIncrementKey = serviceInstance_1.serviceInstance.getAutoIncrementKey(this);
var entityMeta = serviceInstance_1.serviceInstance.getEntityMeta(this);
}
static getSchemas() {
const schemas = serviceInstance_1.serviceInstance.getSchemas(this);
const indexKeys = serviceInstance_1.serviceInstance.getIndexKeys(this);
const uniqueKeys = serviceInstance_1.serviceInstance.getUniqueKeys(this);
const primaryKeys = serviceInstance_1.serviceInstance.getPrimaryKeys(this);
const autoIncrementKey = serviceInstance_1.serviceInstance.getAutoIncrementKey(this);
const entityMeta = serviceInstance_1.serviceInstance.getEntityMeta(this);
// convert to column objects
var columnTypes = Object.keys(schemas)
.reduce(function (a, b) {
var _a;
return Object.assign(a, (_a = {}, _a[b] = schemas[b].type, _a));
}, {});
const columnTypes = Object.keys(schemas)
.reduce((a, b) => Object.assign(a, { [b]: schemas[b].type }), {});
return {
columnTypes: columnTypes,
indexKeys: indexKeys,
uniqueKeys: uniqueKeys,
primaryKeys: primaryKeys,
autoIncrementKey: autoIncrementKey,
columnTypes,
indexKeys,
uniqueKeys,
primaryKeys,
autoIncrementKey,
table: entityMeta.table,

@@ -241,108 +153,60 @@ connection: entityMeta.connection,

};
};
}
// endregion
// region static method: import/export
BaseEntity.export = function (file) {
return __awaiter(this, void 0, void 0, function () {
var all, allDeleted;
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4 /*yield*/, this.all()];
case 1:
all = _a.sent();
return [4 /*yield*/, this.query().onlyDeleted().get()];
case 2:
allDeleted = _a.sent();
return [4 /*yield*/, this.exportEntities(__spreadArrays(all, allDeleted), file)];
case 3:
_a.sent();
return [2 /*return*/];
}
});
static export(file) {
return __awaiter(this, void 0, void 0, function* () {
const all = yield this.all();
const allDeleted = yield this.query().onlyDeleted().get();
yield this.exportEntities([...all, ...allDeleted], file);
});
};
BaseEntity.exportEntities = function (entities, file) {
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4 /*yield*/, entityExporter_1.entityExporter.exportEntities(this, entities, file)];
case 1:
_a.sent();
return [2 /*return*/];
}
});
}
static exportEntities(entities, file) {
return __awaiter(this, void 0, void 0, function* () {
yield entityExporter_1.entityExporter.exportEntities(this, entities, file);
});
};
BaseEntity.getImportFileMeta = function () {
}
static getImportFileMeta() {
//
};
BaseEntity.import = function (file, skipSchemasCheck) {
if (skipSchemasCheck === void 0) { skipSchemasCheck = false; }
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4 /*yield*/, entityExporter_1.entityExporter.import(this, file, skipSchemasCheck)];
case 1:
_a.sent();
return [2 /*return*/];
}
});
}
static import(file, skipSchemasCheck = false) {
return __awaiter(this, void 0, void 0, function* () {
yield entityExporter_1.entityExporter.import(this, file, skipSchemasCheck);
});
};
Object.defineProperty(BaseEntity.prototype, "isDeleted", {
// endregion
// region public get properties: conditions
get: function () {
return !isNaN(Number(this._storageStrings.deletedAt));
},
enumerable: true,
configurable: true
});
Object.defineProperty(BaseEntity.prototype, "isNew", {
get: function () {
return this._isNew;
},
enumerable: true,
configurable: true
});
Object.defineProperty(BaseEntity.prototype, "createdAt", {
// endregion
// region public properties: createdAt, updatedAt, deletedAt
get: function () {
return this._get("createdAt");
},
set: function (value) {
this._set("createdAt", value);
},
enumerable: true,
configurable: true
});
Object.defineProperty(BaseEntity.prototype, "updatedAt", {
get: function () {
return this._get("updatedAt");
},
set: function (value) {
this._set("updatedAt", value);
},
enumerable: true,
configurable: true
});
Object.defineProperty(BaseEntity.prototype, "deletedAt", {
get: function () {
return this._get("deletedAt");
},
set: function (value) {
this._set("deletedAt", value);
},
enumerable: true,
configurable: true
});
}
// endregion
// region public get properties: conditions
get isDeleted() {
return !isNaN(Number(this._storageStrings.deletedAt));
}
get isNew() {
return this._isNew;
}
// endregion
// region public properties: createdAt, updatedAt, deletedAt
get createdAt() {
return this._get("createdAt");
}
set createdAt(value) {
this._set("createdAt", value);
}
get updatedAt() {
return this._get("updatedAt");
}
set updatedAt(value) {
this._set("updatedAt", value);
}
get deletedAt() {
return this._get("deletedAt");
}
set deletedAt(value) {
this._set("deletedAt", value);
}
// endregion
// region public methods
BaseEntity.prototype.getEntityId = function () {
var primaryKeys = serviceInstance_1.serviceInstance.getPrimaryKeys(this.constructor).sort();
var values = [];
for (var _i = 0, primaryKeys_1 = primaryKeys; _i < primaryKeys_1.length; _i++) {
var column = primaryKeys_1[_i];
var value = this._get(column);
getEntityId() {
const primaryKeys = serviceInstance_1.serviceInstance.getPrimaryKeys(this.constructor).sort();
const values = [];
for (const column of primaryKeys) {
const value = this._get(column);
if (typeof value === "number") {

@@ -353,3 +217,3 @@ if (value && Number.isInteger(value)) {

else {
throw new RedisOrmEntityError_1.RedisOrmEntityError("(" + this.constructor.name + ") Invalid number value: " + value + " for primary key: " + column);
throw new RedisOrmEntityError_1.RedisOrmEntityError(`(${this.constructor.name}) Invalid number value: ${value} for primary key: ${column}`);
}

@@ -362,116 +226,92 @@ }

else {
throw new RedisOrmEntityError_1.RedisOrmEntityError("(" + this.constructor.name + ") Invalid string value: '" + value + "' for primary key: " + column);
throw new RedisOrmEntityError_1.RedisOrmEntityError(`(${this.constructor.name}) Invalid string value: '${value}' for primary key: ${column}`);
}
}
else {
throw new RedisOrmEntityError_1.RedisOrmEntityError("(" + this.constructor.name + ") Invalid value: " + value + " for primary key: " + column);
throw new RedisOrmEntityError_1.RedisOrmEntityError(`(${this.constructor.name}) Invalid value: ${value} for primary key: ${column}`);
}
}
return values.join(":");
};
BaseEntity.prototype.getValues = function () {
var values = {};
var columns = serviceInstance_1.serviceInstance.getColumns(this.constructor);
for (var _i = 0, columns_1 = columns; _i < columns_1.length; _i++) {
var column = columns_1[_i];
}
getValues() {
const values = {};
const columns = serviceInstance_1.serviceInstance.getColumns(this.constructor);
for (const column of columns) {
values[column] = this._get(column);
}
return values;
};
BaseEntity.prototype.increment = function (column, value) {
if (value === void 0) { value = 1; }
}
increment(column, value = 1) {
if (this.isNew) {
throw new RedisOrmEntityError_1.RedisOrmEntityError("(" + this.constructor.name + ") You cannot increment a new entity");
throw new RedisOrmEntityError_1.RedisOrmEntityError(`(${this.constructor.name}) You cannot increment a new entity`);
}
if (serviceInstance_1.serviceInstance.isPrimaryKey(this.constructor, column)) {
throw new RedisOrmEntityError_1.RedisOrmEntityError("(" + this.constructor.name + ") You cannot increment primary key");
throw new RedisOrmEntityError_1.RedisOrmEntityError(`(${this.constructor.name}) You cannot increment primary key`);
}
if (serviceInstance_1.serviceInstance.isUniqueKey(this.constructor, column)) {
throw new RedisOrmEntityError_1.RedisOrmEntityError("(" + this.constructor.name + ") You cannot increment unique key");
throw new RedisOrmEntityError_1.RedisOrmEntityError(`(${this.constructor.name}) You cannot increment unique key`);
}
if (!serviceInstance_1.serviceInstance.isNumberColumn(this.constructor, column)) {
throw new RedisOrmEntityError_1.RedisOrmEntityError("(" + this.constructor.name + ") Column need to be in the type of Number");
throw new RedisOrmEntityError_1.RedisOrmEntityError(`(${this.constructor.name}) Column need to be in the type of Number`);
}
if (!Number.isInteger(value)) {
throw new RedisOrmEntityError_1.RedisOrmEntityError("(" + this.constructor.name + ") Increment value need to be an integer");
throw new RedisOrmEntityError_1.RedisOrmEntityError(`(${this.constructor.name}) Increment value need to be an integer`);
}
this._increments[column] = value;
return this;
};
BaseEntity.prototype.set = function (values) {
}
set(values) {
Object.assign(this, values);
return this;
};
BaseEntity.prototype.save = function () {
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4 /*yield*/, this._saveInternal()];
case 1: return [2 /*return*/, _a.sent()];
}
});
}
save() {
return __awaiter(this, void 0, void 0, function* () {
return yield this._saveInternal();
});
};
BaseEntity.prototype.delete = function () {
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4 /*yield*/, this._deleteInternal({ forceDelete: false })];
case 1: return [2 /*return*/, _a.sent()];
}
});
}
delete() {
return __awaiter(this, void 0, void 0, function* () {
return yield this._deleteInternal({ forceDelete: false });
});
};
BaseEntity.prototype.forceDelete = function () {
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4 /*yield*/, this._deleteInternal({ forceDelete: true })];
case 1: return [2 /*return*/, _a.sent()];
}
});
}
forceDelete() {
return __awaiter(this, void 0, void 0, function* () {
return yield this._deleteInternal({ forceDelete: true });
});
};
BaseEntity.prototype.restore = function () {
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4 /*yield*/, this._saveInternal({ isRestore: true })];
case 1: return [2 /*return*/, _a.sent()];
}
});
}
restore() {
return __awaiter(this, void 0, void 0, function* () {
return yield this._saveInternal({ isRestore: true });
});
};
BaseEntity.prototype.clone = function () {
var entity = new this.constructor();
}
clone() {
const entity = new this.constructor();
entity.set(this.getValues());
return entity;
};
BaseEntity.prototype.toJSON = function () {
}
toJSON() {
return this.getValues();
};
}
// endregion
// region protected methods
BaseEntity.prototype.assignStorageStrings = function (storageStrings) {
assignStorageStrings(storageStrings) {
this._isNew = false;
this._storageStrings = storageStrings;
// we preserve default values by removing existing _values only
for (var _i = 0, _a = Object.keys(storageStrings); _i < _a.length; _i++) {
var column = _a[_i];
for (const column of Object.keys(storageStrings)) {
delete this._values[column];
}
};
}
// endregion
// region private methods: value get / set
BaseEntity.prototype._get = function (column) {
_get(column) {
if (!(column in this._values)) {
var schema = serviceInstance_1.serviceInstance.getSchema(this.constructor, column);
const schema = serviceInstance_1.serviceInstance.getSchema(this.constructor, column);
this._values[column] = parser_1.parser.parseStorageStringToValue(schema.type, this._storageStrings[column]);
}
return this._values[column];
};
BaseEntity.prototype._set = function (column, value, updateStorageString) {
if (updateStorageString === void 0) { updateStorageString = false; }
var schema = serviceInstance_1.serviceInstance.getSchema(this.constructor, column);
var storageString = parser_1.parser.parseValueToStorageString(schema.type, value);
}
_set(column, value, updateStorageString = false) {
const schema = serviceInstance_1.serviceInstance.getSchema(this.constructor, column);
const storageString = parser_1.parser.parseValueToStorageString(schema.type, value);
this._values[column] = parser_1.parser.parseStorageStringToValue(schema.type, storageString);

@@ -481,169 +321,152 @@ if (updateStorageString) {

}
};
}
// endregion
// region private methods: common
BaseEntity.prototype._saveInternal = function (_a) {
var _b = (_a === void 0 ? {} : _a).isRestore, isRestore = _b === void 0 ? false : _b;
return __awaiter(this, void 0, void 0, function () {
var changes, tableName, indexKeys, uniqueKeys, autoIncrementKey, entityId, params, redis, commandResult, saveResult, schemaErrors, _i, _c, _d, column, value, isNew;
return __generator(this, function (_e) {
switch (_e.label) {
case 0:
if (this.isDeleted && !isRestore) {
throw new RedisOrmEntityError_1.RedisOrmEntityError("(" + this.constructor.name + ") You cannot update a deleted entity");
}
changes = this._getChanges();
if (Object.keys(changes).length === 0) {
// no changes and no increments, no need to save
if (!isRestore && Object.keys(this._increments).length === 0) {
return [2 /*return*/, this];
}
}
// update updatedAt if user didn't update it explicitly
if (!changes.updatedAt) {
changes.updatedAt = parser_1.parser.parseValueToStorageString(Date, new Date());
}
// remove deletedAt for all situation
changes.deletedAt = parser_1.parser.parseValueToStorageString(Date, new Date(Number.NaN));
tableName = serviceInstance_1.serviceInstance.getTable(this.constructor);
indexKeys = serviceInstance_1.serviceInstance.getIndexKeys(this.constructor);
uniqueKeys = serviceInstance_1.serviceInstance.getUniqueKeys(this.constructor);
autoIncrementKey = serviceInstance_1.serviceInstance.getAutoIncrementKey(this.constructor);
entityId = "";
// we must assign an entity id for the following case
// - if it's not new
// - if it's not auto increment
// - if the auto increment key is not 0
if (!this.isNew || !autoIncrementKey || changes[autoIncrementKey] !== "0") {
entityId = this.getEntityId();
}
params = [
serviceInstance_1.serviceInstance.getSchemasJson(this.constructor),
entityId,
this.isNew,
tableName,
autoIncrementKey,
JSON.stringify(indexKeys),
JSON.stringify(uniqueKeys),
JSON.stringify(changes),
JSON.stringify(this._increments),
isRestore,
];
return [4 /*yield*/, serviceInstance_1.serviceInstance.getRedis(this.constructor)];
case 1:
redis = _e.sent();
return [4 /*yield*/, redis.commandAtomicSave([], params)];
case 2:
commandResult = _e.sent();
saveResult = JSON.parse(commandResult);
if (!saveResult.error) return [3 /*break*/, 5];
if (!(saveResult.error === "Invalid Schemas")) return [3 /*break*/, 4];
return [4 /*yield*/, serviceInstance_1.serviceInstance.compareSchemas(this.constructor)];
case 3:
schemaErrors = _e.sent();
throw new RedisOrmSchemaError_1.RedisOrmSchemaError("(" + this.constructor.name + ") " + saveResult.error, schemaErrors);
case 4: throw new RedisOrmEntityError_1.RedisOrmEntityError("(" + this.constructor.name + ") " + saveResult.error);
case 5:
// update storage strings
Object.assign(this._storageStrings, changes);
// if we do not have id and it's auto increment
if (this.isNew && autoIncrementKey && saveResult.autoIncrementKeyValue) {
this._set(autoIncrementKey, saveResult.autoIncrementKeyValue, true);
}
// if we have increment result
if (saveResult.increments) {
for (_i = 0, _c = Object.entries(saveResult.increments); _i < _c.length; _i++) {
_d = _c[_i], column = _d[0], value = _d[1];
this._set(column, value, true);
}
}
// clean up
this._increments = {};
this._values = {};
isNew = this._isNew;
this._isNew = false;
// fire event
if (isRestore) {
eventEmitters_1.eventEmitters.getEventEmitter(this.constructor).emit("restore", this);
}
else {
if (isNew) {
eventEmitters_1.eventEmitters.getEventEmitter(this.constructor).emit("create", this);
}
else {
eventEmitters_1.eventEmitters.getEventEmitter(this.constructor).emit("update", this);
}
}
return [2 /*return*/, this];
_saveInternal({ isRestore = false } = {}) {
return __awaiter(this, void 0, void 0, function* () {
if (this.isDeleted && !isRestore) {
throw new RedisOrmEntityError_1.RedisOrmEntityError(`(${this.constructor.name}) You cannot update a deleted entity`);
}
const changes = this._getChanges();
if (Object.keys(changes).length === 0) {
// no changes and no increments, no need to save
if (!isRestore && Object.keys(this._increments).length === 0) {
return this;
}
});
});
};
BaseEntity.prototype._deleteInternal = function (_a) {
var _b = (_a === void 0 ? {} : _a).forceDelete, forceDelete = _b === void 0 ? false : _b;
return __awaiter(this, void 0, void 0, function () {
var entityMeta, deletedAt, entityId, tableName, indexKeys, uniqueKeys, keys, params, redis, commandResult, saveResult;
return __generator(this, function (_c) {
switch (_c.label) {
case 0:
// checking
if (this.isNew) {
throw new RedisOrmEntityError_1.RedisOrmEntityError("(" + this.constructor.name + ") You cannot delete a new entity");
}
entityMeta = serviceInstance_1.serviceInstance.getEntityMeta(this.constructor);
if (!forceDelete && this.isDeleted) {
throw new RedisOrmEntityError_1.RedisOrmEntityError("(" + this.constructor.name + ") You cannot delete a deleted entity");
}
deletedAt = this.deletedAt;
if (isNaN(deletedAt.getTime())) {
deletedAt = new Date();
}
entityId = this.getEntityId();
tableName = serviceInstance_1.serviceInstance.getTable(this.constructor);
indexKeys = serviceInstance_1.serviceInstance.getIndexKeys(this.constructor);
uniqueKeys = serviceInstance_1.serviceInstance.getUniqueKeys(this.constructor);
keys = [];
params = [
serviceInstance_1.serviceInstance.getSchemasJson(this.constructor),
entityId,
!forceDelete,
tableName,
deletedAt.getTime(),
JSON.stringify(indexKeys),
JSON.stringify(uniqueKeys),
];
return [4 /*yield*/, serviceInstance_1.serviceInstance.getRedis(this.constructor)];
case 1:
redis = _c.sent();
return [4 /*yield*/, redis.commandAtomicDelete(keys, params)];
case 2:
commandResult = _c.sent();
saveResult = JSON.parse(commandResult);
// throw error if there is any
if (saveResult.error) {
throw new RedisOrmEntityError_1.RedisOrmEntityError("(" + this.constructor.name + ") " + saveResult.error);
}
// update deleted At
this._set("deletedAt", deletedAt, true);
// fire event
if (forceDelete) {
eventEmitters_1.eventEmitters.getEventEmitter(this.constructor).emit("forceDelete", this);
}
else {
eventEmitters_1.eventEmitters.getEventEmitter(this.constructor).emit("delete", this);
}
return [2 /*return*/, this];
}
// update updatedAt if user didn't update it explicitly
if (!changes.updatedAt) {
changes.updatedAt = parser_1.parser.parseValueToStorageString(Date, new Date());
}
// remove deletedAt for all situation
changes.deletedAt = parser_1.parser.parseValueToStorageString(Date, new Date(Number.NaN));
// prepare redis lua command parameters
const tableName = serviceInstance_1.serviceInstance.getTable(this.constructor);
const indexKeys = serviceInstance_1.serviceInstance.getIndexKeys(this.constructor);
const uniqueKeys = serviceInstance_1.serviceInstance.getUniqueKeys(this.constructor);
const autoIncrementKey = serviceInstance_1.serviceInstance.getAutoIncrementKey(this.constructor);
let entityId = "";
// we must assign an entity id for the following case
// - if it's not new
// - if it's not auto increment
// - if the auto increment key is not 0
if (!this.isNew || !autoIncrementKey || changes[autoIncrementKey] !== "0") {
entityId = this.getEntityId();
}
// prepare argument
const params = [
serviceInstance_1.serviceInstance.getSchemasJson(this.constructor),
entityId,
this.isNew,
tableName,
autoIncrementKey,
JSON.stringify(indexKeys),
JSON.stringify(uniqueKeys),
JSON.stringify(changes),
JSON.stringify(this._increments),
isRestore,
];
const redis = yield serviceInstance_1.serviceInstance.getRedis(this.constructor);
const commandResult = yield redis.commandAtomicSave([], params);
const saveResult = JSON.parse(commandResult);
if (saveResult.error) {
if (saveResult.error === "Invalid Schemas") {
const schemaErrors = yield serviceInstance_1.serviceInstance.compareSchemas(this.constructor);
throw new RedisOrmSchemaError_1.RedisOrmSchemaError(`(${this.constructor.name}) ${saveResult.error}`, schemaErrors);
}
});
else {
throw new RedisOrmEntityError_1.RedisOrmEntityError(`(${this.constructor.name}) ${saveResult.error}`);
}
}
// update storage strings
Object.assign(this._storageStrings, changes);
// if we do not have id and it's auto increment
if (this.isNew && autoIncrementKey && saveResult.autoIncrementKeyValue) {
this._set(autoIncrementKey, saveResult.autoIncrementKeyValue, true);
}
// if we have increment result
if (saveResult.increments) {
for (const [column, value] of Object.entries(saveResult.increments)) {
this._set(column, value, true);
}
}
// clean up
this._increments = {};
this._values = {};
// update the flags
const isNew = this._isNew;
this._isNew = false;
// fire event
if (isRestore) {
eventEmitters_1.eventEmitters.getEventEmitter(this.constructor).emit("restore", this);
}
else {
if (isNew) {
eventEmitters_1.eventEmitters.getEventEmitter(this.constructor).emit("create", this);
}
else {
eventEmitters_1.eventEmitters.getEventEmitter(this.constructor).emit("update", this);
}
}
return this;
});
};
BaseEntity.prototype._getChanges = function () {
var hasChanges = false;
var changes = {};
var schemas = serviceInstance_1.serviceInstance.getSchemas(this.constructor);
for (var _i = 0, _a = Object.entries(schemas); _i < _a.length; _i++) {
var _b = _a[_i], column = _b[0], schema = _b[1];
}
_deleteInternal({ forceDelete = false } = {}) {
return __awaiter(this, void 0, void 0, function* () {
// checking
if (this.isNew) {
throw new RedisOrmEntityError_1.RedisOrmEntityError(`(${this.constructor.name}) You cannot delete a new entity`);
}
// if it's soft delete
const entityMeta = serviceInstance_1.serviceInstance.getEntityMeta(this.constructor);
if (!forceDelete && this.isDeleted) {
throw new RedisOrmEntityError_1.RedisOrmEntityError(`(${this.constructor.name}) You cannot delete a deleted entity`);
}
// if we didn't set deletedAt, set a new one
let deletedAt = this.deletedAt;
if (isNaN(deletedAt.getTime())) {
deletedAt = new Date();
}
// prepare redis lua command parameters
const entityId = this.getEntityId();
const tableName = serviceInstance_1.serviceInstance.getTable(this.constructor);
const indexKeys = serviceInstance_1.serviceInstance.getIndexKeys(this.constructor);
const uniqueKeys = serviceInstance_1.serviceInstance.getUniqueKeys(this.constructor);
const keys = [];
const params = [
serviceInstance_1.serviceInstance.getSchemasJson(this.constructor),
entityId,
!forceDelete,
tableName,
deletedAt.getTime(),
JSON.stringify(indexKeys),
JSON.stringify(uniqueKeys),
];
const redis = yield serviceInstance_1.serviceInstance.getRedis(this.constructor);
const commandResult = yield redis.commandAtomicDelete(keys, params);
const saveResult = JSON.parse(commandResult);
// throw error if there is any
if (saveResult.error) {
throw new RedisOrmEntityError_1.RedisOrmEntityError(`(${this.constructor.name}) ${saveResult.error}`);
}
// update deleted At
this._set("deletedAt", deletedAt, true);
// fire event
if (forceDelete) {
eventEmitters_1.eventEmitters.getEventEmitter(this.constructor).emit("forceDelete", this);
}
else {
eventEmitters_1.eventEmitters.getEventEmitter(this.constructor).emit("delete", this);
}
return this;
});
}
_getChanges() {
let hasChanges = false;
const changes = {};
const schemas = serviceInstance_1.serviceInstance.getSchemas(this.constructor);
for (const [column, schema] of Object.entries(schemas)) {
// if no such value before, it must be a changes
var currentValue = this._get(column);
var storageString = parser_1.parser.parseValueToStorageString(schema.type, currentValue);
const currentValue = this._get(column);
const storageString = parser_1.parser.parseValueToStorageString(schema.type, currentValue);
if (!(column in this._storageStrings) || storageString !== this._storageStrings[column]) {

@@ -655,5 +478,4 @@ changes[column] = storageString;

return changes;
};
return BaseEntity;
}());
}
}
exports.BaseEntity = BaseEntity;

26

build/configLoader.js

@@ -10,12 +10,10 @@ "use strict";

Object.defineProperty(exports, "__esModule", { value: true });
var fs = __importStar(require("fs"));
var path = __importStar(require("path"));
var ConfigLoader = /** @class */ (function () {
function ConfigLoader() {
}
ConfigLoader.prototype.getConfigFile = function () {
var name = process.env.NODE_ENV || "default";
var configFiles = ["redisorm.default.json"];
const fs = __importStar(require("fs"));
const path = __importStar(require("path"));
class ConfigLoader {
getConfigFile() {
const name = process.env.NODE_ENV || "default";
let configFiles = [`redisorm.default.json`];
if (process.env.NODE_ENV) {
configFiles.push("redisorm." + name + ".json");
configFiles.push(`redisorm.${name}.json`);
}

@@ -25,6 +23,5 @@ if (process.env.REDISORM_CONFIG_PATH) {

}
for (var _i = 0, configFiles_1 = configFiles; _i < configFiles_1.length; _i++) {
var configFile = configFiles_1[_i];
for (const configFile of configFiles) {
try {
var result = fs.accessSync(configFile, fs.constants.F_OK);
const result = fs.accessSync(configFile, fs.constants.F_OK);
return path.join(process.cwd(), configFile);

@@ -37,5 +34,4 @@ }

return null;
};
return ConfigLoader;
}());
}
}
exports.configLoader = new ConfigLoader();

33

build/decorators/Column.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
require("reflect-metadata");
var __1 = require("..");
var serviceInstance_1 = require("../serviceInstance");
const __1 = require("..");
const serviceInstance_1 = require("../serviceInstance");
function validSchema(target, schema) {
// only one schema
var autoIncrementKey = serviceInstance_1.serviceInstance.getAutoIncrementKey(target);
const autoIncrementKey = serviceInstance_1.serviceInstance.getAutoIncrementKey(target);
if (autoIncrementKey) {
if (schema.autoIncrement) {
throw new __1.RedisOrmDecoratorError("(" + target.name + ") AutoIncrement already exist for column: " + autoIncrementKey);
throw new __1.RedisOrmDecoratorError(`(${target.name}) AutoIncrement already exist for column: ${autoIncrementKey}`);
}
if (schema.primary) {
throw new __1.RedisOrmDecoratorError("(" + target.name + ") AutoIncrement can only work with one primary key");
throw new __1.RedisOrmDecoratorError(`(${target.name}) AutoIncrement can only work with one primary key`);
}
}
if (schema.autoIncrement && !schema.primary) {
throw new __1.RedisOrmDecoratorError("(" + target.name + ") AutoIncrement needs pair up with primary key");
throw new __1.RedisOrmDecoratorError(`(${target.name}) AutoIncrement needs pair up with primary key`);
}
if (schema.primary) {
if (schema.type !== String && schema.type !== Number) {
throw new __1.RedisOrmDecoratorError("(" + target.name + ") Primary key only supports String or Number");
throw new __1.RedisOrmDecoratorError(`(${target.name}) Primary key only supports String or Number`);
}

@@ -27,3 +27,3 @@ }

if (schema.type !== Number && schema.type !== Boolean && schema.type !== Date) {
throw new __1.RedisOrmDecoratorError("(" + target.name + ") Index only supports Number, Boolean or Date");
throw new __1.RedisOrmDecoratorError(`(${target.name}) Index only supports Number, Boolean or Date`);
}

@@ -33,12 +33,11 @@ }

if (schema.type !== String && schema.type !== Number) {
throw new __1.RedisOrmDecoratorError("(" + target.name + ") Unique only supports String or Number");
throw new __1.RedisOrmDecoratorError(`(${target.name}) Unique only supports String or Number`);
}
}
}
function Column(schema) {
if (schema === void 0) { schema = {}; }
return function (target, propertyKey) {
var propertyType = Reflect.getMetadata("design:type", target, propertyKey);
var propertyType1 = Reflect.getMetadataKeys(target, propertyKey);
var newSchema = {
function Column(schema = {}) {
return (target, propertyKey) => {
const propertyType = Reflect.getMetadata("design:type", target, propertyKey);
const propertyType1 = Reflect.getMetadataKeys(target, propertyKey);
let newSchema = {
type: propertyType,

@@ -58,6 +57,6 @@ primary: false,

Object.defineProperty(target.constructor.prototype, propertyKey, {
get: function () {
get() {
return this._get(propertyKey);
},
set: function (value) {
set(value) {
return this._set(propertyKey, value);

@@ -64,0 +63,0 @@ },

30

build/decorators/Entity.js
"use strict";
var __assign = (this && this.__assign) || function () {
__assign = Object.assign || function(t) {
for (var s, i = 1, n = arguments.length; i < n; i++) {
s = arguments[i];
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
t[p] = s[p];
}
return t;
};
return __assign.apply(this, arguments);
};
Object.defineProperty(exports, "__esModule", { value: true });
var __1 = require("..");
var serviceInstance_1 = require("../serviceInstance");
function Entity(entityMeta) {
if (entityMeta === void 0) { entityMeta = {}; }
return function (target) {
const __1 = require("..");
const serviceInstance_1 = require("../serviceInstance");
function Entity(entityMeta = {}) {
return (target) => {
// add entity meta
var newEntityMeta = {
let newEntityMeta = {
table: "",

@@ -29,3 +17,3 @@ connection: "default",

// add createdAt, updatedAt and deletedAt
var schema = {
const schema = {
type: Date,

@@ -38,8 +26,8 @@ primary: false,

serviceInstance_1.serviceInstance.addColumn(target, "createdAt", schema);
serviceInstance_1.serviceInstance.addColumn(target, "updatedAt", __assign(__assign({}, schema), { index: newEntityMeta.indexUpdatedAt }));
serviceInstance_1.serviceInstance.addColumn(target, "updatedAt", Object.assign(Object.assign({}, schema), { index: newEntityMeta.indexUpdatedAt }));
serviceInstance_1.serviceInstance.addColumn(target, "deletedAt", schema);
// validate from entity
var primaryKeys = serviceInstance_1.serviceInstance.getPrimaryKeys(target);
const primaryKeys = serviceInstance_1.serviceInstance.getPrimaryKeys(target);
if (primaryKeys.length === 0) {
throw new __1.RedisOrmDecoratorError("(" + target.name + ") No primary keys exist for this entity");
throw new __1.RedisOrmDecoratorError(`(${target.name}) No primary keys exist for this entity`);
}

@@ -46,0 +34,0 @@ };

295

build/entityExporter.js

@@ -11,29 +11,2 @@ "use strict";

};
var __generator = (this && this.__generator) || function (thisArg, body) {
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
function verb(n) { return function (v) { return step([n, v]); }; }
function step(op) {
if (f) throw new TypeError("Generator is already executing.");
while (_) try {
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
if (y = 0, t) op = [op[0] & 2, t.value];
switch (op[0]) {
case 0: case 1: t = op; break;
case 4: _.label++; return { value: op[1], done: false };
case 5: _.label++; y = op[1]; op = [0]; continue;
case 7: op = _.ops.pop(); _.trys.pop(); continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
if (t[2]) _.ops.pop();
_.trys.pop(); continue;
}
op = body.call(thisArg, _);
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
}
};
var __importDefault = (this && this.__importDefault) || function (mod) {

@@ -50,13 +23,11 @@ return (mod && mod.__esModule) ? mod : { "default": mod };

Object.defineProperty(exports, "__esModule", { value: true });
var fs_1 = __importDefault(require("fs"));
var readline = __importStar(require("readline"));
var serviceInstance_1 = require("./serviceInstance");
var EntityExporter = /** @class */ (function () {
function EntityExporter() {
}
EntityExporter.prototype.exportEntities = function (entityType, entities, file) {
return new Promise(function (resolve, reject) {
var writeStream = fs_1.default.createWriteStream(file, { encoding: "utf-8" });
const fs_1 = __importDefault(require("fs"));
const readline = __importStar(require("readline"));
const serviceInstance_1 = require("./serviceInstance");
class EntityExporter {
exportEntities(entityType, entities, file) {
return new Promise((resolve, reject) => {
const writeStream = fs_1.default.createWriteStream(file, { encoding: "utf-8" });
// write the meta
var meta = {
const meta = {
createdAt: new Date(),

@@ -70,10 +41,9 @@ class: entityType.name,

// write all the models
for (var _i = 0, entities_1 = entities; _i < entities_1.length; _i++) {
var entity = entities_1[_i];
for (const entity of entities) {
writeStream.write(JSON.stringify(entity.getValues()) + "\r\n");
}
writeStream.on("error", function (err) {
writeStream.on("error", err => {
reject(err);
});
writeStream.on("finish", function () {
writeStream.on("finish", () => {
resolve();

@@ -83,144 +53,127 @@ });

});
};
EntityExporter.prototype.import = function (entityType, file, skipSchemasCheck) {
if (skipSchemasCheck === void 0) { skipSchemasCheck = false; }
return __awaiter(this, void 0, void 0, function () {
var readStream, r1;
return __generator(this, function (_a) {
readStream = fs_1.default.createReadStream(file, { encoding: "utf8" });
r1 = readline.createInterface({ input: readStream });
return [2 /*return*/, new Promise(function (resolve, reject) {
var valuesList = [];
var meta = null;
var closed = false;
var saveModelPromise = null;
var promiseRunning = false;
var currentError = null;
function checkComplete() {
if (closed) {
r1.removeAllListeners();
r1.close();
readStream.close();
if (!promiseRunning) {
resolve(true);
}
}
}
import(entityType, file, skipSchemasCheck = false) {
return __awaiter(this, void 0, void 0, function* () {
const readStream = fs_1.default.createReadStream(file, { encoding: "utf8" });
const r1 = readline.createInterface({ input: readStream });
return new Promise((resolve, reject) => {
const valuesList = [];
let meta = null;
let closed = false;
const saveModelPromise = null;
let promiseRunning = false;
let currentError = null;
function checkComplete() {
if (closed) {
r1.removeAllListeners();
r1.close();
readStream.close();
if (!promiseRunning) {
resolve(true);
}
function checkError() {
if (currentError) {
r1.removeAllListeners();
r1.close();
readStream.close();
if (!promiseRunning) {
reject(currentError);
}
}
function checkError() {
if (currentError) {
r1.removeAllListeners();
r1.close();
readStream.close();
if (!promiseRunning) {
reject(currentError);
}
}
}
function saveEntity() {
if (!promiseRunning) {
promiseRunning = true;
asyncSaveModel().then(() => {
promiseRunning = false;
checkError();
checkComplete();
r1.resume();
}).catch(err => {
promiseRunning = false;
currentError = err;
checkError();
});
}
}
function asyncSaveModel() {
return __awaiter(this, void 0, void 0, function* () {
while (valuesList.length > 0) {
const values = valuesList.shift();
try {
const entity = new entityType();
entity.set(values);
yield entity.save();
if (values.deletedAt) {
const deletedAt = new Date(values.deletedAt);
if (!isNaN(Number(deletedAt))) {
entity.deletedAt = deletedAt;
yield entity.delete();
}
}
}
}
function saveEntity() {
if (!promiseRunning) {
promiseRunning = true;
asyncSaveModel().then(function () {
promiseRunning = false;
checkError();
checkComplete();
r1.resume();
}).catch(function (err) {
promiseRunning = false;
currentError = err;
checkError();
});
catch (err) {
err.message = `data: ${JSON.stringify(values)}\r\n` + err.message;
throw err;
}
}
function asyncSaveModel() {
return __awaiter(this, void 0, void 0, function () {
var values, entity, deletedAt, err_1;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
if (!(valuesList.length > 0)) return [3 /*break*/, 7];
values = valuesList.shift();
_a.label = 1;
case 1:
_a.trys.push([1, 5, , 6]);
entity = new entityType();
entity.set(values);
return [4 /*yield*/, entity.save()];
case 2:
_a.sent();
if (!values.deletedAt) return [3 /*break*/, 4];
deletedAt = new Date(values.deletedAt);
if (!!isNaN(Number(deletedAt))) return [3 /*break*/, 4];
entity.deletedAt = deletedAt;
return [4 /*yield*/, entity.delete()];
case 3:
_a.sent();
_a.label = 4;
case 4: return [3 /*break*/, 6];
case 5:
err_1 = _a.sent();
err_1.message = "data: " + JSON.stringify(values) + "\r\n" + err_1.message;
throw err_1;
case 6: return [3 /*break*/, 0];
case 7: return [2 /*return*/];
}
});
});
});
}
r1.on("line", data => {
r1.pause();
// the first line will be meta
if (!meta) {
try {
meta = JSON.parse(data);
r1.resume();
}
r1.on("line", function (data) {
r1.pause();
// the first line will be meta
if (!meta) {
try {
meta = JSON.parse(data);
r1.resume();
}
catch (err) {
err.message = "data: " + data + "\r\n" + err.message;
currentError = err;
checkError();
}
if (!skipSchemasCheck) {
var className = entityType.name;
var clientSchemas = serviceInstance_1.serviceInstance.getSchemasJson(entityType);
if (meta.class !== className) {
var err = new Error();
err.message = "Class name: " + className + " does not match with the import file: " + meta.class;
currentError = err;
checkError();
}
else if (meta.schemas !== clientSchemas) {
var err = new Error();
err.message = "Current Schemas: " + clientSchemas + " does not match with the import file: " + meta.schemas;
currentError = err;
checkError();
}
}
catch (err) {
err.message = `data: ${data}\r\n` + err.message;
currentError = err;
checkError();
}
if (!skipSchemasCheck) {
const className = entityType.name;
const clientSchemas = serviceInstance_1.serviceInstance.getSchemasJson(entityType);
if (meta.class !== className) {
const err = new Error();
err.message = `Class name: ${className} does not match with the import file: ${meta.class}`;
currentError = err;
checkError();
}
else {
try {
var values = JSON.parse(data);
valuesList.push(values);
saveEntity();
}
catch (err) {
err.message = "data: " + data + "\r\n" + err.message;
currentError = err;
checkError();
}
else if (meta.schemas !== clientSchemas) {
const err = new Error();
err.message = `Current Schemas: ${clientSchemas} does not match with the import file: ${meta.schemas}`;
currentError = err;
checkError();
}
});
r1.on("error", function (err) {
}
}
else {
try {
const values = JSON.parse(data);
valuesList.push(values);
saveEntity();
}
catch (err) {
err.message = `data: ${data}\r\n` + err.message;
currentError = err;
checkError();
});
r1.on("close", function () {
closed = true;
checkComplete();
});
})];
}
}
});
r1.on("error", err => {
currentError = err;
checkError();
});
r1.on("close", () => {
closed = true;
checkComplete();
});
});
});
};
return EntityExporter;
}());
}
}
exports.entityExporter = new EntityExporter();

26

build/errors/RedisOrmDecoratorError.js
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var RedisOrmDecoratorError = /** @class */ (function (_super) {
__extends(RedisOrmDecoratorError, _super);
function RedisOrmDecoratorError(message) {
var _this = _super.call(this, message) || this;
Object.setPrototypeOf(_this, RedisOrmDecoratorError.prototype);
return _this;
class RedisOrmDecoratorError extends Error {
constructor(message) {
super(message);
Object.setPrototypeOf(this, RedisOrmDecoratorError.prototype);
}
return RedisOrmDecoratorError;
}(Error));
}
exports.RedisOrmDecoratorError = RedisOrmDecoratorError;

26

build/errors/RedisOrmEntityError.js
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var RedisOrmEntityError = /** @class */ (function (_super) {
__extends(RedisOrmEntityError, _super);
function RedisOrmEntityError(message) {
var _this = _super.call(this, message) || this;
Object.setPrototypeOf(_this, RedisOrmEntityError.prototype);
return _this;
class RedisOrmEntityError extends Error {
constructor(message) {
super(message);
Object.setPrototypeOf(this, RedisOrmEntityError.prototype);
}
return RedisOrmEntityError;
}(Error));
}
exports.RedisOrmEntityError = RedisOrmEntityError;

26

build/errors/RedisOrmQueryError.js
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var RedisOrmQueryError = /** @class */ (function (_super) {
__extends(RedisOrmQueryError, _super);
function RedisOrmQueryError(message) {
var _this = _super.call(this, message) || this;
Object.setPrototypeOf(_this, RedisOrmQueryError.prototype);
return _this;
class RedisOrmQueryError extends Error {
constructor(message) {
super(message);
Object.setPrototypeOf(this, RedisOrmQueryError.prototype);
}
return RedisOrmQueryError;
}(Error));
}
exports.RedisOrmQueryError = RedisOrmQueryError;

28

build/errors/RedisOrmSchemaError.js
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var RedisOrmSchemaError = /** @class */ (function (_super) {
__extends(RedisOrmSchemaError, _super);
function RedisOrmSchemaError(message, errors) {
var _this = _super.call(this, message) || this;
_this.errors = errors;
Object.setPrototypeOf(_this, RedisOrmSchemaError.prototype);
return _this;
class RedisOrmSchemaError extends Error {
constructor(message, errors) {
super(message);
this.errors = errors;
Object.setPrototypeOf(this, RedisOrmSchemaError.prototype);
}
return RedisOrmSchemaError;
}(Error));
}
exports.RedisOrmSchemaError = RedisOrmSchemaError;

13

build/eventEmitters.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var events_1 = require("events");
var EventEmitters = /** @class */ (function () {
function EventEmitters() {
const events_1 = require("events");
class EventEmitters {
constructor() {
this._eventEmitters = new Map();
}
EventEmitters.prototype.getEventEmitter = function (target) {
getEventEmitter(target) {
if (!this._eventEmitters.has(target)) {

@@ -13,5 +13,4 @@ this._eventEmitters.set(target, new events_1.EventEmitter());

return this._eventEmitters.get(target);
};
return EventEmitters;
}());
}
}
exports.eventEmitters = new EventEmitters();

16

build/index.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var BaseEntity_1 = require("./BaseEntity");
const BaseEntity_1 = require("./BaseEntity");
exports.BaseEntity = BaseEntity_1.BaseEntity;
var Column_1 = require("./decorators/Column");
const Column_1 = require("./decorators/Column");
exports.Column = Column_1.Column;
var Entity_1 = require("./decorators/Entity");
const Entity_1 = require("./decorators/Entity");
exports.Entity = Entity_1.Entity;
var RedisOrmDecoratorError_1 = require("./errors/RedisOrmDecoratorError");
const RedisOrmDecoratorError_1 = require("./errors/RedisOrmDecoratorError");
exports.RedisOrmDecoratorError = RedisOrmDecoratorError_1.RedisOrmDecoratorError;
var RedisOrmEntityError_1 = require("./errors/RedisOrmEntityError");
const RedisOrmEntityError_1 = require("./errors/RedisOrmEntityError");
exports.RedisOrmEntityError = RedisOrmEntityError_1.RedisOrmEntityError;
var RedisOrmQueryError_1 = require("./errors/RedisOrmQueryError");
const RedisOrmQueryError_1 = require("./errors/RedisOrmQueryError");
exports.RedisOrmQueryError = RedisOrmQueryError_1.RedisOrmQueryError;
var RedisOrmSchemaError_1 = require("./errors/RedisOrmSchemaError");
const RedisOrmSchemaError_1 = require("./errors/RedisOrmSchemaError");
exports.RedisOrmSchemaError = RedisOrmSchemaError_1.RedisOrmSchemaError;
var Query_1 = require("./Query");
const Query_1 = require("./Query");
exports.Query = Query_1.Query;

23

build/parser.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var Parser = /** @class */ (function () {
function Parser() {
}
Parser.prototype.parseStorageStringToValue = function (type, storageString) {
var value;
class Parser {
parseStorageStringToValue(type, storageString) {
let value;
switch (type) {

@@ -23,3 +21,3 @@ case String:

try {
var temp = JSON.parse(storageString);
const temp = JSON.parse(storageString);
if (Array.isArray(temp)) {

@@ -46,5 +44,5 @@ value = temp;

return value;
};
Parser.prototype.parseValueToStorageString = function (type, value) {
var storageString = "";
}
parseValueToStorageString(type, value) {
let storageString = "";
switch (type) {

@@ -61,3 +59,3 @@ case String:

case Date:
var temp1 = void 0;
let temp1;
if (value === "now") {

@@ -87,5 +85,4 @@ temp1 = Number(new Date());

return storageString;
};
return Parser;
}());
}
}
exports.parser = new Parser();

858

build/Query.js

@@ -11,36 +11,2 @@ "use strict";

};
var __generator = (this && this.__generator) || function (thisArg, body) {
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
function verb(n) { return function (v) { return step([n, v]); }; }
function step(op) {
if (f) throw new TypeError("Generator is already executing.");
while (_) try {
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
if (y = 0, t) op = [op[0] & 2, t.value];
switch (op[0]) {
case 0: case 1: t = op; break;
case 4: _.label++; return { value: op[1], done: false };
case 5: _.label++; y = op[1]; op = [0]; continue;
case 7: op = _.ops.pop(); _.trys.pop(); continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
if (t[2]) _.ops.pop();
_.trys.pop(); continue;
}
op = body.call(thisArg, _);
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
}
};
var __spreadArrays = (this && this.__spreadArrays) || function () {
for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
for (var r = Array(s), k = 0, i = 0; i < il; i++)
for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
r[k] = a[j];
return r;
};
var __importDefault = (this && this.__importDefault) || function (mod) {

@@ -50,9 +16,9 @@ return (mod && mod.__esModule) ? mod : { "default": mod };

Object.defineProperty(exports, "__esModule", { value: true });
var debug_1 = __importDefault(require("debug"));
var RedisOrmQueryError_1 = require("./errors/RedisOrmQueryError");
var parser_1 = require("./parser");
var serviceInstance_1 = require("./serviceInstance");
var debug = debug_1.default("tsredisorm/performance");
var Query = /** @class */ (function () {
function Query(_entityType) {
const debug_1 = __importDefault(require("debug"));
const RedisOrmQueryError_1 = require("./errors/RedisOrmQueryError");
const parser_1 = require("./parser");
const serviceInstance_1 = require("./serviceInstance");
const debug = debug_1.default("tsredisorm/performance");
class Query {
constructor(_entityType) {
this._entityType = _entityType;

@@ -71,156 +37,102 @@ this._onlyDeleted = false;

// region find
Query.prototype.find = function (idObject) {
return __awaiter(this, void 0, void 0, function () {
var entityId, primaryKeys, entity, entityStorageKey, redis, storageStrings_1;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
this._timerStart("find");
entityId = serviceInstance_1.serviceInstance.convertAsEntityId(this._entityType, idObject);
primaryKeys = serviceInstance_1.serviceInstance.getPrimaryKeys(this._entityType);
if (!entityId) return [3 /*break*/, 3];
entityStorageKey = serviceInstance_1.serviceInstance.getEntityStorageKey(this._entityType, entityId);
if (!entityStorageKey) {
throw new RedisOrmQueryError_1.RedisOrmQueryError("(" + this._entityType.name + ") Invalid id " + JSON.stringify(idObject));
}
return [4 /*yield*/, this._getRedis()];
case 1:
redis = _a.sent();
return [4 /*yield*/, redis.hgetall(entityStorageKey)];
case 2:
storageStrings_1 = _a.sent();
if (primaryKeys.every(function (primaryKey) { return primaryKey in storageStrings_1; })) {
if ((storageStrings_1.deletedAt !== "NaN") === this._onlyDeleted) {
entity = this._entityType.newFromStorageStrings(storageStrings_1);
}
}
_a.label = 3;
case 3:
this._timerEndCustom("find", "id: " + JSON.stringify(idObject));
return [2 /*return*/, entity];
find(idObject) {
return __awaiter(this, void 0, void 0, function* () {
this._timerStart("find");
const entityId = serviceInstance_1.serviceInstance.convertAsEntityId(this._entityType, idObject);
const primaryKeys = serviceInstance_1.serviceInstance.getPrimaryKeys(this._entityType);
// if we have a valid entity id
let entity;
if (entityId) {
const entityStorageKey = serviceInstance_1.serviceInstance.getEntityStorageKey(this._entityType, entityId);
if (!entityStorageKey) {
throw new RedisOrmQueryError_1.RedisOrmQueryError(`(${this._entityType.name}) Invalid id ${JSON.stringify(idObject)}`);
}
});
});
};
Query.prototype.findMany = function (idObjects) {
return __awaiter(this, void 0, void 0, function () {
var promises, _i, idObjects_1, idObject, result, entities;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
this._timerStart("findMany");
promises = [];
for (_i = 0, idObjects_1 = idObjects; _i < idObjects_1.length; _i++) {
idObject = idObjects_1[_i];
promises.push(this.find(idObject));
}
return [4 /*yield*/, Promise.all(promises)];
case 1:
result = _a.sent();
entities = result.filter(function (x) { return x; });
this._timerEndCustom("findMany", "Total Id: " + idObjects.length);
return [2 /*return*/, entities];
// we need to make sure if have all the keys exist in the storage strings
const redis = yield this._getRedis();
const storageStrings = yield redis.hgetall(entityStorageKey);
if (primaryKeys.every(primaryKey => primaryKey in storageStrings)) {
if ((storageStrings.deletedAt !== "NaN") === this._onlyDeleted) {
entity = this._entityType.newFromStorageStrings(storageStrings);
}
}
});
}
this._timerEndCustom("find", `id: ${JSON.stringify(idObject)}`);
return entity;
});
};
Query.prototype.findUnique = function (column, value) {
return __awaiter(this, void 0, void 0, function () {
var redis, id, entity;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
this._timerStart("findUnique");
if (!serviceInstance_1.serviceInstance.isUniqueKey(this._entityType, column)) {
throw new RedisOrmQueryError_1.RedisOrmQueryError("(" + this._entityType.name + ") Invalid unique column: " + column);
}
return [4 /*yield*/, this._getRedis()];
case 1:
redis = _a.sent();
return [4 /*yield*/, redis.hget(serviceInstance_1.serviceInstance.getUniqueStorageKey(this._entityType, column), value.toString())];
case 2:
id = _a.sent();
if (!id) return [3 /*break*/, 4];
return [4 /*yield*/, this.find(id)];
case 3:
entity = _a.sent();
_a.label = 4;
case 4:
this._timerEndCustom("findUnique", "Column: " + column + ", Value: " + value);
return [2 /*return*/, entity];
}
});
}
findMany(idObjects) {
return __awaiter(this, void 0, void 0, function* () {
this._timerStart("findMany");
const promises = [];
for (const idObject of idObjects) {
promises.push(this.find(idObject));
}
const result = yield Promise.all(promises);
const entities = result.filter(x => x);
this._timerEndCustom("findMany", `Total Id: ${idObjects.length}`);
return entities;
});
};
Query.prototype.findUniqueMany = function (column, values) {
return __awaiter(this, void 0, void 0, function () {
var promises, _i, values_1, value, result, entities;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
this._timerStart("findUniqueMany");
promises = [];
for (_i = 0, values_1 = values; _i < values_1.length; _i++) {
value = values_1[_i];
promises.push(this.findUnique(column, value));
}
return [4 /*yield*/, Promise.all(promises)];
case 1:
result = _a.sent();
entities = result.filter(function (x) { return x; });
this._timerEndCustom("findUniqueMany", "Column: " + column + ", Total values: " + values.length);
return [2 /*return*/, entities];
}
});
}
findUnique(column, value) {
return __awaiter(this, void 0, void 0, function* () {
this._timerStart("findUnique");
if (!serviceInstance_1.serviceInstance.isUniqueKey(this._entityType, column)) {
throw new RedisOrmQueryError_1.RedisOrmQueryError(`(${this._entityType.name}) Invalid unique column: ${column}`);
}
const redis = yield this._getRedis();
const id = yield redis.hget(serviceInstance_1.serviceInstance.getUniqueStorageKey(this._entityType, column), value.toString());
let entity;
if (id) {
entity = yield this.find(id);
}
this._timerEndCustom("findUnique", `Column: ${column}, Value: ${value}`);
return entity;
});
};
}
findUniqueMany(column, values) {
return __awaiter(this, void 0, void 0, function* () {
this._timerStart("findUniqueMany");
const promises = [];
for (const value of values) {
promises.push(this.findUnique(column, value));
}
const result = yield Promise.all(promises);
const entities = result.filter(x => x);
this._timerEndCustom("findUniqueMany", `Column: ${column}, Total values: ${values.length}`);
return entities;
});
}
// endregion
// region take
Query.prototype.first = function () {
return __awaiter(this, void 0, void 0, function () {
var entities;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
this.offset(0);
this.limit(1);
return [4 /*yield*/, this.get()];
case 1:
entities = _a.sent();
return [2 /*return*/, entities.length ? entities[0] : undefined];
}
});
first() {
return __awaiter(this, void 0, void 0, function* () {
this.offset(0);
this.limit(1);
const entities = yield this.get();
return entities.length ? entities[0] : undefined;
});
};
Query.prototype.get = function () {
return __awaiter(this, void 0, void 0, function () {
var result;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
this._timerStart("get");
return [4 /*yield*/, this._get()];
case 1:
result = _a.sent();
this._timerEnd("get");
return [2 /*return*/, result];
}
});
}
get() {
return __awaiter(this, void 0, void 0, function* () {
this._timerStart("get");
const result = yield this._get();
this._timerEnd("get");
return result;
});
};
Query.prototype.where = function (column, operator, value) {
var columnString = column;
}
where(column, operator, value) {
const columnString = column;
if (serviceInstance_1.serviceInstance.isIndexKey(this._entityType, columnString)) {
if (this._onlyDeleted) {
throw new RedisOrmQueryError_1.RedisOrmQueryError("(" + this._entityType.name + ") You cannot apply extra where indexing clause for only deleted query");
throw new RedisOrmQueryError_1.RedisOrmQueryError(`(${this._entityType.name}) You cannot apply extra where indexing clause for only deleted query`);
}
if (!serviceInstance_1.serviceInstance.isIndexKey(this._entityType, columnString)) {
throw new RedisOrmQueryError_1.RedisOrmQueryError("(" + this._entityType.name + ") Invalid index column: " + column);
throw new RedisOrmQueryError_1.RedisOrmQueryError(`(${this._entityType.name}) Invalid index column: ${column}`);
}
// convert value into string value
if (value !== "-inf" && value !== "+inf") {
var schema = serviceInstance_1.serviceInstance.getSchema(this._entityType, columnString);
const schema = serviceInstance_1.serviceInstance.getSchema(this._entityType, columnString);
value = parser_1.parser.parseValueToStorageString(schema.type, value);
}
var whereIndexType = { min: "-inf", max: "+inf" };
let whereIndexType = { min: "-inf", max: "+inf" };
if (columnString in this._whereIndexes) {

@@ -247,3 +159,3 @@ whereIndexType = this._whereIndexes[columnString];

default:
throw new RedisOrmQueryError_1.RedisOrmQueryError("(" + this._entityType.name + ") Invalid operator (" + operator + ") for index column: " + column);
throw new RedisOrmQueryError_1.RedisOrmQueryError(`(${this._entityType.name}) Invalid operator (${operator}) for index column: ${column}`);
}

@@ -254,17 +166,17 @@ this._whereIndexes[columnString] = whereIndexType;

if (!["=", "!=", "like"].includes(operator)) {
throw new RedisOrmQueryError_1.RedisOrmQueryError("(" + this._entityType.name + ") Invalid operator (" + operator + ") for non index column: " + column);
throw new RedisOrmQueryError_1.RedisOrmQueryError(`(${this._entityType.name}) Invalid operator (${operator}) for non index column: ${column}`);
}
// convert value into string value
var schema = serviceInstance_1.serviceInstance.getSchema(this._entityType, columnString);
const schema = serviceInstance_1.serviceInstance.getSchema(this._entityType, columnString);
value = parser_1.parser.parseValueToStorageString(schema.type, value);
this._whereSearches[columnString] = { operator: operator, value: value };
this._whereSearches[columnString] = { operator: operator, value };
}
else {
throw new RedisOrmQueryError_1.RedisOrmQueryError("(" + this._entityType.name + ") Invalid search column: " + column);
throw new RedisOrmQueryError_1.RedisOrmQueryError(`(${this._entityType.name}) Invalid search column: ${column}`);
}
return this;
};
Query.prototype.onlyDeleted = function () {
}
onlyDeleted() {
if (Object.keys(this._whereIndexes).length > 0) {
throw new RedisOrmQueryError_1.RedisOrmQueryError("(" + this._entityType.name + ") You cannot apply extra where indexing clause for only deleted query");
throw new RedisOrmQueryError_1.RedisOrmQueryError(`(${this._entityType.name}) You cannot apply extra where indexing clause for only deleted query`);
}

@@ -275,363 +187,258 @@ this.where("deletedAt", "<=", "+inf");

return this;
};
Query.prototype.sortBy = function (column, order) {
}
sortBy(column, order) {
if (this._sortBy !== null) {
throw new RedisOrmQueryError_1.RedisOrmQueryError("(" + this._entityType.name + ") You can only order by 1 column");
throw new RedisOrmQueryError_1.RedisOrmQueryError(`(${this._entityType.name}) You can only order by 1 column`);
}
if (!serviceInstance_1.serviceInstance.isSortableColumn(this._entityType, column)) {
throw new RedisOrmQueryError_1.RedisOrmQueryError("(" + this._entityType.name + ") Not sortable Column: " + column + ". You can only sort column type of Number, Boolean or Date");
throw new RedisOrmQueryError_1.RedisOrmQueryError(`(${this._entityType.name}) Not sortable Column: ${column}. You can only sort column type of Number, Boolean or Date`);
}
this._sortBy = { column: column, order: order };
this._sortBy = { column: column, order };
return this;
};
Query.prototype.offset = function (value) {
}
offset(value) {
this._offset = value;
return this;
};
Query.prototype.limit = function (value) {
}
limit(value) {
this._limit = value;
return this;
};
Query.prototype.take = function (value) {
}
take(value) {
this._limit = value;
this._offset = 0;
return this;
};
Query.prototype.groupBy = function (column) {
}
groupBy(column) {
if (this._groupByColumn !== null) {
throw new RedisOrmQueryError_1.RedisOrmQueryError("(" + this._entityType.name + ") You can only group by 1 column");
throw new RedisOrmQueryError_1.RedisOrmQueryError(`(${this._entityType.name}) You can only group by 1 column`);
}
if (!serviceInstance_1.serviceInstance.isValidColumn(this._entityType, column)) {
throw new RedisOrmQueryError_1.RedisOrmQueryError("(" + this._entityType.name + ") Invalid column: " + column);
throw new RedisOrmQueryError_1.RedisOrmQueryError(`(${this._entityType.name}) Invalid column: ${column}`);
}
this._groupByColumn = column;
return this;
};
}
// endregion
// region aggregate
Query.prototype.count = function () {
return __awaiter(this, void 0, void 0, function () {
var result;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
this._timerStart("count");
return [4 /*yield*/, this._aggregate("count", "")];
case 1:
result = _a.sent();
this._timerEnd("count");
return [2 /*return*/, result];
}
});
count() {
return __awaiter(this, void 0, void 0, function* () {
this._timerStart("count");
const result = yield this._aggregate("count", "");
this._timerEnd("count");
return result;
});
};
Query.prototype.min = function (column) {
return __awaiter(this, void 0, void 0, function () {
var result;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
this._timerStart("min");
return [4 /*yield*/, this._aggregate("min", column)];
case 1:
result = _a.sent();
this._timerEnd("min");
return [2 /*return*/, result];
}
});
}
min(column) {
return __awaiter(this, void 0, void 0, function* () {
this._timerStart("min");
const result = yield this._aggregate("min", column);
this._timerEnd("min");
return result;
});
};
Query.prototype.max = function (column) {
return __awaiter(this, void 0, void 0, function () {
var result;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
this._timerStart("max");
return [4 /*yield*/, this._aggregate("max", column)];
case 1:
result = _a.sent();
this._timerEnd("max");
return [2 /*return*/, result];
}
});
}
max(column) {
return __awaiter(this, void 0, void 0, function* () {
this._timerStart("max");
const result = yield this._aggregate("max", column);
this._timerEnd("max");
return result;
});
};
Query.prototype.sum = function (column) {
return __awaiter(this, void 0, void 0, function () {
var result;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
this._timerStart("sum");
return [4 /*yield*/, this._aggregate("sum", column)];
case 1:
result = _a.sent();
this._timerEnd("sum");
return [2 /*return*/, result];
}
});
}
sum(column) {
return __awaiter(this, void 0, void 0, function* () {
this._timerStart("sum");
const result = yield this._aggregate("sum", column);
this._timerEnd("sum");
return result;
});
};
Query.prototype.avg = function (column) {
return __awaiter(this, void 0, void 0, function () {
var result;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
this._timerStart("avg");
return [4 /*yield*/, this._aggregate("avg", column)];
case 1:
result = _a.sent();
this._timerEnd("avg");
return [2 /*return*/, result];
}
});
}
avg(column) {
return __awaiter(this, void 0, void 0, function* () {
this._timerStart("avg");
const result = yield this._aggregate("avg", column);
this._timerEnd("avg");
return result;
});
};
}
// endregion
// region rank
Query.prototype.rank = function (column, idObject, isReverse) {
if (isReverse === void 0) { isReverse = false; }
return __awaiter(this, void 0, void 0, function () {
var indexStorageKey, entityId, offset, redis, tempOffset;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
this._timerStart("rank");
if (!serviceInstance_1.serviceInstance.isIndexKey(this._entityType, column)) {
throw new RedisOrmQueryError_1.RedisOrmQueryError("(" + this._entityType.name + ") Invalid index column: " + column);
}
indexStorageKey = serviceInstance_1.serviceInstance.getIndexStorageKey(this._entityType, column);
entityId = serviceInstance_1.serviceInstance.convertAsEntityId(this._entityType, idObject);
offset = -1;
if (!entityId) return [3 /*break*/, 6];
return [4 /*yield*/, this._getRedis()];
case 1:
redis = _a.sent();
tempOffset = null;
if (!isReverse) return [3 /*break*/, 3];
return [4 /*yield*/, redis.zrevrank(indexStorageKey, entityId)];
case 2:
tempOffset = _a.sent();
return [3 /*break*/, 5];
case 3: return [4 /*yield*/, redis.zrank(indexStorageKey, entityId)];
case 4:
tempOffset = _a.sent();
_a.label = 5;
case 5:
if (tempOffset !== null) {
offset = tempOffset;
}
_a.label = 6;
case 6:
this._timerEnd("rank");
return [2 /*return*/, offset];
rank(column, idObject, isReverse = false) {
return __awaiter(this, void 0, void 0, function* () {
this._timerStart("rank");
if (!serviceInstance_1.serviceInstance.isIndexKey(this._entityType, column)) {
throw new RedisOrmQueryError_1.RedisOrmQueryError(`(${this._entityType.name}) Invalid index column: ${column}`);
}
const indexStorageKey = serviceInstance_1.serviceInstance.getIndexStorageKey(this._entityType, column);
const entityId = serviceInstance_1.serviceInstance.convertAsEntityId(this._entityType, idObject);
let offset = -1;
if (entityId) {
const redis = yield this._getRedis();
let tempOffset = null;
if (isReverse) {
tempOffset = yield redis.zrevrank(indexStorageKey, entityId);
}
});
else {
tempOffset = yield redis.zrank(indexStorageKey, entityId);
}
if (tempOffset !== null) {
offset = tempOffset;
}
}
this._timerEnd("rank");
return offset;
});
};
}
// endregion
// region private methods
Query.prototype._get = function () {
return __awaiter(this, void 0, void 0, function () {
var whereIndexKeys, whereSearchKeys, params, _i, _a, _b, column, _c, min, max, _d, _e, _f, column, _g, operator, value, redis, ids;
return __generator(this, function (_h) {
switch (_h.label) {
case 0:
whereIndexKeys = Object.keys(this._whereIndexes);
whereSearchKeys = Object.keys(this._whereSearches);
// we add a default index
if (whereIndexKeys.length === 0) {
if (this._sortBy && serviceInstance_1.serviceInstance.isIndexKey(this._entityType, this._sortBy.column)) {
this.where(this._sortBy.column, "<=", "+inf");
}
else {
this.where("createdAt", "<=", "+inf");
}
whereIndexKeys = Object.keys(this._whereIndexes);
}
// if we only search with only one index and ordering is same as the index
if (whereIndexKeys.length === 1 && whereSearchKeys.length === 0 &&
(!this._sortBy || this._sortBy.column === whereIndexKeys[0])) {
return [2 /*return*/, this._getSimple()];
}
params = [
whereIndexKeys.length,
whereSearchKeys.length,
this._offset,
this._limit,
serviceInstance_1.serviceInstance.getTable(this._entityType),
"",
"",
"",
"",
this._sortBy ? this._sortBy.column : "",
this._sortBy ? this._sortBy.order : "",
];
// whereIndexes
for (_i = 0, _a = Object.entries(this._whereIndexes); _i < _a.length; _i++) {
_b = _a[_i], column = _b[0], _c = _b[1], min = _c.min, max = _c.max;
params.push(column);
params.push(min);
params.push(max);
}
// whereSearches
for (_d = 0, _e = Object.entries(this._whereSearches); _d < _e.length; _d++) {
_f = _e[_d], column = _f[0], _g = _f[1], operator = _g.operator, value = _g.value;
params.push(column);
params.push(operator);
params.push(value);
}
return [4 /*yield*/, this._getRedis()];
case 1:
redis = _h.sent();
return [4 /*yield*/, redis.commandAtomicMixedQuery([], params)];
case 2:
ids = _h.sent();
return [4 /*yield*/, this.findMany(ids)];
case 3: return [2 /*return*/, _h.sent()];
_get() {
return __awaiter(this, void 0, void 0, function* () {
let whereIndexKeys = Object.keys(this._whereIndexes);
const whereSearchKeys = Object.keys(this._whereSearches);
// we add a default index
if (whereIndexKeys.length === 0) {
if (this._sortBy && serviceInstance_1.serviceInstance.isIndexKey(this._entityType, this._sortBy.column)) {
this.where(this._sortBy.column, "<=", "+inf");
}
});
else {
this.where("createdAt", "<=", "+inf");
}
whereIndexKeys = Object.keys(this._whereIndexes);
}
// if we only search with only one index and ordering is same as the index
if (whereIndexKeys.length === 1 && whereSearchKeys.length === 0 &&
(!this._sortBy || this._sortBy.column === whereIndexKeys[0])) {
return this._getSimple();
}
// we send to redis lua to do complex query
const params = [
whereIndexKeys.length,
whereSearchKeys.length,
this._offset,
this._limit,
serviceInstance_1.serviceInstance.getTable(this._entityType),
"",
"",
"",
"",
this._sortBy ? this._sortBy.column : "",
this._sortBy ? this._sortBy.order : "",
];
// whereIndexes
for (const [column, { min, max }] of Object.entries(this._whereIndexes)) {
params.push(column);
params.push(min);
params.push(max);
}
// whereSearches
for (const [column, { operator, value }] of Object.entries(this._whereSearches)) {
params.push(column);
params.push(operator);
params.push(value);
}
// whereSearches
const redis = yield this._getRedis();
const ids = yield redis.commandAtomicMixedQuery([], params);
return yield this.findMany(ids);
});
};
}
// only work for query with index and same ordering
Query.prototype._getSimple = function () {
return __awaiter(this, void 0, void 0, function () {
var whereIndexKeys, column, min, max, order, indexStorageKey, extraParams, redis, ids;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
whereIndexKeys = Object.keys(this._whereIndexes);
column = whereIndexKeys[0];
min = this._whereIndexes[column].min;
max = this._whereIndexes[column].max;
order = this._sortBy ? this._sortBy.order : "asc";
indexStorageKey = serviceInstance_1.serviceInstance.getIndexStorageKey(this._entityType, column);
extraParams = ["LIMIT", this._offset.toString(), this._limit.toString()];
return [4 /*yield*/, this._getRedis()];
case 1:
redis = _a.sent();
ids = [];
if (!(order === "asc")) return [3 /*break*/, 3];
return [4 /*yield*/, redis.zrangebyscore.apply(redis, __spreadArrays([indexStorageKey, min, max], extraParams))];
case 2:
ids = _a.sent();
return [3 /*break*/, 5];
case 3:
if (!(order === "desc")) return [3 /*break*/, 5];
return [4 /*yield*/, redis.zrevrangebyscore.apply(redis, __spreadArrays([indexStorageKey, max, min], extraParams))];
case 4:
ids = _a.sent();
_a.label = 5;
case 5: return [4 /*yield*/, this.findMany(ids)];
case 6: return [2 /*return*/, _a.sent()];
}
});
_getSimple() {
return __awaiter(this, void 0, void 0, function* () {
const whereIndexKeys = Object.keys(this._whereIndexes);
const column = whereIndexKeys[0];
const min = this._whereIndexes[column].min;
const max = this._whereIndexes[column].max;
const order = this._sortBy ? this._sortBy.order : "asc";
// redis params
const indexStorageKey = serviceInstance_1.serviceInstance.getIndexStorageKey(this._entityType, column);
const extraParams = ["LIMIT", this._offset.toString(), this._limit.toString()];
// collect result ids
const redis = yield this._getRedis();
let ids = [];
if (order === "asc") {
ids = yield redis.zrangebyscore(indexStorageKey, min, max, ...extraParams);
}
else if (order === "desc") {
ids = yield redis.zrevrangebyscore(indexStorageKey, max, min, ...extraParams);
}
return yield this.findMany(ids);
});
};
Query.prototype._aggregate = function (aggregate, aggregateColumn) {
return __awaiter(this, void 0, void 0, function () {
var whereIndexKeys, whereSearchKeys, params, _i, _a, _b, column, _c, min, max, _d, _e, _f, column, _g, operator, value, redis, commandResult, result;
return __generator(this, function (_h) {
switch (_h.label) {
case 0:
if (aggregate !== "count") {
if (!serviceInstance_1.serviceInstance.isNumberColumn(this._entityType, aggregateColumn)) {
throw new RedisOrmQueryError_1.RedisOrmQueryError("(" + this._entityType.name + ") Column: " + aggregateColumn + " is not in the type of number");
}
}
whereIndexKeys = Object.keys(this._whereIndexes);
whereSearchKeys = Object.keys(this._whereSearches);
// we add a default index
if (whereIndexKeys.length === 0) {
this.where("createdAt", "<=", "+inf");
whereIndexKeys = Object.keys(this._whereIndexes);
}
if (!(aggregate === "count" && !this._groupByColumn &&
whereIndexKeys.length === 1 && whereSearchKeys.length === 0)) return [3 /*break*/, 2];
return [4 /*yield*/, this._aggregateSimple()];
case 1: return [2 /*return*/, _h.sent()];
case 2:
params = [
whereIndexKeys.length,
whereSearchKeys.length,
this._limit,
this._offset,
serviceInstance_1.serviceInstance.getTable(this._entityType),
aggregate,
aggregateColumn,
this._groupByColumn,
this._groupByDateFormat,
"",
"",
];
// whereIndexes
for (_i = 0, _a = Object.entries(this._whereIndexes); _i < _a.length; _i++) {
_b = _a[_i], column = _b[0], _c = _b[1], min = _c.min, max = _c.max;
params.push(column);
params.push(min);
params.push(max);
}
// whereSearches
for (_d = 0, _e = Object.entries(this._whereSearches); _d < _e.length; _d++) {
_f = _e[_d], column = _f[0], _g = _f[1], operator = _g.operator, value = _g.value;
params.push(column);
params.push(operator);
params.push(value);
}
return [4 /*yield*/, this._getRedis()];
case 3:
redis = _h.sent();
return [4 /*yield*/, redis.commandAtomicMixedQuery([], params)];
case 4:
commandResult = _h.sent();
result = JSON.parse(commandResult);
if (!this._groupByColumn) {
return [2 /*return*/, result["*"] || 0];
}
return [2 /*return*/, result];
}
_aggregate(aggregate, aggregateColumn) {
return __awaiter(this, void 0, void 0, function* () {
if (aggregate !== "count") {
if (!serviceInstance_1.serviceInstance.isNumberColumn(this._entityType, aggregateColumn)) {
throw new RedisOrmQueryError_1.RedisOrmQueryError(`(${this._entityType.name}) Column: ${aggregateColumn} is not in the type of number`);
}
});
}
let whereIndexKeys = Object.keys(this._whereIndexes);
const whereSearchKeys = Object.keys(this._whereSearches);
// we add a default index
if (whereIndexKeys.length === 0) {
this.where("createdAt", "<=", "+inf");
whereIndexKeys = Object.keys(this._whereIndexes);
}
// aggregate in simple way
if (aggregate === "count" && !this._groupByColumn &&
whereIndexKeys.length === 1 && whereSearchKeys.length === 0) {
return yield this._aggregateSimple();
}
const params = [
whereIndexKeys.length,
whereSearchKeys.length,
this._limit,
this._offset,
serviceInstance_1.serviceInstance.getTable(this._entityType),
aggregate,
aggregateColumn,
this._groupByColumn,
this._groupByDateFormat,
"",
"",
];
// whereIndexes
for (const [column, { min, max }] of Object.entries(this._whereIndexes)) {
params.push(column);
params.push(min);
params.push(max);
}
// whereSearches
for (const [column, { operator, value }] of Object.entries(this._whereSearches)) {
params.push(column);
params.push(operator);
params.push(value);
}
const redis = yield this._getRedis();
const commandResult = yield redis.commandAtomicMixedQuery([], params);
const result = JSON.parse(commandResult);
if (!this._groupByColumn) {
return result["*"] || 0;
}
return result;
});
};
Query.prototype._aggregateSimple = function () {
return __awaiter(this, void 0, void 0, function () {
var count, whereIndexKeys, column, min, max, redis;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
count = 0;
whereIndexKeys = Object.keys(this._whereIndexes);
column = whereIndexKeys[0];
min = this._whereIndexes[column].min;
max = this._whereIndexes[column].max;
return [4 /*yield*/, this._getRedis()];
case 1:
redis = _a.sent();
if (!(max === "+inf" && min === "-inf")) return [3 /*break*/, 3];
return [4 /*yield*/, redis.zcard(serviceInstance_1.serviceInstance.getIndexStorageKey(this._entityType, column))];
case 2:
count = _a.sent();
return [3 /*break*/, 5];
case 3: return [4 /*yield*/, redis.zcount(serviceInstance_1.serviceInstance.getIndexStorageKey(this._entityType, column), min, max)];
case 4:
count = _a.sent();
_a.label = 5;
case 5: return [2 /*return*/, count];
}
});
}
_aggregateSimple() {
return __awaiter(this, void 0, void 0, function* () {
let count = 0;
const whereIndexKeys = Object.keys(this._whereIndexes);
const column = whereIndexKeys[0];
const min = this._whereIndexes[column].min;
const max = this._whereIndexes[column].max;
const redis = yield this._getRedis();
if (max === "+inf" && min === "-inf") {
count = yield redis.zcard(serviceInstance_1.serviceInstance.getIndexStorageKey(this._entityType, column));
}
else {
count = yield redis.zcount(serviceInstance_1.serviceInstance.getIndexStorageKey(this._entityType, column), min, max);
}
return count;
});
};
Query.prototype._getRedis = function () {
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4 /*yield*/, serviceInstance_1.serviceInstance.getRedis(this._entityType)];
case 1: return [2 /*return*/, _a.sent()];
}
});
}
_getRedis() {
return __awaiter(this, void 0, void 0, function* () {
return yield serviceInstance_1.serviceInstance.getRedis(this._entityType);
});
};
Query.prototype._timerStart = function (type) {
}
_timerStart(type) {
if (debug.enabled && this._timerType === "") {

@@ -641,25 +448,24 @@ this._timer = process.hrtime();

}
};
Query.prototype._timerEnd = function (type) {
}
_timerEnd(type) {
if (debug.enabled && this._timerType === type) {
var diff = process.hrtime(this._timer);
var executionTime = (diff[1] / 1000000).toFixed(2);
var indexWhere = "Index: " + JSON.stringify(this._whereIndexes);
var searchWhere = "Search: " + JSON.stringify(this._whereSearches);
var sort = "Sort by: " + JSON.stringify(this._sortBy);
var groupBy = "Group by: " + JSON.stringify(this._groupByColumn);
var offset = "offset: " + this._offset;
var limit = "limit: " + this._limit;
debug("(" + this._entityType.name + ") " + type + " executed in " + executionTime + "ms. " + indexWhere + ". " + searchWhere + ". " + sort + ". " + groupBy + ". " + offset + ". " + limit);
const diff = process.hrtime(this._timer);
const executionTime = (diff[1] / 1000000).toFixed(2);
const indexWhere = `Index: ${JSON.stringify(this._whereIndexes)}`;
const searchWhere = `Search: ${JSON.stringify(this._whereSearches)}`;
const sort = `Sort by: ${JSON.stringify(this._sortBy)}`;
const groupBy = `Group by: ${JSON.stringify(this._groupByColumn)}`;
const offset = `offset: ${this._offset}`;
const limit = `limit: ${this._limit}`;
debug(`(${this._entityType.name}) ${type} executed in ${executionTime}ms. ${indexWhere}. ${searchWhere}. ${sort}. ${groupBy}. ${offset}. ${limit}`);
}
};
Query.prototype._timerEndCustom = function (type, data) {
}
_timerEndCustom(type, data) {
if (debug.enabled && this._timerType === type) {
var diff = process.hrtime(this._timer);
var executionTime = (diff[1] / 1000000).toFixed(2);
debug("(" + this._entityType.name + ") " + type + " executed in " + executionTime + "ms. " + data);
const diff = process.hrtime(this._timer);
const executionTime = (diff[1] / 1000000).toFixed(2);
debug(`(${this._entityType.name}) ${type} executed in ${executionTime}ms. ${data}`);
}
};
return Query;
}());
}
}
exports.Query = Query;

559

build/serviceInstance.js

@@ -11,29 +11,2 @@ "use strict";

};
var __generator = (this && this.__generator) || function (thisArg, body) {
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
function verb(n) { return function (v) { return step([n, v]); }; }
function step(op) {
if (f) throw new TypeError("Generator is already executing.");
while (_) try {
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
if (y = 0, t) op = [op[0] & 2, t.value];
switch (op[0]) {
case 0: case 1: t = op; break;
case 4: _.label++; return { value: op[1], done: false };
case 5: _.label++; y = op[1]; op = [0]; continue;
case 7: op = _.ops.pop(); _.trys.pop(); continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
if (t[2]) _.ops.pop();
_.trys.pop(); continue;
}
op = body.call(thisArg, _);
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
}
};
var __importStar = (this && this.__importStar) || function (mod) {

@@ -50,13 +23,13 @@ if (mod && mod.__esModule) return mod;

Object.defineProperty(exports, "__esModule", { value: true });
var fs = __importStar(require("fs"));
var ioredis_1 = __importDefault(require("ioredis"));
var path = __importStar(require("path"));
var configLoader_1 = require("./configLoader");
var RedisOrmDecoratorError_1 = require("./errors/RedisOrmDecoratorError");
var RedisOrmQueryError_1 = require("./errors/RedisOrmQueryError");
var IOREDIS_ERROR_RETRY_DELAY = 1000;
var IOREDIS_CONNECT_TIMEOUT = 10000;
var IOREDIS_REIGSTER_LUA_DELAY = 100;
var ServiceInstance = /** @class */ (function () {
function ServiceInstance() {
const fs = __importStar(require("fs"));
const ioredis_1 = __importDefault(require("ioredis"));
const path = __importStar(require("path"));
const configLoader_1 = require("./configLoader");
const RedisOrmDecoratorError_1 = require("./errors/RedisOrmDecoratorError");
const RedisOrmQueryError_1 = require("./errors/RedisOrmQueryError");
const IOREDIS_ERROR_RETRY_DELAY = 1000;
const IOREDIS_CONNECT_TIMEOUT = 10000;
const IOREDIS_REIGSTER_LUA_DELAY = 100;
class ServiceInstance {
constructor() {
this._entityMetas = new Map();

@@ -68,9 +41,9 @@ this._entitySchemas = new Map();

// region public methods: set
ServiceInstance.prototype.addEntity = function (target, entityMeta) {
addEntity(target, entityMeta) {
if (!this._entityMetas.has(target)) {
this._entityMetas.set(target, entityMeta);
}
};
ServiceInstance.prototype.addColumn = function (target, column, schema) {
var schemas = this._entitySchemas.get(target);
}
addColumn(target, column, schema) {
let schemas = this._entitySchemas.get(target);
if (!schemas) {

@@ -81,22 +54,22 @@ schemas = {};

schemas[column] = schema;
};
}
// endregion
// region public methods: get
ServiceInstance.prototype.getConnectionConfig = function (target) {
var connection = this.getConnection(target);
var configFile = configLoader_1.configLoader.getConfigFile();
getConnectionConfig(target) {
const connection = this.getConnection(target);
const configFile = configLoader_1.configLoader.getConfigFile();
if (!configFile) {
throw new RedisOrmDecoratorError_1.RedisOrmDecoratorError("Config file not found. Please create redisorm.default.json in the project root folder.");
throw new RedisOrmDecoratorError_1.RedisOrmDecoratorError(`Config file not found. Please create redisorm.default.json in the project root folder.`);
}
var rawData = fs.readFileSync(configFile);
var connectionConfigs = JSON.parse(rawData.toString());
const rawData = fs.readFileSync(configFile);
const connectionConfigs = JSON.parse(rawData.toString());
if (!(connection in connectionConfigs)) {
throw new RedisOrmDecoratorError_1.RedisOrmDecoratorError("Invalid connection: " + connection + ". Please check " + configFile);
throw new RedisOrmDecoratorError_1.RedisOrmDecoratorError(`Invalid connection: ${connection}. Please check ${configFile}`);
}
// add retry add retry strategy if needed to trigger connect error
var connectionConfig = connectionConfigs[connection];
var maxConnectRetry = connectionConfig.maxConnectRetry;
const connectionConfig = connectionConfigs[connection];
const maxConnectRetry = connectionConfig.maxConnectRetry;
if (maxConnectRetry) {
var connectTimeout = connectionConfig.connectTimeout || IOREDIS_CONNECT_TIMEOUT;
connectionConfig.retryStrategy = function (times) {
const connectTimeout = connectionConfig.connectTimeout || IOREDIS_CONNECT_TIMEOUT;
connectionConfig.retryStrategy = (times) => {
return times > maxConnectRetry ? null : IOREDIS_ERROR_RETRY_DELAY;

@@ -106,56 +79,53 @@ };

return connectionConfig;
};
ServiceInstance.prototype.getEntityMeta = function (target) {
}
getEntityMeta(target) {
return this._entityMetas.get(target);
};
ServiceInstance.prototype.getTable = function (target) {
}
getTable(target) {
return this.getEntityMeta(target).table;
};
ServiceInstance.prototype.getConnection = function (target) {
}
getConnection(target) {
return this.getEntityMeta(target).connection;
};
ServiceInstance.prototype.getPrimaryKeys = function (target) {
var schemas = this.getSchemas(target);
return Object.entries(schemas).filter(function (x) { return x[1].primary; }).map(function (x) { return x[0]; });
};
ServiceInstance.prototype.getAutoIncrementKey = function (target) {
var schemas = this.getSchemas(target);
var filteredSchemas = Object.entries(schemas).find(function (x) { return x[1].autoIncrement; });
}
getPrimaryKeys(target) {
const schemas = this.getSchemas(target);
return Object.entries(schemas).filter(x => x[1].primary).map(x => x[0]);
}
getAutoIncrementKey(target) {
const schemas = this.getSchemas(target);
const filteredSchemas = Object.entries(schemas).find(x => x[1].autoIncrement);
return filteredSchemas ? filteredSchemas[0] : "";
};
ServiceInstance.prototype.getIndexKeys = function (target) {
var schemas = this.getSchemas(target);
return Object.entries(schemas).filter(function (x) { return x[1].index; }).map(function (x) { return x[0]; });
};
ServiceInstance.prototype.getUniqueKeys = function (target) {
var schemas = this.getSchemas(target);
return Object.entries(schemas).filter(function (x) { return x[1].unique; }).map(function (x) { return x[0]; });
};
ServiceInstance.prototype.getSchemas = function (target) {
}
getIndexKeys(target) {
const schemas = this.getSchemas(target);
return Object.entries(schemas).filter(x => x[1].index).map(x => x[0]);
}
getUniqueKeys(target) {
const schemas = this.getSchemas(target);
return Object.entries(schemas).filter(x => x[1].unique).map(x => x[0]);
}
getSchemas(target) {
return this._entitySchemas.get(target) || {};
};
ServiceInstance.prototype.getSchemasJson = function (target) {
}
getSchemasJson(target) {
if (!this._entitySchemasJsons.has(target)) {
var schemas_1 = this.getSchemas(target);
var keys = Object.keys(schemas_1).sort();
var sortedSchemas = keys.reduce(function (a, b) {
var _a;
return Object.assign(a, (_a = {}, _a[b] = schemas_1[b], _a));
}, {});
const schemas = this.getSchemas(target);
const keys = Object.keys(schemas).sort();
const sortedSchemas = keys.reduce((a, b) => Object.assign(a, { [b]: schemas[b] }), {});
this._entitySchemasJsons.set(target, JSON.stringify(sortedSchemas, schemaJsonReplacer));
}
return this._entitySchemasJsons.get(target);
};
ServiceInstance.prototype.getSchema = function (target, column) {
var schemas = this.getSchemas(target);
}
getSchema(target, column) {
const schemas = this.getSchemas(target);
return schemas[column];
};
ServiceInstance.prototype.getColumns = function (target) {
var schemas = this._entitySchemas.get(target) || {};
}
getColumns(target) {
const schemas = this._entitySchemas.get(target) || {};
return Object.keys(schemas);
};
ServiceInstance.prototype.convertAsEntityId = function (target, idObject) {
var primaryKeys = this.getPrimaryKeys(target).sort();
}
convertAsEntityId(target, idObject) {
const primaryKeys = this.getPrimaryKeys(target).sort();
if (idObject === null || idObject === undefined) {
throw new RedisOrmQueryError_1.RedisOrmQueryError("(" + target.name + ") Invalid id: " + idObject);
throw new RedisOrmQueryError_1.RedisOrmQueryError(`(${target.name}) Invalid id: ${idObject}`);
}

@@ -169,287 +139,214 @@ else if (typeof idObject === "string") {

else if (typeof idObject === "object") {
if (!primaryKeys.every(function (column) { return column in idObject; })) {
throw new RedisOrmQueryError_1.RedisOrmQueryError("(" + target.name + ") Invalid id " + JSON.stringify(idObject));
if (!primaryKeys.every(column => column in idObject)) {
throw new RedisOrmQueryError_1.RedisOrmQueryError(`(${target.name}) Invalid id ${JSON.stringify(idObject)}`);
}
return primaryKeys
.map(function (column) { return idObject[column].toString().replace(/:/g, ""); })
.map(column => idObject[column].toString().replace(/:/g, ""))
.join(":");
}
};
}
// endregion
// region public methods: conditions
ServiceInstance.prototype.isIndexKey = function (target, column) {
var keys = this.getIndexKeys(target);
isIndexKey(target, column) {
const keys = this.getIndexKeys(target);
return keys.includes(column);
};
ServiceInstance.prototype.isValidColumn = function (target, column) {
var keys = exports.serviceInstance.getColumns(target);
}
isValidColumn(target, column) {
const keys = exports.serviceInstance.getColumns(target);
return keys.includes(column);
};
ServiceInstance.prototype.isSearchableColumn = function (target, column) {
var schemas = exports.serviceInstance.getSchemas(target);
}
isSearchableColumn(target, column) {
const schemas = exports.serviceInstance.getSchemas(target);
return (column in schemas && [String, Number, Date, Boolean].includes(schemas[column].type));
};
ServiceInstance.prototype.isUniqueKey = function (target, column) {
var keys = exports.serviceInstance.getUniqueKeys(target);
}
isUniqueKey(target, column) {
const keys = exports.serviceInstance.getUniqueKeys(target);
return keys.includes(column);
};
ServiceInstance.prototype.isPrimaryKey = function (target, column) {
var keys = exports.serviceInstance.getPrimaryKeys(target);
}
isPrimaryKey(target, column) {
const keys = exports.serviceInstance.getPrimaryKeys(target);
return keys.includes(column);
};
ServiceInstance.prototype.isSortableColumn = function (target, column) {
var schema = exports.serviceInstance.getSchema(target, column);
}
isSortableColumn(target, column) {
const schema = exports.serviceInstance.getSchema(target, column);
return schema.type === Number || schema.type === Boolean || schema.type === Date;
};
ServiceInstance.prototype.isNumberColumn = function (target, column) {
var schema = exports.serviceInstance.getSchema(target, column);
}
isNumberColumn(target, column) {
const schema = exports.serviceInstance.getSchema(target, column);
return schema.type === Number;
};
ServiceInstance.prototype.isDateColumn = function (target, column) {
var schema = exports.serviceInstance.getSchema(target, column);
}
isDateColumn(target, column) {
const schema = exports.serviceInstance.getSchema(target, column);
return schema.type === Date;
};
}
// endregion
// region redis
ServiceInstance.prototype.getRedis = function (target, registerRedis) {
if (registerRedis === void 0) { registerRedis = true; }
return __awaiter(this, void 0, void 0, function () {
var entityMeta, redisContainer, connectionConfig;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
entityMeta = this.getEntityMeta(target);
redisContainer = entityMeta.redisMaster;
if (!redisContainer) {
connectionConfig = this.getConnectionConfig(target);
redisContainer = {
redis: new ioredis_1.default(connectionConfig),
connecting: false,
ready: false,
schemaErrors: [],
error: null,
};
entityMeta.redisMaster = redisContainer;
}
if (!registerRedis) return [3 /*break*/, 2];
return [4 /*yield*/, this._registerRedis(target, redisContainer)];
case 1:
_a.sent();
_a.label = 2;
case 2: return [2 /*return*/, redisContainer.redis];
}
});
getRedis(target, registerRedis = true) {
return __awaiter(this, void 0, void 0, function* () {
const entityMeta = this.getEntityMeta(target);
let redisContainer = entityMeta.redisMaster;
if (!redisContainer) {
const connectionConfig = this.getConnectionConfig(target);
redisContainer = {
redis: new ioredis_1.default(connectionConfig),
connecting: false,
ready: false,
schemaErrors: [],
error: null,
};
entityMeta.redisMaster = redisContainer;
}
if (registerRedis) {
yield this._registerRedis(target, redisContainer);
}
return redisContainer.redis;
});
};
ServiceInstance.prototype.compareSchemas = function (target) {
return __awaiter(this, void 0, void 0, function () {
var redis, errors, remoteSchemas, clientSchemasJson, clientSchemas, err_1;
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4 /*yield*/, exports.serviceInstance.getRedis(target)];
case 1:
redis = _a.sent();
errors = [];
_a.label = 2;
case 2:
_a.trys.push([2, 4, , 5]);
return [4 /*yield*/, this.getRemoteSchemas(target, redis)];
case 3:
remoteSchemas = _a.sent();
if (remoteSchemas) {
clientSchemasJson = this.getSchemasJson(target);
clientSchemas = JSON.parse(clientSchemasJson);
errors = this._validateSchemas(clientSchemas, remoteSchemas);
}
return [3 /*break*/, 5];
case 4:
err_1 = _a.sent();
// just throw directly
throw err_1;
case 5: return [2 /*return*/, errors];
}
compareSchemas(target) {
return __awaiter(this, void 0, void 0, function* () {
const redis = yield exports.serviceInstance.getRedis(target);
let errors = [];
try {
const remoteSchemas = yield this.getRemoteSchemas(target, redis);
if (remoteSchemas) {
// we do such indirect case is to convert primitive types to strings
const clientSchemasJson = this.getSchemasJson(target);
const clientSchemas = JSON.parse(clientSchemasJson);
errors = this._validateSchemas(clientSchemas, remoteSchemas);
}
});
}
catch (err) {
// just throw directly
throw err;
}
return errors;
});
};
ServiceInstance.prototype.getRemoteSchemas = function (target, redis) {
return __awaiter(this, void 0, void 0, function () {
var metaStorageKey, hashKey, remoteSchemasString;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
metaStorageKey = this.getMetaStorageKey(target);
hashKey = "schemas";
return [4 /*yield*/, redis.hget(metaStorageKey, hashKey)];
case 1:
remoteSchemasString = _a.sent();
if (remoteSchemasString) {
return [2 /*return*/, JSON.parse(remoteSchemasString)];
}
return [2 /*return*/, null];
}
});
}
getRemoteSchemas(target, redis) {
return __awaiter(this, void 0, void 0, function* () {
const metaStorageKey = this.getMetaStorageKey(target);
const hashKey = "schemas";
const remoteSchemasString = yield redis.hget(metaStorageKey, hashKey);
if (remoteSchemasString) {
return JSON.parse(remoteSchemasString);
}
return null;
});
};
ServiceInstance.prototype.resyncDb = function (target) {
return __awaiter(this, void 0, void 0, function () {
var clientSchemasJson, metaStorageKey, hashKey, redis;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
clientSchemasJson = this.getSchemasJson(target);
metaStorageKey = this.getMetaStorageKey(target);
hashKey = "schemas";
return [4 /*yield*/, this.getRedis(target, false)];
case 1:
redis = _a.sent();
return [4 /*yield*/, redis.hset(metaStorageKey, hashKey, clientSchemasJson)];
case 2:
_a.sent();
return [2 /*return*/];
}
});
}
resyncDb(target) {
return __awaiter(this, void 0, void 0, function* () {
const clientSchemasJson = this.getSchemasJson(target);
const metaStorageKey = this.getMetaStorageKey(target);
const hashKey = "schemas";
// force update schema
const redis = yield this.getRedis(target, false);
yield redis.hset(metaStorageKey, hashKey, clientSchemasJson);
});
};
}
// endregion
// region public methods: storage key
ServiceInstance.prototype.getEntityStorageKey = function (target, entityId) {
return "entity:" + this.getTable(target) + ":" + entityId;
};
ServiceInstance.prototype.getIndexStorageKey = function (target, column) {
return "index:" + this.getTable(target) + ":" + column;
};
ServiceInstance.prototype.getUniqueStorageKey = function (target, column) {
return "unique:" + this.getTable(target) + ":" + column;
};
ServiceInstance.prototype.getMetaStorageKey = function (target) {
return "meta:" + this.getTable(target);
};
getEntityStorageKey(target, entityId) {
return `entity:${this.getTable(target)}:${entityId}`;
}
getIndexStorageKey(target, column) {
return `index:${this.getTable(target)}:${column}`;
}
getUniqueStorageKey(target, column) {
return `unique:${this.getTable(target)}:${column}`;
}
getMetaStorageKey(target) {
return `meta:${this.getTable(target)}`;
}
// endregion
// region private methods
ServiceInstance.prototype._registerRedis = function (target, redisContainer) {
return __awaiter(this, void 0, void 0, function () {
var err_2;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
if (!redisContainer.connecting) return [3 /*break*/, 2];
return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, IOREDIS_REIGSTER_LUA_DELAY); })];
case 1:
_a.sent();
return [3 /*break*/, 0];
case 2:
if (!!redisContainer.ready) return [3 /*break*/, 7];
redisContainer.connecting = true;
_a.label = 3;
case 3:
_a.trys.push([3, 5, , 6]);
return [4 /*yield*/, this._registerLau(target, redisContainer)];
case 4:
_a.sent();
return [3 /*break*/, 6];
case 5:
err_2 = _a.sent();
redisContainer.error = err_2;
return [3 /*break*/, 6];
case 6:
redisContainer.ready = true;
redisContainer.connecting = false;
_a.label = 7;
case 7: return [2 /*return*/];
_registerRedis(target, redisContainer) {
return __awaiter(this, void 0, void 0, function* () {
// allow multiple call to registerLua for same model if it's not completed registering yet
while (redisContainer.connecting) {
yield new Promise(resolve => setTimeout(resolve, IOREDIS_REIGSTER_LUA_DELAY));
}
if (!redisContainer.ready) {
redisContainer.connecting = true;
// register lua
try {
yield this._registerLau(target, redisContainer);
}
});
});
};
ServiceInstance.prototype._registerLau = function (target, redisContainer) {
return __awaiter(this, void 0, void 0, function () {
var luaShared, lua1, lua2, lua3, lua4, lua5, err_3;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
_a.trys.push([0, 6, , 7]);
luaShared = fs.readFileSync(path.join(__dirname, "../lua/shared.lua"), { encoding: "utf8" });
lua1 = fs.readFileSync(path.join(__dirname, "../lua/atomicResyncDb.lua"), { encoding: "utf8" });
return [4 /*yield*/, redisContainer.redis.defineCommand("commandAtomicResyncDb", { numberOfKeys: 0, lua: luaShared + lua1 })];
case 1:
_a.sent();
lua2 = fs.readFileSync(path.join(__dirname, "../lua/atomicMixedQuery.lua"), { encoding: "utf8" });
return [4 /*yield*/, redisContainer.redis.defineCommand("commandAtomicMixedQuery", { numberOfKeys: 0, lua: luaShared + lua2 })];
case 2:
_a.sent();
lua3 = fs.readFileSync(path.join(__dirname, "../lua/atomicSave.lua"), { encoding: "utf8" });
return [4 /*yield*/, redisContainer.redis.defineCommand("commandAtomicSave", { numberOfKeys: 0, lua: luaShared + lua3 })];
case 3:
_a.sent();
lua4 = fs.readFileSync(path.join(__dirname, "../lua/atomicDelete.lua"), { encoding: "utf8" });
return [4 /*yield*/, redisContainer.redis.defineCommand("commandAtomicDelete", { numberOfKeys: 0, lua: luaShared + lua4 })];
case 4:
_a.sent();
lua5 = fs.readFileSync(path.join(__dirname, "../lua/atomicTruncate.lua"), { encoding: "utf8" });
return [4 /*yield*/, redisContainer.redis.defineCommand("commandAtomicTruncate", { numberOfKeys: 0, lua: luaShared + lua5 })];
case 5:
_a.sent();
return [3 /*break*/, 7];
case 6:
err_3 = _a.sent();
// just throw directly
throw err_3;
case 7: return [2 /*return*/];
catch (err) {
redisContainer.error = err;
}
});
redisContainer.ready = true;
redisContainer.connecting = false;
}
});
};
ServiceInstance.prototype._validateSchemas = function (clientSchemas, remoteSchemas) {
var errors = [];
}
_registerLau(target, redisContainer) {
return __awaiter(this, void 0, void 0, function* () {
try {
const luaShared = fs.readFileSync(path.join(__dirname, "../lua/shared.lua"), { encoding: "utf8" });
const lua1 = fs.readFileSync(path.join(__dirname, "../lua/atomicResyncDb.lua"), { encoding: "utf8" });
yield redisContainer.redis.defineCommand("commandAtomicResyncDb", { numberOfKeys: 0, lua: luaShared + lua1 });
const lua2 = fs.readFileSync(path.join(__dirname, "../lua/atomicMixedQuery.lua"), { encoding: "utf8" });
yield redisContainer.redis.defineCommand("commandAtomicMixedQuery", { numberOfKeys: 0, lua: luaShared + lua2 });
const lua3 = fs.readFileSync(path.join(__dirname, "../lua/atomicSave.lua"), { encoding: "utf8" });
yield redisContainer.redis.defineCommand("commandAtomicSave", { numberOfKeys: 0, lua: luaShared + lua3 });
const lua4 = fs.readFileSync(path.join(__dirname, "../lua/atomicDelete.lua"), { encoding: "utf8" });
yield redisContainer.redis.defineCommand("commandAtomicDelete", { numberOfKeys: 0, lua: luaShared + lua4 });
const lua5 = fs.readFileSync(path.join(__dirname, "../lua/atomicTruncate.lua"), { encoding: "utf8" });
yield redisContainer.redis.defineCommand("commandAtomicTruncate", { numberOfKeys: 0, lua: luaShared + lua5 });
}
catch (err) {
// just throw directly
throw err;
}
});
}
_validateSchemas(clientSchemas, remoteSchemas) {
const errors = [];
// check remote schemas has all keys in client schemas
for (var _i = 0, _a = Object.keys(clientSchemas); _i < _a.length; _i++) {
var column = _a[_i];
for (const column of Object.keys(clientSchemas)) {
if (!(column in remoteSchemas)) {
errors.push("Column: " + column + " does not exist in remote schemas");
errors.push(`Column: ${column} does not exist in remote schemas`);
continue;
}
var clientSchema = clientSchemas[column];
var remoteSchema = remoteSchemas[column];
const clientSchema = clientSchemas[column];
const remoteSchema = remoteSchemas[column];
if (clientSchema.type !== remoteSchema.type) {
errors.push("Incompatible type on column: " + column + ", current value: " + clientSchema.type + ", remove value: " + remoteSchema.type);
errors.push(`Incompatible type on column: ${column}, current value: ${clientSchema.type}, remove value: ${remoteSchema.type}`);
}
if (clientSchema.index !== remoteSchema.index) {
errors.push("Incompatible index on column: " + column + ", current value: " + clientSchema.index + ", remove value: " + remoteSchema.index);
errors.push(`Incompatible index on column: ${column}, current value: ${clientSchema.index}, remove value: ${remoteSchema.index}`);
}
if (clientSchema.unique !== remoteSchema.unique) {
errors.push("Incompatible unique on column: " + column + ", current value: " + clientSchema.unique + ", remove value: " + remoteSchema.unique);
errors.push(`Incompatible unique on column: ${column}, current value: ${clientSchema.unique}, remove value: ${remoteSchema.unique}`);
}
if (clientSchema.autoIncrement !== remoteSchema.autoIncrement) {
errors.push("Incompatible autoIncrement on column: " + column + ", current value: " + clientSchema.autoIncrement + ", remove value: " + remoteSchema.autoIncrement);
errors.push(`Incompatible autoIncrement on column: ${column}, current value: ${clientSchema.autoIncrement}, remove value: ${remoteSchema.autoIncrement}`);
}
if (clientSchema.primary !== remoteSchema.primary) {
errors.push("Incompatible primary on column: " + column + ", current value: " + clientSchema.primary + ", remove value: " + remoteSchema.primary);
errors.push(`Incompatible primary on column: ${column}, current value: ${clientSchema.primary}, remove value: ${remoteSchema.primary}`);
}
}
// check client schemas has all keys in remote schemas
for (var _b = 0, _c = Object.keys(remoteSchemas); _b < _c.length; _b++) {
var column = _c[_b];
for (const column of Object.keys(remoteSchemas)) {
if (!(column in clientSchemas)) {
errors.push("Column: " + column + " does not exist in current schemas");
errors.push(`Column: ${column} does not exist in current schemas`);
}
}
return errors;
};
ServiceInstance.prototype._openFile = function (file) {
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_a) {
return [2 /*return*/, new Promise(function (resolve, reject) {
fs.readFile(file, "utf8", function (err, text) {
if (err) {
return reject(err);
}
else {
resolve(text);
}
});
})];
}
_openFile(file) {
return __awaiter(this, void 0, void 0, function* () {
return new Promise((resolve, reject) => {
fs.readFile(file, "utf8", (err, text) => {
if (err) {
return reject(err);
}
else {
resolve(text);
}
});
});
});
};
return ServiceInstance;
}());
}
}
exports.serviceInstance = new ServiceInstance();

@@ -456,0 +353,0 @@ function schemaJsonReplacer(key, value) {

3

package.json
{
"name": "ts-redis-orm",
"version": "0.1.8",
"version": "0.1.9",
"description": "A full functional Redis Orm library written in Typescript.",

@@ -30,2 +30,3 @@ "main": "build/index.js",

"devDependencies": {
"clone": "^2.1.2",
"@types/chai": "^4.2.4",

@@ -32,0 +33,0 @@ "@types/mocha": "^5.2.7",

7

tests/general.test.ts
import {assert, expect } from "chai";
import clone from "clone";
import {BaseEntity, Column, Entity} from "../src/";

@@ -60,4 +61,8 @@ import {serviceInstance} from "../src/serviceInstance";

describe("General Test: Create Entity", () => {
it("clone entity", async () => {
const entity = new TestingGeneral();
const newEntity = clone(entity);
});
it("new entity", async () => {
console.log(TestingGeneral.getSchemas());
const entity = new TestingGeneral();

@@ -64,0 +69,0 @@ assert.isTrue(entity.isNew);

2

tsconfig.json

@@ -6,3 +6,3 @@ {

"resolveJsonModule": true,
"target": "es5",
"target": "es2015",
/* Specify ECMAScript target version: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017', 'ES2018', 'ES2019' or 'ESNEXT'. */

@@ -9,0 +9,0 @@ "module": "commonjs",

SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap
  • Changelog

About

Packages

npm

Go

Maven

PyPI

Rubygems

Stay in touch

Get open source security insights delivered straight into your inbox.

  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc