refactoring formulas

Author: RafaelGB

docs/docs/features/Formulas.md

@@ -31,7 +31,7 @@ The root object `db` has the following functions:
 
 - `js` : execute a javascript function that you previously defined in the `js` folder of your table in the database or plugin global settings. (I.E.: `db.js.myFunction( arg1, arg2)`)
 - `dataview`: expose the dataview API. (see [Dataview API](https://github.com/blacksmithgu/obsidian-dataview/blob/master/src/api/plugin-api.ts))
-- `rollup`: expose the rollup functions of the dbfolder plugin.  (see [Rollup documentation](/features/Relations/#rollups))
+- `rollup`: expose the rollup functions of the dbfolder plugin.  (see [Rollup documentation](/obsidian-db-folder/features/Relations/#rollups))
 
 #### Javascript file structure
 To add a javascript file to the `js` folder, it must be a `.js` file and have the following structure:

src/DatabaseView.tsx

@@ -1,4 +1,3 @@
-import { obtainFormulasFromFolder } from "automations/AutomationsHelper";
 import { DatabaseColumn } from "cdm/DatabaseModel";
 import { UpdaterData, ViewEvents } from "cdm/EmitterModel";
 import {
@@ -38,6 +37,7 @@ import {
   Menu,
 } from "obsidian";
 import { createRoot, Root } from "react-dom/client";
+import { DbAutomationService } from "services/AutomationService";
 import DatabaseInfo from "services/DatabaseInfo";
 import { LOGGER } from "services/Logger";
 import { SettingsModal } from "Settings";
@@ -168,7 +168,7 @@ export class DatabaseView extends TextFileView implements HoverParent {
       );
       this.initial = obtainInitialType(this.columns);
 
-      this.formulas = await obtainFormulasFromFolder(
+      this.formulas = await DbAutomationService.buildFns(
         this.diskConfig.yaml.config
       );
       // Define table properties

src/automations/AutomationsHelper.ts

@@ -2,6 +2,7 @@ import { DEFAULT_SETTINGS, FooterType } from "helpers/Constants";
 import { Literal } from "obsidian-dataview";
 import { DataviewService } from "services/DataviewService";
 import { DateTime } from "luxon";
+import { DbAutomationService } from "services/AutomationService";
 
 export default class Footer {
     constructor(public readonly colValues: Literal[]) { }
@@ -119,10 +120,7 @@ export default class Footer {
      * @returns 
      */
     public sum(): string {
-        const total = this.colValues
-            .map((value) => Number(value))
-            .filter((value) => !isNaN(value))
-            .reduce((acc: number, value: number) => acc + value, 0);
+        const total = DbAutomationService.coreFns.numbers.sum(this.colValues);
         return `Total: ${total}`;
     }
 
@@ -131,10 +129,7 @@ export default class Footer {
      * @returns 
      */
     public min(): string {
-        const min = this.colValues
-            .map((value) => Number(value))
-            .filter((value) => !isNaN(value))
-            .reduce((acc: number, value: number) => Math.min(acc, value), Number.MAX_SAFE_INTEGER);
+        const min = DbAutomationService.coreFns.numbers.min(this.colValues);
         return `Min: ${min}`;
     }
 
@@ -143,10 +138,7 @@ export default class Footer {
      * @returns 
      */
     public max(): string {
-        const max = this.colValues
-            .map((value) => Number(value))
-            .filter((value) => !isNaN(value))
-            .reduce((acc: number, value: number) => Math.max(acc, value), Number.MIN_SAFE_INTEGER);
+        const max = DbAutomationService.coreFns.numbers.max(this.colValues);
         return `Max: ${max}`;
     }
 

src/automations/Footer.ts

@@ -1,9 +1,6 @@
 import { FormulaFunctions } from "automations/formula_functions/FormulaFunctions";
-import { IGenerateObject } from "automations/IGenerateObject";
+import { IGenerateObject } from "automations/core/IGenerateObject";
 import { LocalSettings } from "cdm/SettingsModel";
-import { Link } from "obsidian-dataview";
-import { DataviewService } from "services/DataviewService";
-import Rollup from "automations/Rollup";
 export class FormulaGenerator implements IGenerateObject {
     public js_functions: FormulaFunctions;
 
@@ -16,13 +13,8 @@ export class FormulaGenerator implements IGenerateObject {
     }
 
     async generate_object(): Promise<Record<string, unknown>> {
-        const final_object: Record<string, unknown> = {};
-        Object.assign(final_object, {
+        return {
             js: await this.generate_js_functions(),
-            dataview: DataviewService.getDataviewAPI(),
-            rollup: (relation: Link[]) => new Rollup(relation)
-        }
-        );
-        return final_object;
+        };
     }
 }

src/automations/FormulaGenerator.ts

@@ -0,0 +1,27 @@
+import { IGenerateObject } from "automations/core/IGenerateObject";
+import { DatabaseFnType } from "cdm/ModulesFnModel";
+import { DbModule } from "./core/DbModule";
+import { NumbersFn } from "./core/modules/NumbersFn";
+export class ModulesGenerator implements IGenerateObject {
+    private modules_array: Array<DbModule> = [];
+
+    constructor() {
+        this.modules_array.push(new NumbersFn());
+    }
+
+    async init(): Promise<void> {
+        for (const mod of this.modules_array) {
+            await mod.init();
+        }
+    }
+
+    async generate_object(): Promise<DatabaseFnType> {
+        const internal_functions_object: { [key: string]: unknown } = {};
+        for (const mod of this.modules_array) {
+            internal_functions_object[mod.getName()] =
+                await mod.generate_object();
+        }
+
+        return internal_functions_object as DatabaseFnType;
+    }
+}

src/automations/ModulesGenerator.ts

@@ -1,13 +1,19 @@
 import { LocalSettings } from "cdm/SettingsModel";
 import { DEFAULT_SETTINGS, InputType, ROLLUP_ACTIONS } from "helpers/Constants";
 import { Link, Literal, SMarkdownPage } from "obsidian-dataview";
+import { DbAutomationService } from "services/AutomationService";
 import { DataviewService } from "services/DataviewService";
 import { LOGGER } from "services/Logger";
 import { ParseService } from "services/ParseService";
 
 class Rollup {
     private pages: Record<string, Literal>[];
 
+    /**
+     * Obtains the metadata associated to a list of links
+     * @param relation 
+     * @returns 
+     */
     static generatePages(relation: Link[]): Record<string, Literal>[] {
         return relation.map((link) =>
             DataviewService.getDataviewAPI().page(link.path)
@@ -27,27 +33,27 @@ class Rollup {
         let result = "";
         switch (action) {
             case ROLLUP_ACTIONS.SUM:
-                result = this.sum(key);
+                result = this.sum(key).toString();
                 break;
 
             case ROLLUP_ACTIONS.COUNT_ALL:
-                result = this.countAll(key);
+                result = this.countAll(key).toString();
                 break;
 
             case ROLLUP_ACTIONS.COUNT_UNIQUE:
-                result = this.countUnique(key);
+                result = this.countUnique(key).toString();
                 break;
 
             case ROLLUP_ACTIONS.ORIGINAL_VALUE:
                 result = this.originalValue(key);
                 break;
 
             case ROLLUP_ACTIONS.TRUTHY_COUNT:
-                result = this.truthyCount(key);
+                result = this.truthyCount(key).toString();
                 break;
 
             case ROLLUP_ACTIONS.FALSY_COUNT:
-                result = this.falsyCount(key);
+                result = this.falsyCount(key).toString();
                 break;
 
             case ROLLUP_ACTIONS.PERCENT_EMPTY:
@@ -59,15 +65,15 @@ class Rollup {
                 break;
 
             case ROLLUP_ACTIONS.ALL_TASKS:
-                result = this.allTasks();
+                result = this.allTasks().toString();
                 break;
 
             case ROLLUP_ACTIONS.TASK_COMPLETED:
-                result = this.taskCompleted();
+                result = this.taskCompleted().toString();
                 break;
 
             case ROLLUP_ACTIONS.TASK_TODO:
-                result = this.taskTodo();
+                result = this.taskTodo().toString();
                 break;
 
             default:
@@ -85,44 +91,35 @@ class Rollup {
      * Iters over the pages and sums the values of the key
      * @returns 
      */
-    public sum(key: string): string {
+    public sum(key: string): number {
         // Check if key is not truthy, return empty string
         if (!key) {
-            return "";
+            return NaN;
         }
-        let sum = 0;
-        this.pages.forEach((page) => {
-            if (page[key]) {
-                sum += Number(page[key]);
-            }
-        });
-        return sum.toString();
+        const rawValues = this.rawValues(key);
+        return DbAutomationService.coreFns.numbers.sum(rawValues)
     }
 
     /**
      * Obtains the number of pages of the relation with the key informed
      * @returns 
      */
-    public countAll(key: string): string {
+    public countAll(key: string): number {
         // Check if key is not truthy, return empty string
         if (!key) {
-            return "";
+            return 0;
         }
-        return this.pages.filter((page) => page[key] !== undefined).length.toString();
+        return this.rawValues(key).length;
     }
 
-    public countUnique(key: string): string {
+    public countUnique(key: string): number {
         // Check if key is not truthy, return empty string
         if (!key) {
-            return "";
+            return 0;
         }
         const uniqueValues = new Set();
-        this.pages
-            .filter((page) => page[key] !== undefined)
-            .forEach((page) => {
-                uniqueValues.add(page[key]);
-            });
-        return uniqueValues.size.toString();
+        this.rawValues(key).forEach((value) => uniqueValues.add(value));
+        return uniqueValues.size;
     }
 
     /**
@@ -135,25 +132,28 @@ class Rollup {
             return "";
         }
         const settings = config || DEFAULT_SETTINGS.local_settings;
-        return this.pages
-            .filter((page) => page[key])
-            .map((page) => ParseService.parseLiteral(page[key], InputType.MARKDOWN, settings)).join(", ");
+        return this.rawValues(key)
+            .map((value) => ParseService.parseLiteral(
+                value,
+                InputType.MARKDOWN,
+                settings))
+            .join(", ");
     }
 
-    public falsyCount(key: string): string {
+    public falsyCount(key: string): number {
         // Check if key is not truthy, return empty string
         if (!key) {
-            return "";
+            return 0;
         }
-        return this.pages.filter((page) => page[key] !== undefined && !page[key]).length.toString();
+        return this.pages.filter((page) => page[key] !== undefined && !page[key]).length;
     }
 
-    public truthyCount(key: string): string {
+    public truthyCount(key: string): number {
         // Check if key is not truthy, return empty string
         if (!key) {
-            return "";
+            return 0;
         }
-        return this.pages.filter((page) => page[key] !== undefined && page[key]).length.toString();
+        return this.pages.filter((page) => page[key] !== undefined && page[key]).length;
     }
 
     public percentEmpty(key: string): string {
@@ -176,25 +176,29 @@ class Rollup {
         return `${((filled / total) * 100).toFixed(2)}%`;
     }
 
-    public allTasks(): string {
+    public allTasks(): number {
         return this.pages.map((page: SMarkdownPage) => {
             const file_tasks = page.file.tasks;
             return file_tasks.length
-        }).reduce((a, b) => a + b, 0).toString();
+        }).reduce((a, b) => a + b, 0);
     }
 
-    public taskCompleted(): string {
+    public taskCompleted(): number {
         return this.pages.map((page: SMarkdownPage) => {
             const file_tasks = page.file.tasks;
             return file_tasks.filter(task => task.checked).length
-        }).reduce((a, b) => a + b, 0).toString();
+        }).reduce((a, b) => a + b, 0);
     }
 
-    public taskTodo(): string {
+    public taskTodo(): number {
         return this.pages.map((page: SMarkdownPage) => {
             const file_tasks = page.file.tasks;
             return file_tasks.filter(task => !task.checked).length
-        }).reduce((a, b) => a + b, 0).toString();
+        }).reduce((a, b) => a + b, 0);
+    }
+
+    private rawValues(key: string): Literal[] {
+        return this.pages.filter((page) => page[key] !== undefined).map((page) => page[key]);
     }
 }
 

src/automations/Rollup.ts

@@ -0,0 +1,33 @@
+
+import { IGenerateObject } from "./IGenerateObject";
+
+export abstract class DbModule implements IGenerateObject {
+    public abstract name: string;
+    protected static_functions: Map<string, unknown> = new Map();
+    protected dynamic_functions: Map<string, unknown> = new Map();
+    protected static_object: { [x: string]: unknown };
+
+    constructor() { }
+
+    getName(): string {
+        return this.name;
+    }
+
+    abstract create_static_functions(): Promise<void>;
+    abstract create_dynamic_functions(): Promise<void>;
+
+    async init(): Promise<void> {
+        await this.create_static_functions();
+        this.static_object = Object.fromEntries(this.static_functions);
+    }
+
+    async generate_object(): Promise<Record<string, unknown>> {
+        await this.create_dynamic_functions();
+
+        return {
+            ...this.static_object,
+            ...this.static_object,
+            ...Object.fromEntries(this.dynamic_functions),
+        };
+    }
+}