grand-connectors
Version:
A Grandjs package for applying repository pattern for nodejs and javascript applications using typescript
179 lines (177 loc) • 7.34 kB
JavaScript
;
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.DataSources = exports.loadClass = exports.InjectService = exports.InjectModel = exports.InjectDataSource = void 0;
const types_1 = require("./types");
const util_1 = require("util");
const fs_1 = __importDefault(require("fs"));
const path_1 = __importDefault(require("path"));
const store_1 = require("./store");
Object.defineProperty(exports, "DataSources", { enumerable: true, get: function () { return store_1.DataSources; } });
// inject new service in any class
const InjectService = (store, Service, mode = types_1.ServiceModes.global, data) => {
return (constructor) => {
var _a, _b, _c;
let storeWhere;
let preparedService;
if (Service) {
let serviceName = typeof Service === "function"
? (_a = Service.prototype.constructor) === null || _a === void 0 ? void 0 : _a.name
: Service.constructor.name;
let serviceNameLowerCase = serviceName.charAt(0).toLowerCase() + serviceName.slice(1);
if (Object.values(types_1.ServiceModes).includes(mode)) {
if (mode === types_1.ServiceModes.global) {
if (store_1.Services[serviceName]) {
}
else {
store_1.Services[serviceName] = { name: serviceName, Service: new Service(data) };
if ((_b = store_1.Services[serviceName].Service) === null || _b === void 0 ? void 0 : _b.init) {
(_c = store_1.Services[serviceName].Service) === null || _c === void 0 ? void 0 : _c.init();
}
}
preparedService = store_1.Services[serviceName].Service;
}
else {
preparedService =
typeof Service === "function" ? new Service(data) : Service;
if (preparedService === null || preparedService === void 0 ? void 0 : preparedService.init) {
preparedService === null || preparedService === void 0 ? void 0 : preparedService.init();
}
}
if (store === "this") {
storeWhere = constructor.prototype;
}
else {
storeWhere = constructor.prototype[store] =
constructor.prototype[store] || {};
}
storeWhere[serviceNameLowerCase] = preparedService;
}
else {
throw new Error(`service mode should be on of the following, ${Object.keys(types_1.ServiceModes).join(" , ")}`);
}
}
};
};
exports.InjectService = InjectService;
// define the mode of service is it global or private
const Mode = (mode) => {
return (target) => {
let modes = Object.values(types_1.ServiceModes);
if (modes.includes(mode)) {
target.Mode = mode;
}
else {
throw new Error(`service mode should be on of the following, ${modes.join(" , ")}`);
}
};
};
// inject new data source into the repository
const InjectDataSource = (ComingDataSource) => {
return (target, key) => {
var _a;
let dataSource = ((_a = store_1.DataSources[key]) === null || _a === void 0 ? void 0 : _a.name) === key
? store_1.DataSources[key].DataSource
: new ComingDataSource();
target[key] = dataSource;
target.dataSources = target.dataSources || {};
target.dataSources[key] = dataSource;
if (!store_1.DataSources[key]) {
store_1.DataSources[key] = { name: key, dataSource };
}
};
};
exports.InjectDataSource = InjectDataSource;
// inject model into the repository
const InjectModel = (options) => {
return (target, key) => {
target.dataSources = target.dataSources || {};
let DataSource = target.dataSources[options.DataSourceName];
target.Models = target.Models || {};
target.Models[key] = {
DataSource: DataSource ? DataSource : null,
Entity: options.Entity,
Model: options.Model ? options.Model : null,
};
target[key] = {
DataSource: DataSource ? DataSource : null,
Entity: options.Entity,
Model: options.Model ? options.Model : null,
};
};
};
exports.InjectModel = InjectModel;
const bootsstrapModel = () => __awaiter(void 0, void 0, void 0, function* () {
try {
let readdir = (0, util_1.promisify)(fs_1.default.readdir);
let mkdir = (0, util_1.promisify)(fs_1.default.mkdir);
let modelsDir = path_1.default.join(process.cwd(), "models");
let directoryExists = yield readdir(modelsDir);
// check if it exists
if (directoryExists) {
}
else {
yield mkdir(modelsDir);
}
}
catch (err) {
console.log(err);
}
});
const writeModel = (dataSourceType, entityName) => __awaiter(void 0, void 0, void 0, function* () {
try {
let exists = (0, util_1.promisify)(fs_1.default.exists);
let writeFile = (0, util_1.promisify)(fs_1.default.writeFile);
let modelsDir = path_1.default.join(process.cwd(), "models");
let modelDir = path_1.default.join(modelsDir, `${entityName}.model.ts`);
let fileExists = yield exists(modelDir);
// check if file is not exist
if (!fileExists) {
}
}
catch (err) { }
});
const generateMongooseModel = (Entity, entityName) => {
entityName = entityName.charAt(0).toUpperCase();
const Schema = Entity.prototype.Schema;
const DocumentData = {};
Object.keys(Schema).map((key) => {
let schema = Schema[key];
if (schema.isModel) {
if (Array.isArray(schema.type) && schema.type.length > 0) {
}
else {
}
}
else {
DocumentData[key] = schema.type;
}
});
const template = `
import mongoose, {Document, model} from "mongoose";
interface I${entityName} extends Document {
${Object.keys(DocumentData)
.map((key) => {
[key];
})
.join("")}
}
`;
};
// load class method for mongoose
const loadClass = (Schema, entity) => {
Schema.loadClass(entity.prototype.Methods || class {
});
};
exports.loadClass = loadClass;