@vandenberghinc/volt 1.1.26 → 1.1.28

package/backend/dist/esm/backend/src/database/database.d.ts

@@ -0,0 +1,66 @@
+/**
+ * @author Daan van den Bergh
+ * @copyright © 2022 - 2025 Daan van den Bergh.
+ */
+import { Db, MongoClient } from 'mongodb';
+import * as mongodb from "mongodb";
+import { Collection } from "./collection.js";
+import type { Server } from "../server.js";
+export declare namespace Database {
+    /** The database constructor options. */
+    interface Opts {
+        /** The database URI. */
+        uri: string;
+        /** The additional cient options. */
+        client?: mongodb.MongoClientOptions;
+    }
+}
+/**
+ * The MongoDB database class, accessable under `Server.db`.
+ * @docs
+ * @nav Backend/Database
+*/
+export declare class Database {
+    static constructor_scheme: {
+        uri: {
+            type: string;
+            default: null;
+        };
+        client: {
+            type: string;
+            default: {};
+        };
+        _server: {
+            type: string[];
+        };
+    };
+    uri: string;
+    client_opts?: mongodb.MongoClientOptions;
+    server: Server;
+    client?: MongoClient;
+    _db?: Db;
+    collections: Map<string, Collection<any>>;
+    _listed_cols: any;
+    constructor({ uri, client, _server, }: Database.Opts & {
+        _server: Server;
+    });
+    db(): Promise<Db>;
+    connected: boolean;
+    private connect_promise?;
+    connect(): Promise<void>;
+    /** Initialize. */
+    initialize(): Promise<void>;
+    /** Ensure connection. */
+    ensure_connection(): Promise<void>;
+    close(): Promise<void>;
+    /**
+     * {Create Collection}
+     * Initialize database collection.
+     * @note When called multiple times with the same name, it will return the same cached collection.
+     * @param info.unique If true, an error will be thrown if the collection already exists.
+     *                    Defauls to `true`.
+     */
+    collection<Data extends mongodb.Document = mongodb.Document>(info: string | (Omit<Collection.Opts<Data>, "db"> & {
+        unique?: boolean;
+    })): Collection<Data>;
+}

package/backend/dist/esm/{database → backend/src/database}/database.js

@@ -2,70 +2,28 @@
  * @author Daan van den Bergh
  * @copyright © 2022 - 2025 Daan van den Bergh.
  */
+// ---------------------------------------------------------
+// Libraries.
+// External imports.
 import { MongoClient, ServerApiVersion } from 'mongodb';
 // Imports.
-import { logger } from "../logger.js";
 import { Collection } from "./collection.js";
-/** Debug */
-const { log } = logger;
-// ---------------------------------------------------------
-// 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
+/**
+ * The MongoDB database class, accessable under `Server.db`.
+ * @docs
+ * @nav Backend/Database
 */
 export 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) => 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: { type: ["object", "undefined"] },
+        // source: {type: "string", default: null},
+        // config: {type: "object", default: {}},
+        // start_args: {type: "array", default: []},
+        // preview: {type: "boolean", default: true},
+        // preview_ip_whitelist: {type: "array", default: []},
+        // daemon: {type: ["object", "boolean"], default: {}},
     };
     // Attributes.
     uri;
@@ -74,7 +32,6 @@ export class Database {
     client;
     _db;
     collections = new Map();
-    _connect_promise;
     // System.
     _listed_cols;
     constructor({ uri, client, _server, }) {
@@ -90,9 +47,9 @@ export class Database {
         // daemon?: Record<string, any> | boolean,
         // Checks.
         // if (!_server || (_server.is_primary && uri == null)) {
-        //     ({uri, config, start_args, config, client} = vlib.Scheme.verify({
+        //     ({uri, config, start_args, config, client} = vlib.Schema.verify({
         //         object: arguments[0],
-        //         check_unknown: true, 
+        //         check_unknown: true,
         //         throw_err: true,
         //         scheme: Database.constructor_scheme
         //     }));
@@ -107,7 +64,7 @@ export class Database {
         // if (this.server?.daemon && daemon !== false) {
         //     const log_source = this.server.source.join(".logs");
         //     if (!log_source.exists()) {
-        //         log_source.mkdir_sync();
+        //         log_source.mkdir_sync({ recursive: true });
         //     }
         //     if (!this.server) {
         //         throw new Error("Parameter 'Database._server' must be defined for this behaviour.");
@@ -134,70 +91,89 @@ export class Database {
     }
     // Connect.
     connected = false;
+    connect_promise;
     async connect() {
-        try {
-            if (this.client == null) {
-                throw new Error('MongoDB client is not initialized.');
-            }
-            await this.client.connect();
-            this._db = this.client.db();
-            this.connected = true;
-            log(1, "Connected to the database.");
-        }
-        catch (error) {
-            console.error(error);
-            throw new Error('Error connecting to the database');
+        if (this.connect_promise) {
+            return await this.connect_promise;
         }
+        return this.connect_promise = new Promise(async (resolve, reject) => {
+            try {
+                if (this.client == null) {
+                    throw new Error('MongoDB client is not initialized.');
+                }
+                await this.client.connect();
+                this._db = this.client.db();
+                this.connected = true;
+                this.server.log(1, "Connected to the database.");
+            }
+            catch (error) {
+                this.server.log.error(error);
+                throw new Error('Error connecting to the database');
+            }
+        });
     }
     /** Initialize. */
     async initialize() {
         // Initialize client (same as before)
         const opts = this.client_opts ?? {};
-        opts.serverApi ??= {};
-        opts.serverApi.version ??= ServerApiVersion.v1;
-        opts.serverApi.strict ??= true;
-        opts.serverApi.deprecationErrors ??= true;
+        opts.serverApi ??= {
+            version: ServerApiVersion.v1,
+            strict: true,
+            deprecationErrors: true,
+        };
+        if (typeof opts.serverApi === "object") {
+            opts.serverApi.version ??= ServerApiVersion.v1;
+            opts.serverApi.strict ??= true;
+            opts.serverApi.deprecationErrors ??= true;
+        }
+        // for speeding up connect().
+        opts.serverSelectionTimeoutMS = 1000;
+        opts.connectTimeoutMS = 1000;
         this.client = new MongoClient(this.uri, opts);
         // In development we start the connection in the background so the server
         // can finish booting immediately. In production we still block.
         if (this.server.production === false) {
-            this._connect_promise = this.connect(); // don’t await
+            this.connect(); // don’t await
         }
         else {
             await this.connect(); // block in prod
+            // In production we also wanna initialize all collections right away.
+            for (const col of this.collections.values()) {
+                await col.init();
+            }
         }
     }
     /** Ensure connection. */
     async ensure_connection() {
         if (this.connected)
-            return; // already ready
-        if (this._connect_promise)
-            return this._connect_promise; // wait for bg task
-        this._connect_promise = this.connect(); // cold-start (unlikely)
-        return this._connect_promise;
+            return;
+        if (this.connect_promise)
+            return this.connect_promise;
+        return this.connect();
     }
     // Close.
     async close() {
-        log(0, "Stopping the database.");
+        this.server.log(0, "Stopping the database.");
         await this.client?.close();
+        this.connect_promise = undefined;
     }
     /**
      * {Create Collection}
      * Initialize database collection.
      * @note When called multiple times with the same name, it will return the same cached collection.
      * @param info.unique If true, an error will be thrown if the collection already exists.
-     *                    By default it is false.
+     *                    Defauls to `true`.
      */
-    async collection(info) {
+    collection(info) {
         // Set name by single string argument.
         let name;
-        let unique = false;
+        let unique = true;
         let args;
         if (typeof info === "string") {
             name = info;
         }
         else {
-            unique = info.unique || false;
+            unique = info.unique ?? true;
             name = info.name;
             args = info;
         }
@@ -216,22 +192,5 @@ export class Database {
         });
         this.collections.set(name, col);
         return col;
-        // Logs.
-        // debug(2, `Initializing collection "${name}".`);
-        // // Check if the collection exists
-        // if (this._listed_cols == null) {
-        //     this._listed_cols = await this.db.listCollections().toArray();
-        // }
-        // if (!this._listed_cols.find(x => x.name === name)) {
-        //     log(0, `Creating collection "${name}".`);
-        //     await this.db.createCollection(name);
-        // }
-        // // Create collection.
-        // const col: Collection = Collection.create({
-        //     ...info,
-        //     collection: this.db.collection(name),
-        // });
-        // this.collections.set(name, col);
-        // return col;
     }
 }

package/backend/dist/esm/backend/src/database/document.d.ts

@@ -0,0 +1 @@
+export {};