mongoku 1.3.0 → 2.0.0

package/dist/lib/Factory.js

@@ -1,31 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const MongoManager_1 = require("./MongoManager");
-const HostsManager_1 = require("./HostsManager");
-class Factory {
-    get _initializedError() {
-        return new Error("Factory.load() must be called first");
-    }
-    get mongoManager() {
-        if (!this._mongoManager) {
-            throw this._initializedError;
-        }
-        return this._mongoManager;
-    }
-    get hostsManager() {
-        if (!this._hostsManager) {
-            throw this._initializedError;
-        }
-        return this._hostsManager;
-    }
-    async load() {
-        // Start by initializing the host manager (needed for mongo manager)
-        this._hostsManager = new HostsManager_1.HostsManager();
-        await this._hostsManager.load();
-        // Then we can initialize the mongo manager
-        this._mongoManager = new MongoManager_1.MongoManager();
-        await this._mongoManager.load();
-    }
-}
-const factory = new Factory();
-exports.default = factory;

package/dist/lib/HostsManager.js

@@ -1,81 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const path = require("path");
-const fs = require("fs");
-const os = require("os");
-const util = require("util");
-const Nedb = require("nedb");
-const DEFAULT_HOSTS = process.env.MONGOKU_DEFAULT_HOST ? process.env.MONGOKU_DEFAULT_HOST.split(';') : ['localhost:27017'];
-const DATABASE_FILE = process.env.MONGOKU_DATABASE_FILE || path.join(os.homedir(), '.mongoku.db');
-class HostsManager {
-    promise(fn) {
-        return util.promisify(fn.bind(this._db));
-    }
-    async load() {
-        let first = false;
-        try {
-            await fs.promises.stat(DATABASE_FILE);
-        }
-        catch (err) {
-            first = true;
-        }
-        this._db = new Nedb({
-            filename: DATABASE_FILE
-        });
-        const load = this.promise(this._db.loadDatabase);
-        await load();
-        if (first) {
-            await Promise.all(DEFAULT_HOSTS.map(async (hostname) => {
-                const insert = this.promise(this._db.insert);
-                return await insert({
-                    path: hostname
-                });
-            }));
-        }
-    }
-    getHosts() {
-        return new Promise((resolve, reject) => {
-            this._db.find({}, (err, hosts) => {
-                if (err) {
-                    return reject(err);
-                }
-                else {
-                    return resolve(hosts);
-                }
-            });
-        });
-    }
-    async add(path) {
-        return new Promise((resolve, reject) => {
-            this._db.update({
-                path: path
-            }, {
-                $set: {
-                    path: path
-                }
-            }, { upsert: true }, (err) => {
-                if (err) {
-                    return reject(err);
-                }
-                else {
-                    return resolve();
-                }
-            });
-        });
-    }
-    async remove(path) {
-        return new Promise((resolve, reject) => {
-            this._db.remove({
-                path: new RegExp(`${path}`)
-            }, (err) => {
-                if (err) {
-                    return reject(err);
-                }
-                else {
-                    return resolve();
-                }
-            });
-        });
-    }
-}
-exports.HostsManager = HostsManager;

package/dist/lib/JsonEncoder.js

@@ -1,59 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const MongoDb = require("mongodb");
-class JsonEncoder {
-    static encode(obj) {
-        if (obj instanceof MongoDb.ObjectID) {
-            return {
-                $type: 'ObjectId',
-                $value: obj.toHexString(),
-                $date: obj.generationTime * 1000
-            };
-        }
-        if (obj instanceof Date) {
-            return {
-                $type: 'Date',
-                $value: obj.toISOString()
-            };
-        }
-        if (obj instanceof RegExp) {
-            return {
-                $type: 'RegExp',
-                $value: {
-                    $pattern: obj.source,
-                    $flags: obj.flags
-                }
-            };
-        }
-        if (Array.isArray(obj)) {
-            return [...obj.map(JsonEncoder.encode)];
-        }
-        if (obj && typeof obj === 'object') {
-            for (const [key, value] of Object.entries(obj)) {
-                obj[key] = JsonEncoder.encode(value);
-            }
-        }
-        return obj;
-    }
-    static decode(obj) {
-        if (obj && obj.$type === 'ObjectId') {
-            return new MongoDb.ObjectID(obj.$value);
-        }
-        if (obj && obj.$type === "Date") {
-            return new Date(obj.$value);
-        }
-        if (obj && obj.$type === "RegExp") {
-            return new RegExp(obj.$value.$pattern, obj.$value.$flags);
-        }
-        if (Array.isArray(obj)) {
-            return [...obj.map(JsonEncoder.decode)];
-        }
-        if (obj && typeof obj === 'object') {
-            for (const [key, value] of Object.entries(obj)) {
-                obj[key] = JsonEncoder.decode(value);
-            }
-        }
-        return obj;
-    }
-}
-exports.default = JsonEncoder;

package/dist/lib/MongoManager.js

@@ -1,119 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const URL = require("url");
-const MongoDb = require("mongodb");
-const Factory_1 = require("../lib/Factory");
-const Server_1 = require("./Server");
-const Utils_1 = require("./Utils");
-class MongoManager {
-    constructor() {
-        this._servers = {};
-    }
-    async connect(host) {
-        const urlStr = host.path.startsWith('mongodb')
-            ? host.path
-            : `mongodb://${host.path}`;
-        const url = URL.parse(urlStr);
-        let hostname = url.host || host.path;
-        if (this._servers[hostname] instanceof Server_1.Server) {
-            // Already connected
-            return;
-        }
-        try {
-            const client = await MongoDb.MongoClient.connect(urlStr, {
-                useNewUrlParser: true
-            });
-            const server = new Server_1.Server(hostname, client);
-            this._servers[hostname] = server;
-            console.info(`[${hostname}] Connected to ${hostname}`);
-            await this.checkAuth(hostname);
-        }
-        catch (err) {
-            console.error(`Error while connecting to ${hostname}:`, err.code, err.message);
-            this._servers[hostname] = err;
-        }
-    }
-    getServer(name) {
-        const server = this._servers[name] || this._servers[`${name}:27017`];
-        if (!server) {
-            throw new Error('Server does not exist');
-        }
-        return server;
-    }
-    async checkAuth(name) {
-        const server = this.getServer(name);
-        if (server instanceof Error) {
-            return;
-        }
-        try {
-            await server.toJson();
-        }
-        catch (err) {
-            console.log(require('util').inspect(err, false, 20));
-            if (err.code == 13 && err.codeName == "Unauthorized") {
-                this._servers[name] = err;
-            }
-        }
-    }
-    async load() {
-        let hosts = await Factory_1.default.hostsManager.getHosts();
-        await Promise.all(hosts.map((h) => this.connect(h)));
-    }
-    removeServer(name) {
-        delete this._servers[name];
-    }
-    async getServersJson() {
-        const servers = [];
-        for (const [name, server] of Object.entries(this._servers)) {
-            if (server instanceof Error) {
-                servers.push({
-                    name: name,
-                    error: {
-                        code: server.code,
-                        name: server.name,
-                        message: server.message
-                    }
-                });
-            }
-            else {
-                const json = await server.toJson();
-                servers.push(json);
-            }
-        }
-        Utils_1.Utils.fieldSort(servers, "name");
-        return servers;
-    }
-    async getDatabasesJson(serverName) {
-        const server = this.getServer(serverName);
-        if (server instanceof Error) {
-            return [];
-        }
-        const json = await server.toJson();
-        return json.databases;
-    }
-    async getCollectionsJson(serverName, databaseName) {
-        const server = this.getServer(serverName);
-        if (server instanceof Error) {
-            return [];
-        }
-        const database = await server.database(databaseName);
-        if (!database) {
-            return [];
-        }
-        const json = await database.toJson();
-        return json.collections;
-    }
-    async getCollection(serverName, databaseName, collectionName) {
-        const server = this.getServer(serverName);
-        if (server instanceof Error) {
-            return;
-        }
-        const database = await server.database(databaseName);
-        if (!database) {
-            return;
-        }
-        const collection = await database.collection(collectionName);
-        return collection;
-    }
-}
-exports.MongoManager = MongoManager;

package/dist/lib/Server.js

@@ -1,45 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const Database_1 = require("./Database");
-const Utils_1 = require("./Utils");
-class Server {
-    get name() { return this._name; }
-    get size() { return this._size; }
-    constructor(name, client) {
-        this._name = name;
-        this._client = client;
-    }
-    async databases() {
-        const db = this._client.db("test");
-        const results = await db.admin().listDatabases();
-        this._size = results.totalSize;
-        const databases = [];
-        if (Array.isArray(results.databases)) {
-            for (const d of results.databases) {
-                const db = this._client.db(d.name);
-                const database = new Database_1.Database(d.name, d.sizeOnDisk, d.empty, db);
-                databases.push(database);
-            }
-        }
-        return databases;
-    }
-    async database(name) {
-        const databases = await this.databases();
-        return databases.find(d => d.name === name);
-    }
-    async toJson() {
-        const databases = await this.databases();
-        const dbsJson = [];
-        for (const database of databases) {
-            const json = await database.toJson();
-            dbsJson.push(json);
-        }
-        Utils_1.Utils.fieldSort(dbsJson, 'name');
-        return {
-            name: this.name,
-            size: this.size,
-            databases: dbsJson
-        };
-    }
-}
-exports.Server = Server;

package/dist/lib/Utils.js

@@ -1,20 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var Utils;
-(function (Utils) {
-    /**
-     * In-place sort of the given array of objects
-     * @param arr An array of objects
-     * @param field the field used to sort
-     * @param descending whether to use descending order
-     */
-    Utils.fieldSort = (arr, field, descending = false) => {
-        return arr.sort((a, b) => {
-            return (a[field] == b[field])
-                ? 0
-                : (a[field] > b[field])
-                    ? (descending) ? -1 : 1
-                    : (descending) ? 1 : -1;
-        });
-    };
-})(Utils = exports.Utils || (exports.Utils = {}));

package/dist/routes/api.js

@@ -1,201 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const express = require("express");
-const bodyParser = require("body-parser");
-const Factory_1 = require("../lib/Factory");
-exports.api = express.Router();
-// Get servers
-exports.api.get('/servers', async (req, res, next) => {
-    const servers = await Factory_1.default.mongoManager.getServersJson();
-    return res.json(servers);
-});
-exports.api.put('/servers', bodyParser.json(), async (req, res, next) => {
-    try {
-        await Factory_1.default.hostsManager.add(req.body.url);
-        await Factory_1.default.mongoManager.load();
-    }
-    catch (err) {
-        return next(err);
-    }
-    return res.json({
-        ok: true
-    });
-});
-exports.api.delete('/servers/:server', async (req, res, next) => {
-    try {
-        await Factory_1.default.hostsManager.remove(req.params.server);
-        Factory_1.default.mongoManager.removeServer(req.params.server);
-    }
-    catch (err) {
-        return next(err);
-    }
-    return res.json({
-        ok: true
-    });
-});
-exports.api.get('/servers/:server/databases', async (req, res, next) => {
-    const server = req.params.server;
-    try {
-        const databases = await Factory_1.default.mongoManager.getDatabasesJson(server);
-        return res.json(databases);
-    }
-    catch (err) {
-        return next(err);
-    }
-});
-exports.api.get('/servers/:server/databases/:database/collections', async (req, res, next) => {
-    const server = req.params.server;
-    const database = req.params.database;
-    try {
-        const collections = await Factory_1.default.mongoManager.getCollectionsJson(server, database);
-        return res.json(collections);
-    }
-    catch (err) {
-        return next(err);
-    }
-});
-exports.api.get('/servers/:server/databases/:database/collections/:collection/documents/:document', async (req, res, next) => {
-    const server = req.params.server;
-    const database = req.params.database;
-    const collection = req.params.collection;
-    const document = req.params.document;
-    try {
-        const c = await Factory_1.default.mongoManager.getCollection(server, database, collection);
-        if (!c) {
-            return next(new Error(`Collection not found: ${server}.${database}.${collection}`));
-        }
-        const doc = await c.findOne(document);
-        if (!doc) {
-            return next(new Error("This document does not exist"));
-        }
-        return res.json({
-            ok: true,
-            document: doc
-        });
-    }
-    catch (err) {
-        return next(err);
-    }
-});
-exports.api.post('/servers/:server/databases/:database/collections/:collection/documents/:document', bodyParser.json(), async (req, res, next) => {
-    const server = req.params.server;
-    const database = req.params.database;
-    const collection = req.params.collection;
-    const document = req.params.document;
-    const partial = !!req.query.partial;
-    try {
-        const c = await Factory_1.default.mongoManager.getCollection(server, database, collection);
-        if (!c) {
-            return next(new Error(`Collection not found: ${server}.${database}.${collection}`));
-        }
-        const update = await c.updateOne(document, req.body, partial);
-        return res.json({
-            ok: true,
-            update: update
-        });
-    }
-    catch (err) {
-        return next(err);
-    }
-});
-exports.api.delete('/servers/:server/databases/:database/collections/:collection/documents/:document', async (req, res, next) => {
-    const server = req.params.server;
-    const database = req.params.database;
-    const collection = req.params.collection;
-    const document = req.params.document;
-    try {
-        const c = await Factory_1.default.mongoManager.getCollection(server, database, collection);
-        if (!c) {
-            return next(new Error(`Collection not found: ${server}.${database}.${collection}`));
-        }
-        await c.removeOne(document);
-        return res.json({
-            ok: true
-        });
-    }
-    catch (err) {
-        return next(err);
-    }
-});
-exports.api.get('/servers/:server/databases/:database/collections/:collection/query', async (req, res, next) => {
-    const server = req.params.server;
-    const database = req.params.database;
-    const collection = req.params.collection;
-    let query = req.query.q;
-    if (typeof query !== "object") {
-        try {
-            query = JSON.parse(query);
-        }
-        catch (err) {
-            return next(new Error(`Invalid query: ${query}`));
-        }
-    }
-    let sort = req.query.sort || "{}";
-    if (sort && typeof sort !== "object") {
-        try {
-            sort = JSON.parse(sort);
-        }
-        catch (err) {
-            return next(new Error(`Invalid order: ${sort}`));
-        }
-    }
-    let project = req.query.project || "";
-    if (project && typeof project !== "object") {
-        try {
-            project = JSON.parse(project);
-        }
-        catch (err) {
-            return next(new Error(`Invalid project: ${project}`));
-        }
-    }
-    let limit = parseInt(req.query.limit, 10);
-    if (isNaN(limit)) {
-        limit = 20;
-    }
-    let skip = parseInt(req.query.skip, 10);
-    if (isNaN(skip)) {
-        skip = 0;
-    }
-    const c = await Factory_1.default.mongoManager.getCollection(server, database, collection);
-    if (!c) {
-        return next(new Error(`Collection not found: ${server}.${database}.${collection}`));
-    }
-    try {
-        const results = await c.find(query, project, sort, limit, skip);
-        return res.json({
-            ok: true,
-            results: results
-        });
-    }
-    catch (err) {
-        return next(err);
-    }
-});
-exports.api.get('/servers/:server/databases/:database/collections/:collection/count', async (req, res, next) => {
-    const server = req.params.server;
-    const database = req.params.database;
-    const collection = req.params.collection;
-    let query = req.query.q;
-    if (typeof query !== "object") {
-        try {
-            query = JSON.parse(query);
-        }
-        catch (err) {
-            return next(new Error(`Invalid query: ${query}`));
-        }
-    }
-    const c = await Factory_1.default.mongoManager.getCollection(server, database, collection);
-    if (!c) {
-        return next(new Error(`Collection not found: ${server}.${database}.${collection}`));
-    }
-    try {
-        const count = await c.count(query);
-        return res.json({
-            ok: true,
-            count: count
-        });
-    }
-    catch (err) {
-        return next(err);
-    }
-});

package/dist/server.js

@@ -1,57 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const path = require("path");
-const fs = require("fs");
-const express = require("express");
-const app = express();
-const Factory_1 = require("./lib/Factory");
-const api_1 = require("./routes/api");
-const setupServer = () => {
-    const SERVER_PORT = process.env.MONGOKU_SERVER_PORT || 3100;
-    app.get('/', (req, res, next) => {
-        res.sendFile("app/index.html", { root: __dirname }, (err) => {
-            if (err) {
-                return next(err);
-            }
-        });
-    });
-    app.use('/api', api_1.api);
-    app.get('/*', (req, res, next) => {
-        const ext = path.extname(req.url);
-        fs.stat(path.join(__dirname, "app", req.url), (err, stats) => {
-            let file = "index.html";
-            if (stats && stats.isFile()) {
-                file = req.url;
-            }
-            res.sendFile(file, { root: path.join(__dirname, "app") }, (err) => {
-                if (err) {
-                    return next(err);
-                }
-            });
-        });
-    });
-    app.use((err, req, res, next) => {
-        res.status(500);
-        return res.json({
-            ok: false,
-            message: err.message
-        });
-    });
-    app.listen(SERVER_PORT, () => console.log(`[Mongoku] listening on port ` + SERVER_PORT));
-};
-exports.start = async () => {
-    console.log(`[Mongoku] Starting...`);
-    try {
-        await Factory_1.default.load();
-        setupServer();
-    }
-    catch (err) {
-        console.error(err);
-        process.exit(1);
-    }
-};
-if (require.main === module) {
-    (async () => {
-        await exports.start();
-    })();
-}