@brontosaurus/db/controller/namespace.js

:ocean: Schema for brontosaurus

"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());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.getOrganizationsByQueryLean = exports.getNamespacesByQuery = exports.getNamespacesIdsByDomains = exports.getNamespacesIdsByNamespaces = exports.getAllActiveNamespaceDomain = exports.getAllNamespaceDomain = exports.getAllActiveNamespaceNamespace = exports.getAllNamespaceNamespace = exports.getAllNamespacesByPageLean = exports.getAllNamespacesByPage = exports.getAllActiveNamespacesByPageLean = exports.getAllActiveNamespacesByPage = exports.getNamespacesByPageLean = exports.getNamespacesByPage = exports.getActiveNamespacesByPageLean = exports.getActiveNamespacesByPage = exports.getSelectedNamespacesByPageLean = exports.getSelectedNamespacesByPage = exports.getSelectedActiveNamespacesByPageLean = exports.getSelectedActiveNamespacesByPage = exports.getNamespacePagesByKeyword = exports.getActiveNamespacePagesByKeyword = exports.getTotalActiveNamespacePages = exports.getTotalNamespacePages = exports.getAllNamespacesLean = exports.getAllNamespaces = exports.getSelectedNamespacePages = exports.getSelectedActiveNamespacePages = exports.isNamespaceDuplicatedById = exports.isNamespaceDuplicatedByNamespace = exports.isNamespaceDuplicatedByDomain = exports.createUnsavedNamespaceByNamespace = exports.createUnsavedNamespaceByDomain = exports.getNamespacesByDomainsLean = exports.getNamespacesByDomains = exports.getNamespaceByDomainLean = exports.getNamespaceByDomain = exports.getNamespacesByNamespacesLean = exports.getNamespacesByNamespaces = exports.getNamespaceByNamespaceLean = exports.getNamespaceByNamespace = exports.getNamespacesByIdsLean = exports.getNamespacesByIds = exports.getONamespaceByIdLean = exports.getNamespaceById = exports.getBrontosaurusAdminNamespace = exports.getBrontosaurusDefaultNamespace = void 0;
const definition_1 = require("@brontosaurus/definition");
const namespace_1 = require("../data/namespace");
const namespace_2 = require("../model/namespace");
const getBrontosaurusDefaultNamespace = () => __awaiter(void 0, void 0, void 0, function* () {
    const createdDefaultNamespace = yield namespace_2.NamespaceModel.findOne({
        namespace: definition_1.DEFAULT_BRONTOSAURUS_NAMESPACE.DEFAULT,
    });
    if (createdDefaultNamespace) {
        return createdDefaultNamespace;
    }
    const defaultNamespace = new namespace_2.NamespaceModel({
        name: 'Brontosaurus Default',
        domain: namespace_1.parseNamespaceToDomain(definition_1.DEFAULT_BRONTOSAURUS_NAMESPACE.DEFAULT),
        namespace: definition_1.DEFAULT_BRONTOSAURUS_NAMESPACE.DEFAULT,
    });
    yield defaultNamespace.save();
    return defaultNamespace;
});
exports.getBrontosaurusDefaultNamespace = getBrontosaurusDefaultNamespace;
const getBrontosaurusAdminNamespace = () => __awaiter(void 0, void 0, void 0, function* () {
    const createdDefaultNamespace = yield namespace_2.NamespaceModel.findOne({
        namespace: definition_1.DEFAULT_BRONTOSAURUS_NAMESPACE.ADMIN,
    });
    if (createdDefaultNamespace) {
        return createdDefaultNamespace;
    }
    const defaultNamespace = new namespace_2.NamespaceModel({
        name: 'Brontosaurus Admin',
        domain: namespace_1.parseNamespaceToDomain(definition_1.DEFAULT_BRONTOSAURUS_NAMESPACE.ADMIN),
        namespace: definition_1.DEFAULT_BRONTOSAURUS_NAMESPACE.ADMIN,
    });
    yield defaultNamespace.save();
    return defaultNamespace;
});
exports.getBrontosaurusAdminNamespace = getBrontosaurusAdminNamespace;
const getNamespaceById = (id) => __awaiter(void 0, void 0, void 0, function* () {
    return yield namespace_2.NamespaceModel.findOne({
        _id: id,
    });
});
exports.getNamespaceById = getNamespaceById;
const getONamespaceByIdLean = (id) => __awaiter(void 0, void 0, void 0, function* () {
    return yield namespace_2.NamespaceModel.findOne({
        _id: id,
    }).lean();
});
exports.getONamespaceByIdLean = getONamespaceByIdLean;
const getNamespacesByIds = (ids) => __awaiter(void 0, void 0, void 0, function* () {
    return yield namespace_2.NamespaceModel.find({
        _id: {
            $in: ids,
        },
    });
});
exports.getNamespacesByIds = getNamespacesByIds;
const getNamespacesByIdsLean = (ids) => __awaiter(void 0, void 0, void 0, function* () {
    return yield namespace_2.NamespaceModel.find({
        _id: {
            $in: ids,
        },
    }).lean();
});
exports.getNamespacesByIdsLean = getNamespacesByIdsLean;
const getNamespaceByNamespace = (namespace) => __awaiter(void 0, void 0, void 0, function* () {
    const fixed = namespace.toLowerCase();
    return yield namespace_2.NamespaceModel.findOne({
        namespace: fixed,
    });
});
exports.getNamespaceByNamespace = getNamespaceByNamespace;
const getNamespaceByNamespaceLean = (namespace) => __awaiter(void 0, void 0, void 0, function* () {
    const fixed = namespace.toLowerCase();
    return yield namespace_2.NamespaceModel.findOne({
        namespace: fixed,
    }).lean();
});
exports.getNamespaceByNamespaceLean = getNamespaceByNamespaceLean;
const getNamespacesByNamespaces = (namespaces) => __awaiter(void 0, void 0, void 0, function* () {
    const fixes = namespaces.map((namespace) => namespace.toLowerCase());
    return yield namespace_2.NamespaceModel.find({
        namespace: {
            $in: fixes,
        },
    });
});
exports.getNamespacesByNamespaces = getNamespacesByNamespaces;
const getNamespacesByNamespacesLean = (namespaces) => __awaiter(void 0, void 0, void 0, function* () {
    const fixes = namespaces.map((namespace) => namespace.toLowerCase());
    return yield namespace_2.NamespaceModel.find({
        namespace: {
            $in: fixes,
        },
    }).lean();
});
exports.getNamespacesByNamespacesLean = getNamespacesByNamespacesLean;
const getNamespaceByDomain = (domain) => __awaiter(void 0, void 0, void 0, function* () {
    const fixed = domain.toLowerCase();
    return yield namespace_2.NamespaceModel.findOne({
        domain: fixed,
    });
});
exports.getNamespaceByDomain = getNamespaceByDomain;
const getNamespaceByDomainLean = (domain) => __awaiter(void 0, void 0, void 0, function* () {
    const fixed = domain.toLowerCase();
    return yield namespace_2.NamespaceModel.findOne({
        domain: fixed,
    }).lean();
});
exports.getNamespaceByDomainLean = getNamespaceByDomainLean;
const getNamespacesByDomains = (domains) => __awaiter(void 0, void 0, void 0, function* () {
    const fixes = domains.map((domain) => domain.toLowerCase());
    return yield namespace_2.NamespaceModel.find({
        domain: {
            $in: fixes,
        },
    });
});
exports.getNamespacesByDomains = getNamespacesByDomains;
const getNamespacesByDomainsLean = (domains) => __awaiter(void 0, void 0, void 0, function* () {
    const fixes = domains.map((domain) => domain.toLowerCase());
    return yield namespace_2.NamespaceModel.find({
        domain: {
            $in: fixes,
        },
    }).lean();
});
exports.getNamespacesByDomainsLean = getNamespacesByDomainsLean;
const createUnsavedNamespaceByDomain = (domain) => {
    const namespace = namespace_1.parseDomainToNamespace(domain);
    const fixedDomain = domain.toLowerCase();
    const fixedNamespace = namespace.toLowerCase();
    const config = {
        domain: fixedDomain,
        namespace: fixedNamespace,
    };
    return new namespace_2.NamespaceModel(config);
};
exports.createUnsavedNamespaceByDomain = createUnsavedNamespaceByDomain;
const createUnsavedNamespaceByNamespace = (namespace) => {
    const domain = namespace_1.parseNamespaceToDomain(namespace);
    const fixedDomain = domain.toLowerCase();
    const fixedNamespace = namespace.toLowerCase();
    const config = {
        domain: fixedDomain,
        namespace: fixedNamespace,
    };
    return new namespace_2.NamespaceModel(config);
};
exports.createUnsavedNamespaceByNamespace = createUnsavedNamespaceByNamespace;
const isNamespaceDuplicatedByDomain = (domain) => __awaiter(void 0, void 0, void 0, function* () {
    const namespace = yield exports.getNamespaceByDomain(domain);
    return Boolean(namespace);
});
exports.isNamespaceDuplicatedByDomain = isNamespaceDuplicatedByDomain;
const isNamespaceDuplicatedByNamespace = (namespace) => __awaiter(void 0, void 0, void 0, function* () {
    const namespaceInstance = yield exports.getNamespaceByNamespace(namespace);
    return Boolean(namespaceInstance);
});
exports.isNamespaceDuplicatedByNamespace = isNamespaceDuplicatedByNamespace;
const isNamespaceDuplicatedById = (id) => __awaiter(void 0, void 0, void 0, function* () {
    const namespace = yield exports.getNamespaceById(id);
    return Boolean(namespace);
});
exports.isNamespaceDuplicatedById = isNamespaceDuplicatedById;
const getSelectedActiveNamespacePages = (limit, keyword) => __awaiter(void 0, void 0, void 0, function* () {
    if (keyword) {
        return yield exports.getActiveNamespacePagesByKeyword(limit, keyword);
    }
    return yield exports.getTotalActiveNamespacePages(limit);
});
exports.getSelectedActiveNamespacePages = getSelectedActiveNamespacePages;
const getSelectedNamespacePages = (limit, keyword) => __awaiter(void 0, void 0, void 0, function* () {
    if (keyword) {
        return yield exports.getNamespacePagesByKeyword(limit, keyword);
    }
    return yield exports.getTotalNamespacePages(limit);
});
exports.getSelectedNamespacePages = getSelectedNamespacePages;
const getAllNamespaces = () => __awaiter(void 0, void 0, void 0, function* () { return namespace_2.NamespaceModel.find({}); });
exports.getAllNamespaces = getAllNamespaces;
const getAllNamespacesLean = () => __awaiter(void 0, void 0, void 0, function* () { return namespace_2.NamespaceModel.find({}).lean(); });
exports.getAllNamespacesLean = getAllNamespacesLean;
const getTotalNamespacePages = (limit) => __awaiter(void 0, void 0, void 0, function* () { return (yield namespace_2.NamespaceModel.estimatedDocumentCount({})) / limit; });
exports.getTotalNamespacePages = getTotalNamespacePages;
const getTotalActiveNamespacePages = (limit) => __awaiter(void 0, void 0, void 0, function* () {
    return (yield namespace_2.NamespaceModel.countDocuments({
        active: true,
    })) / limit;
});
exports.getTotalActiveNamespacePages = getTotalActiveNamespacePages;
const getActiveNamespacePagesByKeyword = (limit, keyword) => __awaiter(void 0, void 0, void 0, function* () {
    const fixed = keyword.toLowerCase();
    const regexp = new RegExp(fixed, 'i');
    return (yield namespace_2.NamespaceModel.countDocuments({
        namespace: {
            $regex: regexp,
        },
        active: true,
    })) / limit;
});
exports.getActiveNamespacePagesByKeyword = getActiveNamespacePagesByKeyword;
const getNamespacePagesByKeyword = (limit, keyword) => __awaiter(void 0, void 0, void 0, function* () {
    const fixed = keyword.toLowerCase();
    const regexp = new RegExp(fixed, 'i');
    return (yield namespace_2.NamespaceModel.countDocuments({
        namespace: {
            $regex: regexp,
        },
    })) / limit;
});
exports.getNamespacePagesByKeyword = getNamespacePagesByKeyword;
const getSelectedActiveNamespacesByPage = (limit, page, keyword) => __awaiter(void 0, void 0, void 0, function* () {
    if (keyword) {
        return yield exports.getActiveNamespacesByPage(keyword, limit, page);
    }
    return yield exports.getAllActiveNamespacesByPage(limit, page);
});
exports.getSelectedActiveNamespacesByPage = getSelectedActiveNamespacesByPage;
const getSelectedActiveNamespacesByPageLean = (limit, page, keyword) => __awaiter(void 0, void 0, void 0, function* () {
    if (keyword) {
        return yield exports.getActiveNamespacesByPageLean(keyword, limit, page);
    }
    return yield exports.getAllActiveNamespacesByPageLean(limit, page);
});
exports.getSelectedActiveNamespacesByPageLean = getSelectedActiveNamespacesByPageLean;
const getSelectedNamespacesByPage = (limit, page, keyword) => __awaiter(void 0, void 0, void 0, function* () {
    if (keyword) {
        return yield exports.getNamespacesByPage(keyword, limit, page);
    }
    return yield exports.getAllNamespacesByPage(limit, page);
});
exports.getSelectedNamespacesByPage = getSelectedNamespacesByPage;
const getSelectedNamespacesByPageLean = (limit, page, keyword) => __awaiter(void 0, void 0, void 0, function* () {
    if (keyword) {
        return yield exports.getNamespacesByPageLean(keyword, limit, page);
    }
    return yield exports.getAllNamespacesByPageLean(limit, page);
});
exports.getSelectedNamespacesByPageLean = getSelectedNamespacesByPageLean;
const getActiveNamespacesByPage = (keyword, limit, page) => __awaiter(void 0, void 0, void 0, function* () {
    if (page < 0) {
        return [];
    }
    if (limit < 1) {
        return [];
    }
    const fixed = keyword.toLowerCase();
    const regexp = new RegExp(fixed, 'i');
    const namespaces = yield namespace_2.NamespaceModel.find({
        namespace: {
            $regex: regexp,
        },
        active: true,
    }).skip(page * limit).limit(limit).sort({ _id: -1 });
    return namespaces;
});
exports.getActiveNamespacesByPage = getActiveNamespacesByPage;
const getActiveNamespacesByPageLean = (keyword, limit, page) => __awaiter(void 0, void 0, void 0, function* () {
    if (page < 0) {
        return [];
    }
    if (limit < 1) {
        return [];
    }
    const fixed = keyword.toLowerCase();
    const regexp = new RegExp(fixed, 'i');
    const namespaces = yield namespace_2.NamespaceModel.find({
        namespace: {
            $regex: regexp,
        },
        active: true,
    }).skip(page * limit).limit(limit).sort({ _id: -1 }).lean();
    return namespaces;
});
exports.getActiveNamespacesByPageLean = getActiveNamespacesByPageLean;
const getNamespacesByPage = (keyword, limit, page) => __awaiter(void 0, void 0, void 0, function* () {
    if (page < 0) {
        return [];
    }
    if (limit < 1) {
        return [];
    }
    const fixed = keyword.toLowerCase();
    const regexp = new RegExp(fixed, 'i');
    const namespaces = yield namespace_2.NamespaceModel.find({
        namespace: {
            $regex: regexp,
        },
    }).skip(page * limit).limit(limit).sort({ _id: -1 });
    return namespaces;
});
exports.getNamespacesByPage = getNamespacesByPage;
const getNamespacesByPageLean = (keyword, limit, page) => __awaiter(void 0, void 0, void 0, function* () {
    if (page < 0) {
        return [];
    }
    if (limit < 1) {
        return [];
    }
    const fixed = keyword.toLowerCase();
    const regexp = new RegExp(fixed, 'i');
    const namespaces = yield namespace_2.NamespaceModel.find({
        namespace: {
            $regex: regexp,
        },
    }).skip(page * limit).limit(limit).sort({ _id: -1 }).lean();
    return namespaces;
});
exports.getNamespacesByPageLean = getNamespacesByPageLean;
const getAllActiveNamespacesByPage = (limit, page) => __awaiter(void 0, void 0, void 0, function* () {
    if (page < 0) {
        return [];
    }
    if (limit < 1) {
        return [];
    }
    const namespaces = yield namespace_2.NamespaceModel.find({
        active: true,
    }).skip(page * limit).limit(limit).sort({ _id: -1 });
    return namespaces;
});
exports.getAllActiveNamespacesByPage = getAllActiveNamespacesByPage;
const getAllActiveNamespacesByPageLean = (limit, page) => __awaiter(void 0, void 0, void 0, function* () {
    if (page < 0) {
        return [];
    }
    if (limit < 1) {
        return [];
    }
    const namespaces = yield namespace_2.NamespaceModel.find({
        active: true,
    }).skip(page * limit).limit(limit).sort({ _id: -1 }).lean();
    return namespaces;
});
exports.getAllActiveNamespacesByPageLean = getAllActiveNamespacesByPageLean;
const getAllNamespacesByPage = (limit, page) => __awaiter(void 0, void 0, void 0, function* () {
    if (page < 0) {
        return [];
    }
    if (limit < 1) {
        return [];
    }
    const namespaces = yield namespace_2.NamespaceModel.find({}).skip(page * limit).limit(limit).sort({ _id: -1 });
    return namespaces;
});
exports.getAllNamespacesByPage = getAllNamespacesByPage;
const getAllNamespacesByPageLean = (limit, page) => __awaiter(void 0, void 0, void 0, function* () {
    if (page < 0) {
        return [];
    }
    if (limit < 1) {
        return [];
    }
    const namespaces = yield namespace_2.NamespaceModel.find({}).skip(page * limit).limit(limit).sort({ _id: -1 }).lean();
    return namespaces;
});
exports.getAllNamespacesByPageLean = getAllNamespacesByPageLean;
const getAllNamespaceNamespace = () => __awaiter(void 0, void 0, void 0, function* () {
    const namespaces = yield namespace_2.NamespaceModel.find({});
    return namespaces.map((namespace) => namespace.namespace);
});
exports.getAllNamespaceNamespace = getAllNamespaceNamespace;
const getAllActiveNamespaceNamespace = () => __awaiter(void 0, void 0, void 0, function* () {
    const namespaces = yield namespace_2.NamespaceModel.find({
        active: true,
    });
    return namespaces.map((namespace) => namespace.namespace);
});
exports.getAllActiveNamespaceNamespace = getAllActiveNamespaceNamespace;
const getAllNamespaceDomain = () => __awaiter(void 0, void 0, void 0, function* () {
    const namespaces = yield namespace_2.NamespaceModel.find({});
    return namespaces.map((namespace) => namespace.domain);
});
exports.getAllNamespaceDomain = getAllNamespaceDomain;
const getAllActiveNamespaceDomain = () => __awaiter(void 0, void 0, void 0, function* () {
    const namespaces = yield namespace_2.NamespaceModel.find({
        active: true,
    });
    return namespaces.map((namespace) => namespace.domain);
});
exports.getAllActiveNamespaceDomain = getAllActiveNamespaceDomain;
const getNamespacesIdsByNamespaces = (namespaces) => __awaiter(void 0, void 0, void 0, function* () {
    const fixes = namespaces.map((namespace) => namespace.toLowerCase());
    const namespaceInstances = yield namespace_2.NamespaceModel.find({
        namespace: {
            $in: fixes,
        },
    }, {
        _id: 1,
    });
    return namespaceInstances.map((namespaceInstance) => namespaceInstance._id);
});
exports.getNamespacesIdsByNamespaces = getNamespacesIdsByNamespaces;
const getNamespacesIdsByDomains = (domains) => __awaiter(void 0, void 0, void 0, function* () {
    const fixes = domains.map((domain) => domain.toLowerCase());
    const namespaceInstances = yield namespace_2.NamespaceModel.find({
        domain: {
            $in: fixes,
        },
    }, {
        _id: 1,
    });
    return namespaceInstances.map((namespaceInstance) => namespaceInstance._id);
});
exports.getNamespacesIdsByDomains = getNamespacesIdsByDomains;
const getNamespacesByQuery = (query) => __awaiter(void 0, void 0, void 0, function* () {
    return yield namespace_2.NamespaceModel.find(query);
});
exports.getNamespacesByQuery = getNamespacesByQuery;
const getOrganizationsByQueryLean = (query) => __awaiter(void 0, void 0, void 0, function* () {
    return yield namespace_2.NamespaceModel.find(query).lean();
});
exports.getOrganizationsByQueryLean = getOrganizationsByQueryLean;