db-crud-wrapper 1.0.1

package/lib/config.js

@@ -0,0 +1,287 @@
+"use strict";
+
+import * as f from './f.js';
+import * as dbOpe from './db-operations.js';
+
+export const config = {
+    servers: {
+    },
+    log: {
+        level: 0,
+        callback: undefined,
+        maxAsyncInstance: 50
+    },
+    session: {
+        tablePath: 'sessions'        
+    }
+}
+
+export class Server {
+    #_serverName = undefined;
+
+    // server can be the name (string) or object or an instance of Server class
+    constructor(server) {
+        if (typeof server === 'string') {
+            this.#_serverName = server;
+            if (!config.servers[server]) config.servers[server] = {};
+        }
+        else if (typeof server === 'object') {
+            if (server.constructor === Server) { // if server is an instance of Server class, we can use its toObject method to get the server object
+                this.#_serverName = server.name;
+                config.servers[this.#_serverName] = { name, ...structuredClone(server.toObject()) };
+            }
+            else { 
+                if (!server.name) throw new Error('server must have a name.');
+                this.#_serverName = server.name;
+                config.servers[server.name] = { name, ...structuredClone(server) };
+            }
+        }
+        else throw new Error('server must be a string or a server object.');
+    }
+
+    get name() {
+        return this.#_serverName;
+    }
+
+    instance(instance) {
+        if (typeof instance !== 'string') throw new Error('instance must be a string.');
+        config.servers[this.#_serverName].instance = instance;
+        return this;
+    }
+
+    user(user) {
+        if (typeof user !== 'string') throw new Error('user must be a string.');
+        config.servers[this.#_serverName].user = user;
+        return this;
+    }
+
+    password(password) {
+        if (typeof password !== 'string') throw new Error('password must be a string.');
+        config.servers[this.#_serverName].password = password;
+        return this;
+    }
+
+    type(type) {
+        if (typeof type !== 'string' || !Object.values(dbOpe.serverType).includes(type)) throw new Error('invalid server type.');
+        config.servers[this.#_serverName].type = type;
+        return this;
+    }
+
+    realName(realName) {
+        if (typeof realName !== 'string') throw new Error('realName must be a string.');
+        config.servers[this.#_serverName].realName = realName;
+        return this;
+    }
+
+    options(options) {
+        if (typeof options !== 'object') throw new Error('options must be an object.');
+        config.servers[this.#_serverName].options = structuredClone(options);
+        return this;
+    }
+
+    database(database) {
+        return new Database(database, this.#_serverName);
+    }
+
+    toObject() {
+        const _return = structuredClone(config.servers[this.#_serverName]);
+        return _return;
+    }
+}
+
+export class Database {
+    #_dbName = undefined;
+    #_serverName = undefined;
+
+    // datbase can be the name (string) or object or an instance of Database class
+    constructor(database, serverName) {
+        if (typeof serverName !== 'string') throw new Error('server must be a string.');
+        this.#_serverName = serverName;
+        if (typeof database === 'string') {
+            this.#_dbName = database;
+            if (!config.servers[serverName]) config.servers[serverName] = {};
+            // note: I cannot use serverName in setDeep path because it can contain an IP address xx.xx.xx.xx
+            f.setDeep(config.servers[serverName], `databases.${database}`, {});
+        }
+        else if (typeof database === 'object') {
+            if (!database.name) throw new Error('database must have a name.');
+            this.#_dbName = database.name;
+            if (!config.servers[serverName]) config.servers[serverName] = {};
+            // note: I cannot use serverName in setDeep path because it can contain an IP address xx.xx.xx.xx
+            // if database is an instance of Database class, we can use its toObject method to get the database object
+            if (database.constructor === Database)
+                f.setDeep(config.servers[serverName], `databases.${database.name}`, { name, ...structuredClone(database.toObject()) });
+            else
+                f.setDeep(config.servers[serverName], `databases.${database.name}`, { name, ...structuredClone(database) });
+        }
+        else throw new Error('database must be a string or a database object.');
+    }
+
+    get name() {
+        return this.#_dbName;
+    }
+
+    realName(realName) {
+        if (typeof realName !== 'string') throw new Error('realName must be a string.');
+        config.servers[this.#_serverName].databases[this.#_dbName].realName = realName;
+        return this;
+    }
+
+    table(table) {
+        return new Table(table, this.#_dbName, this.#_serverName);
+    }
+
+    toObject() {
+        const _return = structuredClone(config.servers[this.#_serverName].databases[this.#_dbName]);
+        return _return;
+    }
+
+}
+
+export class Table {
+    #_tableName = undefined;
+    #_dbName = undefined;
+    #_serverName = undefined;   
+
+    // table can be a string or a table object or an instance of Table class
+    constructor(table, dbName, serverName) {
+        if (typeof serverName !== 'string') throw new Error('server must be a string.');
+        if (typeof dbName !== 'string') throw new Error('database must be a string.');  
+        this.#_serverName = serverName;
+        this.#_dbName = dbName;
+        if (typeof table === 'string') {
+            this.#_tableName = table;
+            if (!config.servers[serverName]) config.servers[serverName] = {};
+            // note: I cannot use serverName in setDeep path because it can contain an IP address xx.xx.xx.xx
+            f.setDeep(config.servers[serverName], `databases.${dbName}.tables.${table}`, {});
+        }
+        else if (typeof table === 'object') {
+            if (!table.name) throw new Error('table must have a name.');
+            this.#_tableName = table.name;
+            if (!config.servers[serverName]) config.servers[serverName] = {};
+            // note: I cannot use serverName in setDeep path because it can contain an IP address xx.xx.xx.xx
+            // if table is an instance of Table class, we can use its toObject method to get the table object
+            if (table.constructor === Table)
+                f.setDeep(config.servers[serverName], `databases.${dbName}.tables.${table.name}`, { name, ...structuredClone(table.toObject()) });
+            else
+                f.setDeep(config.servers[serverName], `databases.${dbName}.tables.${table.name}`, { name, ...structuredClone(table) });
+        }
+        else throw new Error('table must be a string or a table object.');
+    }
+
+    get name() {
+        return this.#_tableName;
+    }
+
+    realName(realName) {
+        if (typeof realName !== 'string') throw new Error('realName must be a string.');
+        config.servers[this.#_serverName].databases[this.#_dbName].tables[this.#_tableName].realName = realName;
+        return this;
+    }
+
+    idField(idField) {
+        if (typeof idField !== 'string') throw new Error('idField must be a string.');
+        config.servers[this.#_serverName].databases[this.#_dbName].tables[this.#_tableName].idField = idField;
+        return this;
+    }
+
+    autoId(autoId) {
+        if (typeof autoId !== 'boolean') throw new Error('autoId must be a boolean.');
+        config.servers[this.#_serverName].databases[this.#_dbName].tables[this.#_tableName].autoId = autoId;
+        return this;
+    }
+
+    field(field) {
+        return new Field(field, this.#_tableName, this.#_dbName, this.#_serverName);
+    }
+
+    toObject() {
+        const _return = structuredClone(config.servers[this.#_serverName].databases[this.#_dbName].tables[this.#_tableName]);
+        return _return;
+    }
+
+}
+
+export class Field {
+    #_fieldName;
+    #_tableName;
+    #_dbName;
+    #_serverName;
+
+    // field can be a string or a field object 
+    constructor(field, tableName, dbName, serverName) {
+        if (typeof serverName !== 'string') throw new Error('server must be a string.');
+        if (typeof dbName !== 'string') throw new Error('database must be a string.');  
+        if (typeof tableName !== 'string') throw new Error('table must be a string.');
+        this.#_serverName = serverName;
+        this.#_dbName = dbName;
+        this.#_tableName = tableName;
+        if (typeof field === 'string') {
+            this.#_fieldName = field;
+            if (!config.servers[serverName]) config.servers[serverName] = {};
+            // note: I cannot use serverName in setDeep path because it can contain an IP address xx.xx.xx.xx
+            f.setDeep(config.servers[serverName], `databases.${dbName}.tables.${tableName}.fields.${field}`, {});
+        }
+        else if (typeof field === 'object') {
+            if (!field.name) throw new Error('field must have a name.');
+            this.#_fieldName = field.name;
+            if (!config.servers[serverName]) config.servers[serverName] = {};
+            // note: I cannot use serverName in setDeep path because it can contain an IP address xx.xx.xx.xx
+            f.setDeep(config.servers[serverName], `databases.${dbName}.tables.${tableName}.fields.${field}`, { name, ...structuredClone(field) });
+        }
+        else throw new Error('field must be a string or a field object.');
+    }
+
+    get name() {
+        return this.#_fieldName;
+    }
+
+    type(type) {
+        if (typeof type !== 'string') throw new Error('type must be a string.');
+        config.servers[this.#_serverName].databases[this.#_dbName].tables[this.#_tableName].Database[this.#_fieldName].type = type;
+        return this;
+    }
+
+    description(description) {
+        if (typeof description !== 'string') throw new Error('description must be a string.');
+        config.servers[this.#_serverName].databases[this.#_dbName].tables[this.#_tableName].Database[this.#_fieldName].description = description;
+        return this;
+    }
+
+    toObject() {
+        const _return = structuredClone(config.servers[this.#_serverName].databases[this.#_dbName].tables[this.#_tableName].fields[this.#_fieldName]);
+        return _return;
+    }
+
+}
+
+export class Log {
+    constructor() {
+    }
+
+    level(level) {
+        if (typeof level === 'number') {
+            config.log.level = level;
+        } else if (typeof level === 'string' && !isNaN(Number.parseInt(level))) {
+            config.log.level = Number.parseInt(level);
+        }
+        return this;
+    }
+
+    callback(callback) {
+        if (typeof callback === 'function') {
+            config.log.callback = callback;
+        }
+        return this;
+    }
+
+    maxAsyncInstances(maxAsyncInstances) {
+        if (typeof maxAsyncInstances === 'number') {
+            config.log.maxAsyncInstance = maxAsyncInstances;
+        } else if (typeof maxAsyncInstances === 'string' && !isNaN(Number.parseInt(maxAsyncInstances))) {
+            config.log.maxAsyncInstance = Number.parseInt(maxAsyncInstances);
+        }
+        return this;
+    }
+
+}