@vandenberghinc/volt 1.1.2

package/backend/src/database.ts

@@ -0,0 +1,2241 @@
+/*
+ * Author: Daan van den Bergh
+ * Copyright: © 2022 - 2024 Daan van den Bergh.
+ */
+
+// ---------------------------------------------------------
+// Libraries.
+
+import { ChildProcess, spawn } from "child_process";
+import { deserialize, serialize } from "bson";
+import { Transform } from 'stream';
+import { MongoClient, Collection as MongoCollection, ObjectId } from 'mongodb';
+import { logger, LogSource } from "./logger.js";
+import { Status } from "./status.js";
+import { vlib } from "@vinc";
+
+const log_source = new LogSource("Database")
+
+// ---------------------------------------------------------
+// Collection.
+// Path based collection, so "myfile", "mydir/myfile".
+
+// @warning: The "path" param must always be allowed to be an object or string, also for the UIDCollection class.
+// @warning: THE DATABASE COLLECTION SHOULD ALSO ACCEPT OBJECTS FOR PATHS.
+/*  @docs:
+    @nav: Backend
+    @chapter: Database
+    @title: Collection
+    @desc: The database collection class.
+    @note: The document attribute `_path` is a reserved index attribute for the path of the document.
+    @attribute: 
+        @name: col
+        @desc: The native mongodb collection.
+*/
+class Collection {
+
+    // Static attributes.
+    static chunk_size: number = 1024 * 1024 * 4; // 4MB chunks, lower is better for frequent updates.
+    static constructor_scheme = {
+        name: "string",
+        uid_based: "boolean",
+        ttl: {type: "number", default: null},
+        indexes: {
+            type: "array",
+            default: [],
+            value_scheme: {
+                type: ["string", "object"],
+                scheme: {
+                    key: {type: "string", required: (data) => data.key == null && data.keys == null },
+                    keys: {
+                        type: ["string", "array"],
+                        required: (data) => data.key == null && data.keys == null, value_scheme: "string",
+                        postprocess: (keys) => typeof keys === "string" ? [keys] : keys,
+                    },
+                    options: {type: "object", required: false},
+                    commit_quorom: {type: "object", required: false},
+                    forced: {type: "boolean", default: false},
+                },
+                postprocess: (info) => {
+                    if (typeof info === "string") return {keys: [info]}
+                    if (typeof info === "object" && info.key) {
+                        info.keys = info.key;
+                        delete info.key;
+                        return info;
+                    }
+                    return info;
+                },
+            },
+        },
+    }
+
+    
+    // Instance attributes
+    col: MongoCollection;
+    name: string;
+    uid_based: boolean;
+    ttl: number | null;
+    ttl_enabled: boolean;
+
+    constructor(
+        name: string,
+        collection: MongoCollection,
+        ttl: number | null = null,
+        indexes: Array<{
+            keys: string[] | string | Record<string, any>,
+            options?: Record<string, any>,
+            commit_quorum?: any,
+            forced?: boolean
+        }> = [],
+        uid_based: boolean = false,
+    ) {
+
+        // Verify scheme.
+        ({indexes, ttl} = vlib.Scheme.verify({
+            object: {
+                name,
+                indexes,
+                ttl,
+                uid_based,
+            },
+            check_unknown: true,
+            scheme: Collection.constructor_scheme,
+        }));
+
+        // Attributes.
+        this.name = name;
+        this.col = collection;
+        this.uid_based = uid_based;
+        this.ttl = ttl;
+        this.ttl_enabled = typeof ttl === "number";
+
+        // Create default indexes.
+        if (uid_based) {
+            this.col.createIndex({ _path: 1, _uid: 1 });
+        } else {
+            this.col.createIndex({_path: 1});
+        }
+
+        // Create ttl index.
+        if (this.ttl_enabled) {
+            this.col.dropIndex("_ttl_timestamp_1")
+            .catch(err => {
+                if (err.codeName !== 'IndexNotFound') {
+                    throw err;
+                }    
+            })
+            .then(() => {
+                this.col.createIndex(
+                    {_ttl_timestamp: 1}, 
+                    {expireAfterSeconds: parseInt(String(this.ttl! / 1000))}
+                );
+            })
+        }
+
+        // Create indexes.
+        if (Array.isArray(indexes) && indexes.length > 0) {
+            for (const index of indexes) {
+                this.create_index({
+                    keys: index.keys,
+                    options: index.options,
+                    commit_quorum: index.commit_quorum,
+                    forced: index.forced,
+                })
+            }
+        }
+    }
+
+    // Handle file response.
+    private _process_doc<T>(doc: T | null): T | null {
+        if (doc == null) { return null; }
+        else if ((doc as any)._content != null) {
+            return (doc as any)._content;
+        }
+        return doc;
+    }
+
+    // Chunked methods.
+    private async _load_chunked(
+        path: string | Record<string, any>, 
+        find_opts?: Record<string, any>
+    ): Promise<any> {
+        let query = typeof path === "string" ? 
+            {_path: path, chunk: {$gte: 0}} : 
+            {...path, chunk: {$gte: 0}};
+        const chunks_cursor = this.col.find(query, find_opts).sort({chunk: 1});
+        const chunks = await chunks_cursor.toArray();
+        if (chunks.length === 0) {
+            return null;
+        }
+        const buffer = Buffer.concat(chunks.map(chunk => chunk.data.buffer));
+        return deserialize(buffer);
+    }
+
+    private async _save_chunked(
+        path: string | Record<string, any>, 
+        content: any
+    ): Promise<void> {
+
+        // Serialize.
+        const buffer = serialize(content);
+        const new_chunk_count = Math.ceil(buffer.length / Collection.chunk_size);
+
+        // Retrieve the old chunk count
+        const ref_query: any = typeof path === "string" ? 
+            {_path: path, chunk: -1} : 
+            {...path, chunk: -1};
+        const object_ref = await this.col.findOne(ref_query);
+        const old_chunk_count = object_ref ? object_ref.chunks : 0;
+
+        // Update chunks.
+        const bulk_ops: any[] = [];
+        for (let i = 0; i < buffer.length; i += Collection.chunk_size) {
+            let query: Record<string, any>, update: Record<string, any>;
+            if (typeof path === "string") {
+                query = {
+                    _path: path,
+                    chunk: i / Collection.chunk_size,
+                }
+                update = {
+                    chunk: i / Collection.chunk_size,
+                    data: buffer.slice(i, i + Collection.chunk_size)
+                }
+            } else {
+                query = {
+                    ...path,
+                    chunk: i / Collection.chunk_size,
+                }
+                update = {
+                    chunk: i / Collection.chunk_size,
+                    data: buffer.slice(i, i + Collection.chunk_size)
+                }
+            }
+            const full_update: Record<string, any> = {
+                $set: update,
+            };
+            if (this.ttl_enabled) {
+                full_update["$setOnInsert"] = { _ttl_timestamp: new Date() };
+            }
+            bulk_ops.push({
+                updateOne: {
+                    filter: query,
+                    update: full_update,
+                    upsert: true
+                }
+            });
+        }
+
+        // Update reference.
+        const full_update: Record<string, any> = {
+            $set: {
+                chunk: -1,
+                chunks: new_chunk_count,
+            },
+        };
+        if (this.ttl_enabled) {
+            full_update["$setOnInsert"] = { _ttl_timestamp: new Date() };
+        }
+        bulk_ops.push({
+            updateOne: {
+                filter: ref_query,
+                update: full_update,
+                upsert: true
+            }
+        });
+
+        // Write.
+        await this.col.bulkWrite(bulk_ops, {ordered: true});
+
+        // Delete any excess chunks if the new chunk count is less than the old chunk count
+        if (new_chunk_count < old_chunk_count) {
+            ref_query.chunk = {$gte: new_chunk_count};
+            await this.col.deleteMany(ref_query);
+        }
+    }
+
+    /*  @docs:
+        @title: Create index
+        @description: Creates indexes on collections.
+        @return:
+            Returns the document that was found or `null` when no document is found.
+        @parameter:
+            @name: keys
+            @desc: The `keys` argument for the orignal mongodb `createIndex()` function.
+        @parameter:
+            @name: options
+            @desc: The `options` argument for the orignal mongodb `createIndex()` function.
+        @parameter:
+            @name: commitQuorum
+            @desc: The `commitQuorum` argument for the orignal mongodb `createIndex()` function.
+     */
+    async create_index({
+        keys, 
+        options = null, 
+        commit_quorum = null, 
+        forced = false
+    }: {
+        keys: string[] | string | Record<string, any>, 
+        options?: Record<string, any> | null,
+        commit_quorum?: any,
+        forced?: boolean
+    }): Promise<string> {
+        let keys_obj: Record<string, number> = {};
+        if (typeof keys === "string") {
+            keys_obj = {};
+            keys_obj[keys] = 1;
+        }
+        else if (Array.isArray(keys)) {
+            keys_obj = {};
+            for (const key of keys) {
+                keys_obj[key] = 1;
+            }
+        }
+        else if (keys == null || typeof keys !== "object") {
+            vlib.Scheme.throw_invalid_type("keys", keys, ["string", "string[]", "object"], true);
+        } else {
+            keys_obj = keys;
+        }
+
+        // Drop index.
+        if (forced) {
+            try {
+                await this.col.dropIndex(
+                    options?.name ?? 
+                    Object.entries(keys_obj)
+                        .map(([key, value]) => `${key}_${value}`)
+                        .join('_')
+                )
+            } catch (err: any) {
+                if (err.codeName !== 'IndexNotFound') {
+                    throw err;
+                }
+            }
+        }
+
+        // Create index.
+        // @ts-ignore
+        return await this.col.createIndex(keys_obj, options || {}, commit_quorum)
+    }
+
+    /*  @docs:
+     *  @title: Find
+     *  @description: Find a document by a query.
+     *  @return:
+     *      Returns the document that was found or `null` when no document is found.
+     *  @parameter:
+     *      @name: query
+     *      @desc: The query options.
+     *      @type: object
+     */
+    async find(query: Record<string, any>): Promise<any> {
+        try {
+            return this._process_doc(await this.col.findOne(query));
+        } catch (error) {
+            console.error(error);
+            throw new Error('Encountered an error while finding the document.');
+        }
+    }
+
+    /*  @docs:
+     *  @title: Exists
+     *  @description: Check if a document exists.
+     *  @parameter:
+     *      @name: path
+     *      @description: The database path to the document.
+     *      @type: string
+     */
+    async exists(path: string | Record<string, any>): Promise<boolean> {
+        if (typeof path !== "string" && (typeof path !== "object" || path == null)) {
+            throw Error(`Parameter "path" has an invalid type "${typeof path}", the valid type is "string".`);
+        }
+        try {
+            const doc = await this.col.findOne(
+                typeof path === "object" ? path : {_path: path},
+                {projection: { _id: 1 }}
+            );
+            return doc != null;
+        } catch (error) {
+            console.error(error);
+            throw new Error('Encountered an error while checking if the document exists.');
+        }
+    }
+
+    /*  @docs:
+     *  @title: Load
+     *  @description: Load data by path.
+     *  @return:
+     *      Returns the loaded document.
+     *
+     *      Returns the `def` parameter when the data does not exist, keep in mind that when parameter `def` is an object it could be a reference to a defined variable.
+     *  @parameter:
+     *      @name: path
+     *      @description: The database path to the document.
+     *      @type: string
+     *  @parameter:
+     *      @name: opts
+     *      @desc: Additional options.
+     *      @type: null, object
+     *      @attribute:
+     *          @name: default
+     *          @description:
+     *              The default data to be returned when the data does not exist.
+     *  
+     *              When the type of attribute `default` is `object` then the keys that do not exist in the loaded object, but do exist in the default object will be inserted into the loaded object.
+     *          @type: null, object
+     *      @attribute:
+     *          @name: chunked
+     *          @description: Load a chunked document.
+     *          @type: null, object
+     *      @attribute:
+     *          @name: attributes
+     *          @description: The attributes to load.
+     *          @type: null, string[]
+     */
+    async load(
+        path: string | Record<string, any>, 
+        opts: {
+            default?: any,
+            chunked?: boolean,
+            attributes?: string[],
+            projection?: Record<string, any>
+        } | null = null
+    ): Promise<any> {
+        if (typeof path !== "string" && (typeof path !== "object" || path == null)) {
+            throw Error(`Parameter "path" has an invalid type "${typeof path}", the valid type is "string".`);
+        }
+        try {
+
+            // Get attributes.
+            let find_opts: {projection?: Record<string, any>} | undefined;
+            if (opts) {
+                if (opts.projection) {
+                    find_opts = {projection: opts.projection};
+                }
+                else if (opts.attributes) {
+                    find_opts = {projection: {
+                        _id: 1,
+                        _path: 1,
+                        _uid: 1,
+                    }};
+                    opts.attributes.forEach((i) => {
+                        if (find_opts?.projection) {
+                            find_opts.projection[i] = 1;
+                        }
+                    })
+                }
+            }
+
+            // Load doc.
+            let doc;
+            if (opts != null && opts.chunked === true) {
+                doc = await this._load_chunked(path, find_opts);
+            } else {
+
+                // Load.
+                doc = await this.col.findOne(
+                    typeof path === "object" ? path : {_path: path},
+                    find_opts,
+                );
+                this.clean(doc);
+            }
+
+            // Process doc.
+            doc = this._process_doc(doc);
+
+            // Handle default.
+            if (doc == null) {
+                if (opts != null && opts.default !== undefined) { return opts.default; }
+                return null;
+            }
+
+            // Insert default keys.
+            else if (opts != null && typeof opts.default === "object" && opts.default != null && Array.isArray(opts.default) === false) {
+                const set_defaults = (obj: Record<string, any>, defaults: Record<string, any>) => {
+                    Object.keys(defaults).forEach((key) => {
+                        if (obj[key] === undefined) {
+                            obj[key] = defaults[key];
+                        } else if (
+                            typeof obj[key] === "object" && !Array.isArray(obj[key]) && obj[key] != null &&
+                            typeof defaults[key] === "object" && !Array.isArray(defaults[key]) && defaults[key] != null
+                        ) {
+                            set_defaults(obj[key], defaults[key])
+                        }
+                    })
+                }
+                set_defaults(doc, opts.default);
+            }
+
+            // Response.
+            return doc;
+
+        } catch (error) {
+            console.error(error);
+            throw new Error('Encountered an error while loading the document.');
+        }
+    }
+
+    /*  @docs:
+     *  @title: Save
+     *  @description: Save data by path. When the document already exists this function only updates the specified content attributes.
+     *  @return:
+     *      Returns the updated document.
+     *  @parameter:
+     *      @name: path
+     *      @description: The database path to the document.
+     *      @type: string
+     *  @parameter:
+     *      @name: data
+     *      @description: The data to save.
+     *      @type: null, boolean, number, string, array, object
+     *  @parameter:
+     *      @name: opts
+     *      @desc: Additional options.
+     *      @type: null, object
+     *      @attribute:
+     *          @name: chunked
+     *          @description: Chunk the document into multiple documents, therefore documents larger than 16MB are supported.
+     *          @warning: Currently this option is only supported for types `object` and `array`.
+     *          @default: false
+     *          @type: boolean
+     *      @attribute:
+     *          @name: bulk
+     *          @description: Get a bulk operation object, so several operations can be executed in bulk.
+     *          @default: false
+     *          @type: boolean
+     *      @attribute:
+     *          @name: set
+     *          @description: By default the $set attribute is used for the content, with `opts.set` disabled you can create your own instructions. The `content` attribute must reflect this.
+     *          @warning: This does not work in combination with `opts.chunked`.
+     *          @default: true
+     *          @type: boolean
+     */
+    async save(
+        path: string | Record<string, any>, 
+        content: any, 
+        opts: {
+            chunked?: boolean,
+            bulk?: boolean,
+            set?: boolean
+        } | null = null
+    ): Promise<any> {
+        if (typeof path !== "string" && (typeof path !== "object" || path == null)) {
+            throw Error(`Parameter "path" has an invalid type "${typeof path}", the valid type is "string".`);
+        }
+        try {
+            // Vars.
+            let doc, set;
+
+            // Create set.
+            if (typeof content === "object" && Array.isArray(content) == false && content != null) {
+                delete content._id;
+                delete content._path;
+                delete content._uid;
+                delete content._ttl_timestamp;
+                set = content;
+            } else {
+                set = {_content: content};
+            }
+
+            // Save chunked.
+            if (opts != null && opts.chunked === true) {
+                await this._save_chunked(path, set);
+            }
+
+            // Save as single doc.
+            else {
+
+                // Apply $set rules.
+                if (opts == null || (opts.set !== false)) {
+                    set = {$set: set};
+                }
+
+                // Apply TTL.
+                if (this.ttl_enabled) {
+                    if (set["$setOnInsert"] === undefined) {
+                        set["$setOnInsert"] = {}
+                        set["$setOnInsert"]._ttl_timestamp = new Date();
+                    }
+                    else if (set["$setOnInsert"] != null && typeof set["$setOnInsert"] === "object") {
+                        set["$setOnInsert"]._ttl_timestamp = new Date();
+                    } else {
+                        throw new Error(`Undefined behaviour: Unable to assign the $setOnInsert data for ttl control.`);
+                    }
+                }
+
+                // Bulk operation.
+                if (opts != null && opts.bulk) {
+                    return {
+                        updateOne: {
+                            filter: typeof path === "object" ? path : {_path: path},
+                            update: set,
+                            upsert: true,
+                        }
+                    };
+                }
+
+                // Normal operation.
+                else {
+                    await this.col.updateOne(
+                        typeof path === "object" ? path : {_path: path},
+                        set,
+                        {upsert: true},
+                    );
+                }
+            }
+
+            // Response.
+            return content;
+
+        } catch (error) {
+            console.error(error);
+            throw new Error('Encountered an error while updating the document.');
+        }
+    }
+
+    // List.
+    /*  @docs:
+     *  @title: List
+     *  @description: List all child documents of directory path.
+     *  @parameter:
+     *      @name: path
+     *      @description: The database directory path.
+     *      @type: string
+     *  @parameter:
+     *      @name: options
+     *      @description: List options.
+     *      @type: object
+     *      @attribute:
+     *          @name: process
+     *          @description: Process the document. By default saved non object data will be stored under `_content`. Processing checks this attribute and uses that content instead when it is detected.
+     *          @type: boolean
+     *          @default: true
+     *      @attribute:
+     *          @name: projection
+     *          @description: The data attributes to retrieve, when left undefined all attributes are retrieved.
+     *          @type: object
+     *          @default: undefined
+     */
+    async list(
+        path: string | Record<string, any>, 
+        options: {
+            process?: boolean,
+            projection?: Record<string, any>
+        } = {}
+    ): Promise<any[]> {
+        if (typeof path !== "string" && (typeof path !== "object" || path == null)) {
+            throw Error(`Parameter "path" has an invalid type "${typeof path}", the valid type is "string".`);
+        }
+        if (typeof path === "string") {
+            while (path.length > 0 && path.charAt(path.length - 1) === "/") {
+                path = path.substr(0, path.length - 1);
+            }
+            if (path.length == 0) {
+                throw Error("Invalid path.");
+            }
+            path = {_path: {$regex: `^${path}/`}};
+        } else if ((path as Record<string, any>)._path) {
+            let _path = (path as Record<string, any>)._path;
+            while (_path.length > 0 && _path.charAt(_path.length - 1) === "/") {
+                _path = _path.substr(0, _path.length - 1);
+            }
+            if (_path.length == 0) {
+                throw Error("Invalid path.");
+            }
+            (path as Record<string, any>)._path = {$regex: `^${_path}/`};
+        }
+        try {
+            const docs = await this.col.find(path, {projection: options.projection}).toArray();
+            if (options.process === false) {
+                return docs;
+            }
+            return docs.map((doc) => this._process_doc(doc));
+        } catch (error) {
+            console.error(error);
+            throw new Error('Encountered an error while listing all documents.');
+        }
+    }
+
+    /*  @docs:
+     *  @title: List Query
+     *  @description: List all documents of the collection based on a query.
+     *  @parameter:
+     *      @name: query
+     *      @desc: The query options.
+     *      @type: object
+     *  @parameter:
+     *      @name: options
+     *      @description: List options.
+     *      @type: object
+     *      @attribute:
+     *          @name: process
+     *          @description: Process the document. By default saved non object data will be stored under `_content`. Processing checks this attribute and uses that content instead when it is detected.
+     *          @type: boolean
+     *          @default: true
+     *      @attribute:
+     *          @name: projection
+     *          @description: The data attributes to retrieve, when left undefined all attributes are retrieved.
+     *          @type: object
+     *          @default: undefined
+     */
+    async list_query(
+        query: Record<string, any> = {}, 
+        options: {
+            process?: boolean,
+            projection?: Record<string, any>
+        } = {}
+    ): Promise<any[]> {
+        try {
+            const docs = await this.col.find(query, {projection: options.projection}).toArray();
+            if (options.process === false) { return docs; }
+            return docs.map((doc) => this._process_doc(doc)) // list as array since the user might have used a path object width different attributes so dict is not reliable.
+        } catch (error) {
+            console.error(error);
+            throw new Error('Encountered an error while listing all documents.');
+        }
+    }
+
+    /*  @docs:
+     *  @title: List All
+     *  @description: List all documents of the collection, optionally per uid.
+     *  @parameter:
+     *      @name: query
+     *      @ignore: true
+     *  @parameter:
+     *      @name: options
+     *      @description: List options.
+     *      @type: object
+     *      @attribute:
+     *          @name: process
+     *          @description: Process the document. By default saved non object data will be stored under `_content`. Processing checks this attribute and uses that content instead when it is detected.
+     *          @type: boolean
+     *          @default: true
+     *      @attribute:
+     *          @name: projection
+     *          @description: The data attributes to retrieve, when left undefined all attributes are retrieved.
+     *          @type: object
+     *          @default: undefined
+     */
+    async list_all(
+        query: Record<string, any> = {}, 
+        options: {
+            process?: boolean,
+            projection?: Record<string, any>
+        } = {}
+    ): Promise<any[]> {
+        let docs;
+        if (this.uid_based) {
+            docs = await this.col.find(query, {projection: options.projection}).toArray();
+        } else {
+            docs = await this.col.find(query, {projection: options.projection}).toArray();
+        }
+        if (options.process === false) {
+            return docs;
+        }
+        return docs.map((doc) => this._process_doc(doc)) // list as array since the user might have used a path object width different attributes so dict is not reliable.
+    }
+
+    /*  @docs:
+     *  @title: Delete
+     *  @description: Delete a document of the collection by path.
+     *  @parameter:
+     *      @name: path
+     *      @description: The database path to the document.
+     *      @type: string
+     *  @parameter:
+     *      @name: opts
+     *      @desc: Additional options.
+     *      @type: null, object
+     *      @attribute:
+     *          @name: chunked
+     *          @description: Delete a chunked document.
+     *          @default: false
+     *          @type: boolean
+     *      @attribute:
+     *          @name: bulk
+     *          @description: Get a bulk operation object, so several operations can be executed in bulk.
+     *          @default: false
+     *          @type: boolean
+     */
+    async delete(
+        path: string | Record<string, any>, 
+        opts: {
+            chunked?: boolean,
+            bulk?: boolean
+        } | null = null
+    ): Promise<any> {
+        if (typeof path !== "string" && (typeof path !== "object" || path == null)) {
+            throw Error(`Parameter "path" has an invalid type "${typeof path}", the valid type is "string".`);
+        }
+        try {
+            if (opts != null && opts.chunked === true) {
+                if (opts.bulk) {
+                    return {deleteMany: {filter: typeof path === "object" ? path : {_path: path}}};
+                } else {
+                    await this.col.deleteMany(typeof path === "object" ? path : {_path: path});
+                }
+            } else {
+                if (opts != null && opts.bulk) {
+                    return {deleteOne: {filter: typeof path === "object" ? path : {_path: path}}};
+                } else {
+                    await this.col.deleteOne(typeof path === "object" ? path : {_path: path});
+                }
+            }
+        } catch (error) {
+            console.error(error);
+            throw new Error('Encountered an error while deleting.');
+        }
+    }
+
+    /*  @docs:
+     *  @title: Delete Query
+     *  @description: Delete a document of the collection by query.
+     *  @parameter:
+     *      @name: query
+     *      @description: The query object.
+     *      @type: object
+     */
+    async delete_query(query: Record<string, any> = {}): Promise<any> {
+        if (typeof query !== "object" || query == null || Object.keys(query).length === 0) {
+            throw Error(`Parameter "query" has an invalid type "${typeof query}", the valid type is "object".`);
+        }
+        if (Object.keys(query).length === 0) {
+            throw Error(`Parameter "query" is an empty object.`);
+        }
+        return await this.col.deleteMany(query)
+    }
+
+    // Delete all.
+    async delete_all(path: string | Record<string, any>): Promise<void> {
+        if (typeof path !== "string" && (typeof path !== "object" || path == null)) {
+            throw Error(`Parameter "path" has an invalid type "${typeof path}", the valid type is "string".`);
+        }
+        try {
+            await this.col.deleteMany(typeof path === "object" ? path : {_path: path});
+        } catch (error) {
+            console.error(error);
+            throw new Error('Encountered an error while deleting.');
+        }
+    }
+
+    /*  @docs:
+     *  @title: Delete Collection
+     *  @description: Delete all documents of from the collection.
+     */
+    async delete_collection(): Promise<void> {
+        await this.col.deleteMany()
+        await this.col.drop();
+    }
+
+    /*  @docs:
+     *  @title: Clean document
+     *  @description: Clean a document from all default system attributes.
+     */
+    clean<T>(doc: T): T | null {
+        if (doc == null) { return doc; }
+        if (typeof doc === "object") {
+            delete (doc as any)._id;
+            delete (doc as any)._path;
+            if (this.uid_based) {
+                delete (doc as any)._uid;
+            }
+            if (this.ttl_enabled) {
+                delete (doc as any)._ttl_timestamp;
+            }
+        }
+        return doc;
+    }
+
+    /** Write bulk operations. */
+    async bulk_operations(operations: any[] = []): Promise<any> {
+        return await this.col.bulkWrite(operations, {ordered: true});
+    }
+
+}
+
+// ---------------------------------------------------------
+// UID based collection.
+
+// @warning: The "path" param must always be allowed to be an object or string, also for the UIDCollection class.
+// @warning: THE DATABASE COLLECTION SHOULD ALSO ACCEPT OBJECTS FOR PATHS.
+/*  @docs:
+    @nav: Backend
+    @chapter: Database
+    @title: UID Collection
+    @desc: The UID based database collection class.
+    @note: The document attribute `_uid` is a reserved index attribute for the user id of the document.
+    @note: The document attribute `_path` is a reserved index attribute for the path of the document.
+    @attribute: 
+        @name: col
+        @desc: The native mongodb collection.
+*/
+class UIDCollection {
+    private _col: Collection;
+    col: MongoCollection;
+
+    constructor(
+        name: string,
+        collection: MongoCollection,
+        indexes: Array<{
+            keys: string[] | string | Record<string, any>,
+            options?: Record<string, any>,
+            commit_quorum?: any
+        }> = [],
+        ttl: number | null = null,
+    ) {
+        this._col = new Collection(name, collection, ttl, indexes, true);
+        this.col = this._col.col;
+    }
+
+    /*  @docs:
+        @title: Create index
+        @description: Creates indexes on collections.
+        @return:
+            Returns the document that was found or `null` when no document is found.
+        @parameter:
+            @name: keys
+            @desc: The `keys` argument for the orignal mongodb `createIndex()` function.
+        @parameter:
+            @name: options
+            @desc: The `options` argument for the orignal mongodb `createIndex()` function.
+        @parameter:
+            @name: commitQuorum
+            @desc: The `commitQuorum` argument for the orignal mongodb `createIndex()` function.
+     */
+    async create_index({
+        keys, 
+        options = null, 
+        commit_quorum = null
+    }: {
+        keys: string[] | string | Record<string, any>,
+        options?: Record<string, any> | null,
+        commit_quorum?: any
+    }): Promise<string> {
+        return this._col.create_index({keys, options, commit_quorum});
+    }
+
+    /*  @docs:
+     *  @title: Find
+     *  @description: Find a document by a query.
+     *  @return:
+     *      Returns the document that was found or `null` when no document is found.
+     *  @parameter:
+     *      @name: uid
+     *      @cached: Users:uid:param
+     *      @required: false
+     *  @parameter:
+     *      @name: query
+     *      @desc: The query options.
+     *      @type: object
+     */
+    async find(uid: string | null = null, query: Record<string, any> = {}): Promise<any> {
+        if (uid != null) {
+            query._uid = uid;
+        }
+        return await this._col.find(query);
+    }
+
+    /*  @docs:
+     *  @title: Exists
+     *  @description: Check if a document exists.
+     *  @parameter:
+     *      @name: uid
+     *      @cached: Users:uid:param
+     *  @parameter:
+     *      @name: path
+     *      @description: The database path to the document.
+     *      @type: string, object
+     */
+    async exists(uid: string, path: string | Record<string, any>): Promise<boolean> {
+        if (typeof path !== "string" && (typeof path !== "object" || path == null)) {
+            throw Error(`Parameter "path" has an invalid type "${typeof path}", the valid type is "string".`);
+        }
+        if (typeof uid !== "string") {
+            throw Error(`Parameter "uid" has an invalid type "${typeof uid}", the valid type is "string".`);
+        }
+        if (typeof path === "object") {
+            return await this._col.exists({...path, _uid: uid});
+        } else {
+            return await this._col.exists({_path: path, _uid: uid});
+        }
+    }
+
+    /*  @docs:
+     *  @title: Load
+     *  @description: Load data by user id and path.
+     *  @return:
+     *      Returns the loaded document.
+     *
+     *      Returns the `def` parameter when the data does not exist, keep in mind that when parameter `def` is an object it could be a reference to a defined variable.
+     *  @parameter:
+     *      @name: uid
+     *      @cached: Users:uid:param
+     *  @parameter:
+     *      @name: path
+     *      @description: The database path to the document.
+     *      @type: string, object
+     *  @parameter:
+     *      @name: opts
+     *      @desc: Additional options.
+     *      @type: null, object
+     *      @attribute:
+     *          @name: default
+     *          @description:
+     *              The default data to be returned when the data does not exist.
+     *  
+     *              When the type of attribute `default` is `object` then the keys that do not exist in the loaded object, but do exist in the default object will be inserted into the loaded object.
+     *          @type: null, object
+     */
+    async load(
+        uid: string, 
+        path: string | Record<string, any>, 
+        opts: {
+            default?: any,
+            chunked?: boolean,
+            attributes?: string[],
+            projection?: Record<string, any>
+        } | null = null
+    ): Promise<any> {
+        if (typeof path !== "string" && (typeof path !== "object" || path == null)) {
+            throw Error(`Parameter "path" has an invalid type "${typeof path}", the valid type is "string".`);
+        }
+        if (typeof uid !== "string") {
+            throw Error(`Parameter "uid" has an invalid type "${typeof uid}", the valid type is "string".`);
+        }
+        if (typeof path === "object") {
+            return await this._col.load({...path, _uid: uid}, opts);
+        } else {
+            return await this._col.load({_path: path, _uid: uid}, opts);
+        }
+    }
+
+    /*  @docs:
+     *  @title: Save
+     *  @description: Save data by user id and path. When the document already exists this function only updates the specified content attributes.
+     *  @return:
+     *      Returns the updated document.
+     *  @parameter:
+     *      @name: uid
+     *      @cached: Users:uid:param
+     *  @parameter:
+     *      @name: path
+     *      @description: The database path to the document.
+     *      @type: string, object
+     *  @parameter:
+     *      @name: data
+     *      @description: The data to save.
+     *      @type: null, boolean, number, string, array, object
+     *  @parameter:
+     *      @name: opts
+     *      @desc: Additional options.
+     *      @type: null, object
+     *      @attribute:
+     *          @name: chunked
+     *          @description: Chunk the document into multiple documents, therefore documents larger than 16MB are supported.
+     *          @warning: Currently this option is only supported for types `object` and `array`.
+     *          @default: false
+     *          @type: boolean
+     *      @attribute:
+     *          @name: bulk
+     *          @description: Get a bulk operation object, so several operations can be executed in bulk.
+     *          @default: false
+     *          @type: boolean
+     *      @attribute:
+     *          @name: set
+     *          @description: By default the $set attribute is used for the content, with `opts.set` disabled you can create your own instructions. The `content` attribute must reflect this.
+     *          @warning: This does not work in combination with `opts.chunked`.
+     *          @default: true
+     *          @type: boolean
+     */
+    async save(
+        uid: string, 
+        path: string | Record<string, any>, 
+        content: any, 
+        opts: {
+            chunked?: boolean,
+            bulk?: boolean,
+            set?: boolean
+        } | null = null
+    ): Promise<any> {
+        if (typeof path !== "string" && (typeof path !== "object" || path == null)) {
+            throw Error(`Parameter "path" has an invalid type "${typeof path}", the valid type is "string".`);
+        }
+        if (typeof uid !== "string") {
+            throw Error(`Parameter "uid" has an invalid type "${typeof uid}", the valid type is "string".`);
+        }
+        if (typeof path === "object") {
+            return await this._col.save({...path, _uid: uid}, content, opts);
+        } else {
+            return await this._col.save({_path: path, _uid: uid}, content, opts);
+        }
+    }
+
+    /*  @docs:
+     *  @title: List
+     *  @description: List all child documents of directory path.
+     *  @parameter:
+     *      @name: uid
+     *      @cached: Users:uid:param
+     *  @parameter:
+     *      @name: path
+     *      @description: The database directory path.
+     *      @type: string, object
+     *  @parameter:
+     *      @name: options
+     *      @description: List options.
+     *      @type: object
+     *      @attribute:
+     *          @name: process
+     *          @description: Process the document. By default saved non object data will be stored under `_content`. Processing checks this attribute and uses that content instead when it is detected.
+     *          @type: boolean
+     *          @default: true
+     *      @attribute:
+     *          @name: projection
+     *          @description: The data attributes to retrieve, when left undefined all attributes are retrieved.
+     *          @type: object
+     *          @default: undefined
+     */
+    async list(
+        uid: string, 
+        path: string | Record<string, any>, 
+        options: {
+            process?: boolean,
+            projection?: Record<string, any>
+        } = {}
+    ): Promise<any[]> {
+        if (typeof path !== "string" && (typeof path !== "object" || path == null)) {
+            throw Error(`Parameter "path" has an invalid type "${typeof path}", the valid type is "string".`);
+        }
+        if (typeof uid !== "string") {
+            throw Error(`Parameter "uid" has an invalid type "${typeof uid}", the valid type is "string".`);
+        }
+        if (typeof path === "object") {
+            return await this._col.list({...path, _uid: uid}, options)
+        } else {
+            return await this._col.list({_path: path, _uid: uid}, options)
+        }
+    }
+
+    /*  @docs:
+     *  @title: List Query
+     *  @description: List all documents of the collection based on a query.
+     *  @parameter:
+     *      @name: query
+     *      @desc: The query options.
+     *      @type: object
+     *  @parameter:
+     *      @name: options
+     *      @description: List options.
+     *      @type: object
+     *      @attribute:
+     *          @name: process
+     *          @description: Process the document. By default saved non object data will be stored under `_content`. Processing checks this attribute and uses that content instead when it is detected.
+     *          @type: boolean
+     *          @default: true
+     *      @attribute:
+     *          @name: projection
+     *          @description: The data attributes to retrieve, when left undefined all attributes are retrieved.
+     *          @type: object
+     *          @default: undefined
+     */
+    async list_query(
+        query: Record<string, any> = {}, 
+        options: {
+            process?: boolean,
+            projection?: Record<string, any>
+        } = {}
+    ): Promise<any[]> {
+        return await this._col.list_query(query, options);
+    }
+
+    /*  @docs:
+     *  @title: List All
+     *  @description: List all documents of the collection, optionally per uid.
+     *  @parameter:
+     *      @name: uid
+     *      @cached: Users:uid:param
+     *  @parameter:
+     *      @name: options
+     *      @description: List options.
+     *      @type: object
+     *      @attribute:
+     *          @name: process
+     *          @description: Process the document. By default saved non object data will be stored under `_content`. Processing checks this attribute and uses that content instead when it is detected.
+     *          @type: boolean
+     *          @default: true
+     *      @attribute:
+     *          @name: projection
+     *          @description: The data attributes to retrieve, when left undefined all attributes are retrieved.
+     *          @type: object
+     *          @default: undefined
+     */
+    async list_all(
+        uid: string | null = null,
+        options: {
+            process?: boolean,
+            projection?: Record<string, any>
+        } = {}
+    ): Promise<any[]> {
+        if (uid == null) {
+            return await this._col.list_all({}, options)
+        } else {
+            return await this._col.list_all({_uid: uid}, options);
+        }
+    }
+
+    /*  @docs:
+     *  @title: Delete
+     *  @description: Delete a document of the collection by uid and path.
+     *  @parameter:
+     *      @name: uid
+     *      @cached: Users:uid:param
+     *  @parameter:
+     *      @name: path
+     *      @description: The database path to the document.
+     *      @type: string, object
+     *  @parameter:
+     *      @name: opts
+     *      @desc: Additional options.
+     *      @type: null, object
+     *      @attribute:
+     *          @name: chunked
+     *          @description: Delete a chunked document.
+     *          @default: false
+     *          @type: boolean
+     *      @attribute:
+     *          @name: bulk
+     *          @description: Get a bulk operation object, so several operations can be executed in bulk.
+     *          @default: false
+     *          @type: boolean
+     */
+    async delete(
+        uid: string, 
+        path: string | Record<string, any>, 
+        opts: {
+            chunked?: boolean,
+            bulk?: boolean
+        } | null = null
+    ): Promise<any> {
+        if (typeof path !== "string" && (typeof path !== "object" || path == null)) {
+            throw Error(`Parameter "path" has an invalid type "${typeof path}", the valid type is "string".`);
+        }
+        if (typeof uid !== "string") {
+            throw Error(`Parameter "uid" has an invalid type "${typeof uid}", the valid type is "string".`);
+        }
+        if (typeof path === "object") {
+            return await this._col.delete({...path, _uid: uid}, opts)
+        } else {
+            return await this._col.delete({_path: path, _uid: uid}, opts)
+        }
+    }
+
+    /*  @docs:
+     *  @title: Delete Query
+     *  @description: Delete a document of the collection by query.
+     *  @parameter:
+     *      @name: query
+     *      @description: The query object.
+     *      @type: object
+     */
+    async delete_query(query: Record<string, any>): Promise<any> {
+        if (typeof query !== "object" || query == null || Object.keys(query).length === 0) {
+            throw Error(`Parameter "query" has an invalid type "${typeof query}", the valid type is "object".`);
+        }
+        if (Object.keys(query).length === 0) {
+            throw Error(`Parameter "query" is an empty object.`);
+        }
+        return await this._col.delete_query(query)
+    }
+
+    // Delete all.
+    async delete_all(
+        uid: string, 
+        path: string | Record<string, any> | null = null
+    ): Promise<void> {
+        if (typeof uid !== "string") {
+            throw Error(`Parameter "uid" has an invalid type "${typeof uid}", the valid type is "string".`);
+        }
+        if (path == null) {
+            return await this._col.delete_all({_uid: uid})
+        }
+        else if (typeof path === "object") {
+            return await this._col.delete_all({...path, _uid: uid})
+        } else {
+            return await this._col.delete_all({_path: path, _uid: uid})
+        }
+    }
+
+    /*  @docs:
+     *  @title: Delete Collection
+     *  @description: Delete all documents of from the collection.
+     */
+    async delete_collection(): Promise<void> {
+        await this._col.delete_collection()
+    }
+
+    /*  @docs:
+     *  @title: Clean document
+     *  @description: Clean a document from all default system attributes.
+     */
+    clean<T>(doc: T): T | null {
+        return this._col.clean(doc);
+    }
+
+    /** Write bulk operations. */
+    async bulk_operations(operations: any[] = []): Promise<any> {
+        return await this.col.bulkWrite(operations, {ordered: true});
+    }
+}
+
+// ---------------------------------------------------------
+// Database.
+
+/*  @docs:
+    @nav: Backend
+    @chapter: Database
+    @title: Database
+    @desc: 
+        The MongoDB database class, accessable under `Server.db`.
+
+        The database class can be utilized in two ways.
+
+        1. You only provide the `uri` parameter to access an already running mongodb database.
+
+        2. You provide parameters `config` and `start_args` to start and optionally create the database.
+
+    @warning: 
+        Do not forget to enable TLS when using the `config` parameter.
+    @param:
+        @name: uri
+        @desc: The mongodb server uri.
+        @type: string
+    @param:
+        @name: source
+        @desc: The source path of the database directory, by default path `$server_source/.db` will be used.
+        @type: null, string
+    @param:
+        @name: config
+        @desc: The json data for the mongodb config file.
+        @type: null, string
+    @param:
+        @name: start_args
+        @desc: The mongod database start command arguments.
+        @type: null, array[string]
+    @param:
+        @name: client
+        @desc: The MongoClient options.
+        @type: null, object
+*/
+class Database {
+    static constructor_scheme = {
+        uri: {type: "string", default: null},
+        source: {type: "string", default: null},
+        config: {type: "object", default: {}},
+        start_args: {type: "array", default: []},
+        client: {type: "object", default: {}},
+        collections: {type: "array", default: [], value_scheme: {
+            type: ["string", "object"],
+            preprocess: (info: string | Record<string, any>) => typeof info === "string" ? {name: info} : info,
+            scheme: {
+                name: Collection.constructor_scheme.name,
+                ttl: Collection.constructor_scheme.ttl,
+                indexes: Collection.constructor_scheme.indexes,
+            },
+        }},
+        uid_collections: {type: "array", default: [], value_scheme: {
+            type: ["string", "object"],
+            preprocess: (info: string | Record<string, any>) => typeof info === "string" ? {name: info} : info,
+            scheme: {
+                name: Collection.constructor_scheme.name,
+                ttl: Collection.constructor_scheme.ttl,
+                indexes: Collection.constructor_scheme.indexes,
+            },
+        }},
+        preview: {type: "boolean", default: true},
+        preview_ip_whitelist: {type: "array", default: []},
+        daemon: {type: ["object", "boolean"], default: {}},
+        _server: "object",
+    }
+
+    uri: string | null;
+    preview: boolean;
+    preview_ip_whitelist: string[];
+    client_opts: Record<string, any> | null;
+    config: Record<string, any>;
+    source: any; // Using vlib.Path type
+    start_args: string[];
+    _collections: Array<{
+        name: string,
+        ttl?: number | null,
+        indexes?: Array<{
+            keys: string[] | string | Record<string, any>,
+            options?: Record<string, any>,
+            commit_quorum?: any
+        }>,
+    }>;
+    _uid_collections: Array<{
+        name: string,
+        ttl?: number | null,
+        indexes?: Array<{
+            keys: string[] | string | Record<string, any>,
+            options?: Record<string, any>,
+            commit_quorum?: any
+        }>,
+    }>;
+    server: any;
+    client: MongoClient | null;
+    collections: Record<string, Collection | UIDCollection>;
+    proc?: ChildProcess;
+    daemon?: any;
+    db?: any;
+
+    constructor({
+        uri = null,
+        source = null,
+        config = null,
+        start_args = [],
+        client = null,
+        collections = [],
+        uid_collections = [],
+        preview = true,
+        preview_ip_whitelist = [],
+        daemon = {},
+        _server,
+    }: {
+        uri?: string | null,
+        source?: string | null,
+        config?: Record<string, any> | null,
+        start_args?: string[],
+        client?: Record<string, any> | null,
+        collections?: Array<{
+            name: string,
+            ttl?: number | null,
+            indexes?: Array<{
+                keys: string[] | string | Record<string, any>,
+                options?: Record<string, any>,
+                commit_quorum?: any
+            }>,
+        }>,
+        uid_collections?: Array<{
+            name: string,
+            ttl?: number | null,
+            indexes?: Array<{
+                keys: string[] | string | Record<string, any>,
+                options?: Record<string, any>,
+                commit_quorum?: any
+            }>,
+        }>,
+        preview?: boolean,
+        preview_ip_whitelist?: string[],
+        daemon?: Record<string, any> | boolean,
+        _server: any,
+    }) {
+        // Checks.
+        if (_server.is_primary && uri == null) {
+            ({uri, config, start_args, config, client} = vlib.Scheme.verify({
+                object: arguments[0], 
+                check_unknown: true, 
+                scheme: Database.constructor_scheme
+            }));
+        }
+        // Arguments.
+        this.uri = uri;
+        this.preview = preview;
+        this.preview_ip_whitelist = preview_ip_whitelist;
+        this.client_opts = client;
+        this.config = config || {};
+        this.source = source != null ? new vlib.Path(source) : _server.source.join(".db");
+        this.start_args = start_args;
+        this._collections = collections;
+        this._uid_collections = uid_collections;
+        this.server = _server;
+
+        // Attributes.
+        this.client = null;
+        this.collections = {};
+
+        // Initialize the service daemon.
+        if (this.server.daemon && daemon !== false) {
+            const log_source = this.server.source.join(".logs");
+            if (!log_source.exists()) {
+                log_source.mkdir_sync();
+            }
+            this.daemon = new vlib.Daemon({
+                name: this.server.daemon.name + ".mongodb",
+                user: (daemon as Record<string, any>).user || this.server.daemon.user,
+                group: (daemon as Record<string, any>).group || this.server.daemon.group,
+                command: "mongod",
+                cwd: this.server.daemon.cwd,
+                args: ["--config", this.source.join("mongod.json").str(), ...this.start_args],
+                env: (daemon as Record<string, any>).env || this.server.daemon.env,
+                description: (daemon as Record<string, any>).description || `Service daemon for the mongo database of website ${this.server.domain}.`,
+                auto_restart: true,
+                logs: (daemon as Record<string, any>).logs || log_source.join("logs.mongodb").str(),
+                errors: (daemon as Record<string, any>).errors || log_source.join("errors.mongodb").str(),
+            })
+        }
+    }
+
+    // Database preview.
+    _initialize_db_preview(): void {
+        /*
+        if (this.preview && this.server.production === false) {
+            this.server.endpoint(
+
+                // Database preview.
+                {
+                    method: "GET"   ,
+                    endpoint: "/volt/db/preview",
+                    view: {
+                        callback: () => {
+                            volt.utils.on_load(async () => {
+                                
+                                // Style theme.   
+                                const style = {
+                                    // bg: "#151721",
+                                    // sub_bg: "#191B28",
+                                    // tag_bg: "#1C203A",
+                                    // div_bg: "#282B40",
+                                    // fg: "#FFFFFF",
+                                    // sub_fg: "#FFFFFF99",
+                                    // tag_fg: "#FFFFFF",
+
+                                    bg: "#F6F8F8",
+                                    sub_bg: "#FFFFFF",
+                                    tag_bg: "#F6F8F8",
+                                    div_bg: "#00000010",
+                                    fg: "#32334F",
+                                    sub_fg: "#31344599",
+                                    tag_fg: "#313445",
+                                };
+
+                                // List all collections.
+                                const collections = (await volt.utils.request({url: "/volt/db/collections"})).collections;
+
+                                // Render a list.
+                                const prev_lists = [];
+                                function RenderList ({
+                                    title, 
+                                    list, 
+                                    doc = null,
+                                    add_prev = true,
+                                }) {
+                                    if (add_prev) {
+                                        prev_lists.append({title, list, doc});
+                                    }
+
+                                    // Object view.
+                                    const obj_view = VStack();
+                                    const refresh_obj_view = () => {
+                                        obj_view.inner_html("");
+                                        let index = 0;
+                                        obj_view.append(
+                                            ForEach(list, (key, value) => {
+                                                ++index;
+                                                let current_key = key;
+                                                let value_type = Array.isArray(value) ? "array" : value == null ? "null" : typeof value;
+                                                if (Array.isArray(value)) {
+                                                    value = JSON.stringify(value, null, 4)
+                                                }
+
+                                                // Key input.
+                                                const key_input = Input("key")
+                                                    .value(key)
+                                                    .font_family("'Menlo', 'Consolas', monospace")
+                                                    .color(style.sub_fg)
+                                                    .font_size(14)
+                                                    .padding(0)
+                                                    .readonly(key === "_path" || key === "_uid" || key === "uid")
+                                                    .on_mouse_over(e => e.color(style.fg))
+                                                    .on_mouse_out(e => e.color(style.sub_fg))
+                                                    .on_render((e) => e.width(e.text_width(key)))
+                                                    .on_input((e) => {
+                                                        if (key != current_key) {
+                                                            list[e.value()] = list[current_key];
+                                                            delete list[current_key];
+                                                            current_key = e.value();
+                                                        }
+                                                        e.width(e.text_width(current_key));
+                                                    });
+
+                                                // Value input.
+                                                const value_input = Input("value")
+                                                        .value(value == null ? "null" : value)
+                                                        .font_family("'Menlo', 'Consolas', monospace")
+                                                        .color(style.sub_fg)
+                                                        .display("inline-block")
+                                                        .width("fit-content")
+                                                        .font_size(14)
+                                                        .readonly(key === "_path" || key === "_uid")
+                                                        .stretch(true)
+                                                        .on_mouse_over(e => e.color(style.fg))
+                                                        .on_mouse_out(e => e.color(style.sub_fg))
+                                                        .on_input(() => {
+                                                            clearTimeout(value_input.timeout)
+                                                            value_input.timeout = setTimeout(update_value, 500);
+                                                        })
+
+                                                // Type select.
+                                                const type_select = ExtendedSelect({items: ["null", "boolean", "number", "string", "array", "object"]})
+                                                    .center()
+                                                    .margin(0)
+                                                    .max_width(73)
+                                                    .color(style.sub_fg)
+                                                    .font_size(14)
+                                                    .border_radius(10)
+                                                    .background(style.tag_bg)
+                                                    .border_color(style.div_bg)
+                                                    .value(value_type)
+                                                    .container
+                                                        .padding(2.5, 5)
+                                                        .parent();
+
+                                                // Update the list after edits.
+                                                const update_value = () => {
+                                                    const type = type_select.value();
+                                                    const value = value_input.value();
+                                                    if (type === "null") {
+                                                        list[current_key] = null;
+                                                        value_input.value(list[current_key].toString());
+                                                    }
+                                                    else if (type === "boolean") {
+                                                        list[current_key] = value == "true" || value == "True" || value == "TRUE" || value == "1";
+                                                        value_input.value(list[current_key].toString());
+                                                    }
+                                                    else if (type === "number") {
+                                                        if (value.indexOf(".") === -1) {
+                                                            list[current_key] = paseInt(value);
+                                                        } else {
+                                                            list[current_key] = paseFloat(value);
+                                                        }
+                                                        if (isNaN(list[key_input.key])) {
+                                                            list[current_key] = 0;
+                                                        }
+                                                        value_input.value(list[current_key].toString());
+                                                    }
+                                                    else if (type === "string") {
+                                                        list[current_key] = value;
+                                                    }
+                                                    else if (type === "object") {
+                                                        list[current_key] = JSON.parse(value);
+                                                    }
+                                                }
+                                                
+                                                // Row.
+                                                const row = HStack(
+                                                    key_input,
+                                                    Text(" : ")
+                                                        .white_space("pre")
+                                                        .font_family("'Menlo', 'Consolas', monospace")
+                                                        .color(style.sub_fg)
+                                                        .font_size(14),
+                                                    value_input,
+                                                    type_select,
+
+                                                    index < Object.keys(list).length ? null : VStack("add")
+                                                        .background(style.tag_bg)
+                                                        .padding(5, 12.5)
+                                                        .border_radius(10)
+                                                        .font_size(13)
+                                                        .color("#3B8553")
+                                                        .margin_left(10)
+                                                        .border(1, style.div_bg)
+                                                        .on_click(() => {
+                                                            list["_new"] = "";
+                                                            refresh_obj_view();
+                                                        }),
+
+                                                    VStack("delete")
+                                                        .background(style.tag_bg)
+                                                        .color("#B2321E")
+                                                        .padding(5, 12.5)
+                                                        .border_radius(10)
+                                                        .font_size(13)
+                                                        .margin_left(10)
+                                                        .border(1, style.div_bg)
+                                                        .on_click(async () => {
+                                                        }),
+                                                )
+                                                .center_vertical()
+                                                .padding(7.5, 0)
+                                                if (volt.utils.is_obj(value)) {
+                                                    row.on_click(() => RenderList({title: `${title}.${key}`, list: value}));
+                                                }
+                                                return [
+                                                    row,
+                                                    Divider().background(style.div_bg),
+                                                ]
+                                            })
+                                        );
+                                    }
+
+                                    // Add.
+                                    preview.inner_html("");
+                                    preview.append(
+                                        Scroller(
+                                            VStack(
+                                                HStack(
+                                                    Title("Database")
+                                                        .font_family("'Menlo', 'Consolas', monospace")
+                                                        .font_size(12)
+                                                        .color(style.tag_fg)
+                                                        .background(style.tag_bg)
+                                                        .padding(5, 12.5)
+                                                        .border_radius(10)
+                                                        .margin(0, 0, 0, 0)
+                                                        .border(1, style.div_bg)
+                                                        .width("fit-content"),
+
+                                                    Spacer(),
+
+                                                    doc == null ? null : Button("Update")
+                                                        .background(style.tag_bg)
+                                                        .color("#3B8553")
+                                                        .padding(5, 12.5)
+                                                        .margin_right(10)
+                                                        .border_radius(10)
+                                                        .border(1, style.div_bg)
+                                                        .on_click(() => {
+                                                            // --prev_lists.length;
+                                                            // const last = prev_lists[prev_lists.length - 1];
+                                                            // RenderList({...last, add_prev: false})
+                                                        }),
+
+                                                    doc == null ? null : Button("Delete")
+                                                        .background(style.tag_bg)
+                                                        .color("#B2321E")
+                                                        .padding(5, 12.5)
+                                                        .margin_right(10)
+                                                        .border_radius(10)
+                                                        .border(1, style.div_bg)
+                                                        .on_click(async () => {
+                                                            volt.utils.request({
+                                                                method: "DELETE",
+                                                                url: "/volt/db/document",
+                                                                data: doc,
+                                                            })
+                                                            --prev_lists.length;
+                                                            const last = prev_lists[prev_lists.length - 1];
+
+                                                            const __name = doc.uid != null ? `${doc.uid}:${doc.id}` : doc.id
+                                                            const filtered_list = [];
+                                                            last.list.iterate((item) => {
+                                                                if (item.__name !== __name) {
+                                                                    filtered_list.append(item);
+                                                                }
+                                                            })
+                                                            last.list = filtered_list;
+                                                            RenderList({...last, add_prev: false})
+                                                        }),
+
+                                                    prev_lists.length == 1 ? null : Button("Prev")
+                                                        .background(style.tag_bg)
+                                                        .color(style.tag_fg)
+                                                        .padding(5, 12.5)
+                                                        .border_radius(10)
+                                                        .border(1, style.div_bg)
+                                                        .on_click(() => {
+                                                            --prev_lists.length;
+                                                            const last = prev_lists[prev_lists.length - 1];
+                                                            RenderList({...last, add_prev: false})
+                                                        }),
+                                                ),
+
+                                                Title(title)
+                                                    .font_family("'Menlo', 'Consolas', monospace")
+                                                    .font_size(18)
+                                                    .color(style.fg)
+                                                    .margin(15, 0),
+
+                                                Divider().background(style.div_bg),
+
+                                                Array.isArray(list)
+                                                    ? ForEach(list, (item) => {
+                                                        return [
+                                                            VStack(
+                                                                Text(item.__name)
+                                                                    .font_family("'Menlo', 'Consolas', monospace")
+                                                                    .color(style.sub_fg)
+                                                                    .font_size(14)
+                                                                    .on_mouse_over(e => e.color(style.fg))
+                                                                    .on_mouse_out(e => e.color(style.sub_fg))
+                                                            )
+                                                            .padding(7.5, 0)
+                                                            .on_click(item.__click),
+
+                                                            Divider().background(style.div_bg),
+                                                        ]
+                                                    })
+                                                    : () => {refresh_obj_view(); return obj_view}
+                                            )
+                                            .margin(25, 50)
+                                            .padding(25, 25)
+                                            .background(style.sub_bg)
+                                            .border_radius(10)
+                                            .box_shadow("0px 0px 5px #00000090")
+                                        )
+                                        .font_family("Helvetica, sans-serif")
+                                        .background(style.bg)
+                                        .frame("100%", "100%")
+                                    )
+                                }
+
+                                // Render the collections.
+                                const RenderCollections = () => {
+                                    RenderList({title: "/", list: collections.iterate_append((item) => {
+                                        return {
+                                            __name: `${item}/`,
+                                            __click: () => RenderCollection(item),
+                                        }
+                                    })})
+                                }
+
+                                // Render a collection.
+                                const RenderCollection = async (collection) => {
+                                    const documents = (await volt.utils.request({url: "/volt/db/documents", data: {collection}})).documents;
+                                    RenderList({title: `${collection}/`, list: documents.iterate_append((item) => {
+                                        return {
+                                            __name: item._uid != null ? `${item._uid}:${item._path}` : item._path,
+                                            __click: () => RenderDocument(collection, item._path, item._uid),
+                                        }
+                                    })})
+                                }
+
+                                // Render a document.
+                                const RenderDocument = async (collection, path, uid = null) => {
+                                    let doc = (await volt.utils.request({url: "/volt/db/document", data: {collection, path, uid}})).document
+                                    if (Array.isArray(doc)) {
+                                        doc = {_content: doc};
+                                    }
+                                    RenderList({
+                                        title: uid != null ? `${collection}/${uid}:${path}` : `${collection}/${path}`, 
+                                        list: doc,
+                                        doc: {collection, uid, path},
+                                    })
+                                }
+
+                                // Stack.
+                                const preview = VStack()
+                                    .position(0, 0, 0, 0);
+
+                                // Render all collections.
+                                RenderCollections();
+
+                                // Response.
+                                return preview;
+
+                            });
+                        }
+                    }
+                },
+
+                // Get collections.
+                {
+                    method: "GET",
+                    endpoint: "/volt/db/collections",
+                    content_type: "application/json",
+                    rate_limit: "global",
+                    callback: async (stream) => {
+
+                        // Check ip whitelist.
+                        if (!this.preview_ip_whitelist.includes(stream.ip)) {
+                            return stream.error({status: Status.forbidden});
+                        }
+
+                        // Sign in.
+                        return stream.success({data: {
+                            message: "Successfully retrieved all collections.",
+                            collections: await this.get_collections(),
+                        }});
+                    }
+                },
+
+                // Get collection documents.
+                {
+                    method: "GET",
+                    endpoint: "/volt/db/documents",
+                    content_type: "application/json",
+                    rate_limit: "global",
+                    params: {
+                        collection: "string",
+                    },
+                    callback: async (stream, params) => {
+
+                        // Check ip whitelist.
+                        if (!this.preview_ip_whitelist.includes(stream.ip)) {
+                            return stream.error({status: Status.forbidden});
+                        }
+
+                        // Check collection.
+                        let col;
+                        if ((col = this.collections[params.collection]) == null) {
+                            return stream.error({data: {error: `Invalid collection "${params.collection}".`}})
+                        }
+
+                        // Load docs.
+                        let docs = await col.list_all();
+
+                        // Sign in.
+                        return stream.success({data: {
+                            message: "Successfully loaded the document.",
+                            documents: docs,
+                        }});
+                    }
+                },
+
+                // Get document.
+                {
+                    method: "GET",
+                    endpoint: "/volt/db/document",
+                    content_type: "application/json",
+                    rate_limit: "global",
+                    params: {
+                        collection: "string",
+                        path: ["string", "object"],
+                        uid: {type: ["string", "null"], default: null},
+                    },
+                    callback: async (stream, params) => {
+
+                        // Check ip whitelist.
+                        if (!this.preview_ip_whitelist.includes(stream.ip)) {
+                            return stream.error({status: Status.forbidden});
+                        }
+
+                        // Check collection.
+                        let col;
+                        if ((col = this.collections[params.collection]) == null) {
+                            return stream.error({data: {error: `Invalid collection "${params.collection}".`}})
+                        }
+
+                        // Load doc.
+                        let doc;
+                        if (params.uid == null) {
+                            doc = await col.load(params.path);
+                        } else {
+                            doc = await col.load(params.uid, params.path);
+                        }
+
+                        // Sign in.
+                        return stream.success({data: {
+                            message: "Successfully loaded the document.",
+                            document: doc,
+                        }});
+                    }
+                },
+
+                // Delete document.
+                {
+                    method: "DELETE",
+                    endpoint: "/volt/db/document",
+                    content_type: "application/json",
+                    rate_limit: "global",
+                    params: {
+                        collection: "string",
+                        path: ["string", "object"],
+                        uid: {type: ["string", "null"], default: null},
+                    },
+                    callback: async (stream, params) => {
+
+                        // Check ip whitelist.
+                        if (!this.preview_ip_whitelist.includes(stream.ip)) {
+                            return stream.error({status: Status.forbidden});
+                        }
+
+                        // Check collection.
+                        let col;
+                        if ((col = this.collections[params.collection]) == null) {
+                            return stream.error({data: {error: `Invalid collection "${params.collection}".`}})
+                        }
+
+                        // Load doc.
+                        let doc;
+                        if (params.uid == null) {
+                            doc = await col.delete(params.path);
+                        } else {
+                            doc = await col.delete(params.uid, params.path);
+                        }
+
+                        // Sign in.
+                        return stream.success({data: {
+                            message: "Successfully deleted the document.",
+                        }});
+                    }
+                },
+
+                // Update document.
+                {
+                    method: "PATCH",
+                    endpoint: "/volt/db/document",
+                    content_type: "application/json",
+                    rate_limit: "global",
+                    params: {
+                        collection: "string",
+                        path: ["string", "object"],
+                        uid: {type: ["string", "null"], default: null},
+                        content: "object",
+                    },
+                    callback: async (stream, params) => {
+
+                        // Check ip whitelist.
+                        if (!this.preview_ip_whitelist.includes(stream.ip)) {
+                            return stream.error({status: Status.forbidden});
+                        }
+
+                        // Check collection.
+                        let col;
+                        if ((col = this.collections[params.collection]) == null) {
+                            return stream.error({data: {error: `Invalid collection "${params.collection}".`}})
+                        }
+
+                        // Load doc.
+                        let doc;
+                        if (params.uid == null) {
+                            doc = await col.save(params.path, params.content);
+                        } else {
+                            doc = await col.save(params.uid, params.path, params.content);
+                        }
+
+                        // Sign in.
+                        return stream.success({data: {
+                            message: "Successfully updated the document.",
+                        }});
+                    }
+                },
+            )
+        }
+        */
+    }
+
+    // Connect.
+    async connect(): Promise<void> {
+        try {
+            await this.client?.connect();
+            if (this.client) {
+                this.db = this.client.db();
+            }
+        } catch (error) {
+            console.error(error);
+            throw new Error('Error connecting to the database');
+        }
+    }
+
+    // Initialize.
+    async initialize(): Promise<void> {
+        // Set default config.
+        if (this.config.systemLog === undefined) { this.config.systemLog = {}; }
+
+        this.config.systemLog.path = this.source.join("mongod.log").str()
+
+        if (this.config.systemLog.destination === undefined) {
+            this.config.systemLog.destination = "file";
+        }
+        if (this.config.systemLog.logAppend === undefined) {
+            this.config.systemLog.logAppend = true;
+        }
+        if (this.config.systemLog.logRotate === undefined) {
+            this.config.systemLog.logRotate = "reopen";
+        }
+        if (this.config.systemLog.verbosity === undefined) {
+            this.config.systemLog.verbosity = this.server.production ? 0 : 1;
+        }
+
+        if (this.config.storage === undefined) { this.config.storage = {}; }
+
+        const db_path = this.source.join("db");
+        this.config.storage.dbPath = db_path.str()
+        if (!db_path.exists()) {
+            db_path.mkdir_sync();
+        }
+
+        if (this.config.processManagement === undefined) { this.config.processManagement = {}; }
+        this.config.processManagement.pidFilePath = this.source.join("mongod.pid").str()
+
+        if (this.config.net === undefined) { this.config.net = {}; }
+        if (this.config.net.port === undefined) { this.config.net.port = 27017; }
+        if (this.config.net.bindIp === undefined) { this.config.net.bindIp = "127.0.0.1"; }
+
+        // Mode 2: Start database.
+        if (this.server.is_primary && this.uri == null) {
+            // Create the database.
+            if (!this.source.exists()) {
+                this.source.mkdir_sync();
+            }
+
+            // Set the uri.
+            if (this.uri == null) {
+                this.uri = `mongodb://${this.config.net.bindIp}:${this.config.net.port}/main`
+            }
+
+            // Save the config.
+            const config_path = this.source.join("mongod.json");
+            config_path.save_sync(JSON.stringify(this.config));
+
+            // Start the database.
+            this.proc = spawn(
+                "mongod",
+                ["--config", config_path.str(), ...this.start_args],
+                {
+                    stdio: "pipe",
+                    detached: true,
+                    env: {...process.env},
+                },
+            )
+            this.proc.stdout?.on('data', (data) => {
+                console.log(data.toString());
+            })
+            this.proc.stderr?.on('data', (data) => {
+                console.error(data.toString());
+            })
+            this.proc.on("error", (code, signal) => {
+                console.error(`MongoDB crashed with error signal ${signal}.`);
+                process.exit(code);
+            })
+        }
+
+        // Assign URI.
+        else if (!this.server.is_primary && this.uri == null) {
+            this.uri = `mongodb://${this.config.net.bindIp}:${this.config.net.port}/main`
+        }
+
+        // Initialize client.
+        if (this.uri) {
+            this.client = new MongoClient(this.uri, this.client_opts || {});
+        }
+
+        // Connect.
+        await this.connect();
+
+        // Create collections.
+        this._collections.forEach((info) => {
+            if (this[info.name as keyof this] !== undefined) {
+                throw Error(`Unable to initialize database collection "${info.name}", this attribute name is already used.`);
+            }
+            if (Array.isArray(info.indexes)) {
+                for (const index of info.indexes) {
+                    if (index != null && typeof index === "object") {
+                        (index as any).forced = true;
+                    }
+                }
+            }
+            this[info.name] = this.create_collection(info);
+        })
+        this._uid_collections.forEach((info) => {
+            if (this[info.name as keyof this] !== undefined) {
+                throw Error(`Unable to initialize database collection "${info.name}", this attribute name is already used.`);
+            }
+            if (Array.isArray(info.indexes)) {
+                for (const index of info.indexes) {
+                    if (index != null && typeof index === "object") {
+                        (index as any).forced = true;
+                    }
+                }
+            }
+            this[info.name] = this.create_uid_collection(info);
+        })
+    }
+
+    // Close.
+    async close(): Promise<void> {
+        logger.log(0, log_source, "Stopping the database.");
+        await this.client?.close();
+    }
+
+    /*  @docs:
+     *  @title: Create Collection
+     *  @description: Create a database collection.
+     */
+    create_collection(info: {
+        name: string,
+        indexes?: Array<{
+            keys: string[] | string | Record<string, any>,
+            options?: Record<string, any>,
+            commit_quorum?: any
+        }>,
+        ttl?: number | null
+    } | string): Collection {
+        // Set name by single string argument.
+        let name: string;
+        let indexes: Array<any> = [];
+        let ttl: number | null = null;
+        
+        if (typeof info === "string") {
+            name = info;
+        } else {
+            name = info.name;
+            indexes = info.indexes || [];
+            ttl = info.ttl || null;
+        }
+
+        // Check collection.
+        if (name in this.collections) {
+            throw Error(`Collection "${name}" is already initialized.`)
+        }
+        const col = new Collection(
+            name,
+            this.db.collection(name),
+            ttl,
+            indexes,
+        );
+        this.collections[name] = col;
+        return col;
+    }
+
+    /*  @docs:
+     *  @title: Create UID Based Collection
+     *  @description: Create a UID based database collection.
+     */
+    create_uid_collection(info: {
+        name: string,
+        indexes?: Array<{
+            keys: string[] | string | Record<string, any>,
+            options?: Record<string, any>,
+            commit_quorum?: any
+        }>,
+        ttl?: number | null
+    } | string): UIDCollection {
+        // Set name by single string argument.
+        let name: string;
+        let indexes: Array<any> = [];
+        let ttl: number | null = null;
+        
+        if (typeof info === "string") {
+            name = info;
+        } else {
+            name = info.name;
+            indexes = info.indexes || [];
+            ttl = info.ttl || null;
+        }
+
+        // Check collection.
+        if (name in this.collections) {
+            throw Error(`Collection "${name}" is already initialized.`)
+        }
+        const col = new UIDCollection(
+            name,
+            this.db.collection(name),
+            indexes,
+            ttl,
+        );
+        this.collections[name] = col;
+        return col;
+    }
+
+    /*  @docs:
+     *  @title: Get Collections
+     *  @description: Get the names of the initializated database collections.
+     */
+    async get_collections(): Promise<string[]> {
+        const created = Object.keys(this.collections);
+        const database = (await this.db.listCollections().toArray()).map((item: any) => item.name);
+        return created.concat(database)
+            .filter((value, index, self) => self.indexOf(value) === index)
+            .sort((a, b) => {
+                const result = a.toLowerCase().localeCompare(b.toLowerCase());
+                if (a.startsWith('_') && b.startsWith('_')) { return result; }
+                if (a.startsWith('_')) { return 1; }
+                if (b.startsWith('_')) { return -1; }
+                return result;
+            });
+    }
+}
+
+export { Collection, UIDCollection, Database };