functional-models-orm-sql/datastoreAdapter.js

A sql based backend for functional-models

"use strict";
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.create = void 0;
const groupBy_1 = __importDefault(require("lodash/groupBy"));
const modern_async_1 = require("modern-async");
const lib_1 = require("./lib");
const { toSimpleSqlObject, BasicPropertyTypeToParser, toToObjectResult } = lib_1.parsers;
const { knexWrapper, ormQueryToKnex } = lib_1.knex;
const create = ({ knex, getTableNameForModel = lib_1.getTableNameForModel, propertyTypeToParser = BasicPropertyTypeToParser, }) => {
    const wrappedKnex = knexWrapper(knex);
    const toJsonParser = toToObjectResult(propertyTypeToParser);
    const search = (model, ormQuery) => {
        return Promise.resolve().then(() => __awaiter(void 0, void 0, void 0, function* () {
            const definitions = model.getModelDefinition();
            const tableName = getTableNameForModel(model);
            const results = yield ormQueryToKnex(knex, tableName, ormQuery);
            const formatted = results.instances
                .map(instance => toJsonParser(definitions, instance))
                .filter(x => x);
            return {
                instances: formatted,
                page: results.page,
            };
        }));
    };
    const retrieve = (model, id) => {
        return Promise.resolve().then(() => __awaiter(void 0, void 0, void 0, function* () {
            const definitions = model.getModelDefinition();
            const tableName = getTableNameForModel(model);
            const key = definitions.primaryKeyName;
            const fromDb = yield wrappedKnex.getByPrimaryKey(tableName, key, id);
            if (!fromDb) {
                return undefined;
            }
            return toJsonParser(definitions, fromDb);
        }));
    };
    const save = (instance) => __awaiter(void 0, void 0, void 0, function* () {
        return Promise.resolve().then(() => __awaiter(void 0, void 0, void 0, function* () {
            const model = instance.getModel();
            const tableName = getTableNameForModel(model);
            const data = yield instance.toObj();
            const formatted = toSimpleSqlObject(model.getModelDefinition(), data);
            const key = model.getModelDefinition().primaryKeyName;
            yield wrappedKnex.updateOrCreate(tableName, key, formatted);
            const id = yield instance.getPrimaryKey();
            const fromDb = yield wrappedKnex.getByPrimaryKey(tableName, key, id);
            const definitions = instance.getModel().getModelDefinition();
            return toJsonParser(definitions, fromDb);
        }));
    });
    const bulkInsert = (model, instances) => __awaiter(void 0, void 0, void 0, function* () {
        return Promise.resolve().then(() => __awaiter(void 0, void 0, void 0, function* () {
            if (instances.length === 0) {
                return;
            }
            const groups = (0, groupBy_1.default)(instances, x => x.getModel().getName());
            if (Object.keys(groups).length > 1) {
                throw new Error(`Cannot have more than one model type.`);
            }
            const model = instances[0].getModel();
            const definitions = model.getModelDefinition();
            const tableName = getTableNameForModel(model);
            const readyToSend = yield (0, modern_async_1.mapLimit)(instances, (instance) => __awaiter(void 0, void 0, void 0, function* () {
                const obj = yield instance.toObj();
                return toSimpleSqlObject(definitions, obj);
            }), 1);
            yield knex.transaction((trx) => trx.insert(readyToSend).into(tableName));
            return;
        }));
    });
    const deleteObj = (model, primaryKey) => {
        return Promise.resolve().then(() => __awaiter(void 0, void 0, void 0, function* () {
            const tableName = getTableNameForModel(model);
            const primaryKeyName = model.getModelDefinition().primaryKeyName;
            yield knex(tableName)
                .where({ [primaryKeyName]: primaryKey })
                .del(primaryKey);
            return;
        }));
    };
    const count = (model) => {
        const tableName = getTableNameForModel(model);
        return knex(tableName).count();
    };
    return {
        bulkInsert,
        search,
        retrieve,
        save,
        delete: deleteObj,
        count,
    };
};
exports.create = create;
//# sourceMappingURL=datastoreAdapter.js.map