first steps of formulas are working

Author: RafaelGB

src/DatabaseView.tsx

@@ -28,7 +28,6 @@ import {
   TFile,
   Menu,
 } from "obsidian";
-import { Literal } from "obsidian-dataview";
 import { createRoot, Root } from "react-dom/client";
 import DatabaseInfo from "services/DatabaseInfo";
 import { LOGGER } from "services/Logger";
@@ -46,7 +45,7 @@ export class DatabaseView extends TextFileView implements HoverParent {
   columns: Array<TableColumn>;
   shadowColumns: Array<TableColumn>;
   initial: InitialType;
-  formulas: Record<string, (row: RowDataType) => Literal>;
+  formulas: Record<string, unknown>;
 
   constructor(leaf: WorkspaceLeaf, plugin: DBFolderPlugin) {
     super(leaf);

src/automations/AutomationsHelper.ts

@@ -3,7 +3,6 @@ import { FormulaGenerator } from "automations/FormulaGenerator";
 
 export async function obtainFormulasFromFolder(config: LocalSettings) {
     const generator = new FormulaGenerator(config);
-    generator.init();
-    return await generator.generate_object(config);
+    return await generator.generate_object();
 }
 

src/automations/FormulaGenerator.ts

@@ -1,56 +1,26 @@
 import { FormulaFunctions } from "automations/formula_functions/FormulaFunctions";
 import { IGenerateObject } from "automations/IGenerateObject";
-import * as obsidian_module from "obsidian";
 import { LocalSettings } from "cdm/SettingsModel";
 import { RowDataType } from "cdm/FolderModel";
 import { Literal } from "obsidian-dataview";
-
-export enum FunctionsMode {
-    INTERNAL,
-    USER_INTERNAL,
-}
-
 export class FormulaGenerator implements IGenerateObject {
     public formula_functions: FormulaFunctions;
 
     constructor(private config: LocalSettings) {
         this.formula_functions = new FormulaFunctions(config);
     }
 
-    async init(): Promise<void> {
-    }
+    private async generate_formula_functions(): Promise<Record<string, unknown>> {
 
-    additional_functions(): Record<string, unknown> {
-        return {
-            obsidian: obsidian_module,
-        };
+        return await this.formula_functions.generate_object(this.config);
     }
 
-    async generate_object(
-        config: LocalSettings,
-        functions_mode: FunctionsMode = FunctionsMode.USER_INTERNAL
-    ): Promise<Record<string, (row: RowDataType) => Literal>> {
+    async generate_object(): Promise<Record<string, unknown>> {
         const final_object: Record<string, any> = {};
-        const additional_functions_object = this.additional_functions();
-        const internal_functions_object =
-            await this.formula_functions.generate_object(config);
-        let user_functions_object = {};
-
-        Object.assign(final_object, additional_functions_object);
-        switch (functions_mode) {
-            case FunctionsMode.INTERNAL:
-                Object.assign(final_object, internal_functions_object);
-                break;
-            case FunctionsMode.USER_INTERNAL:
-                user_functions_object =
-                    await this.formula_functions.generate_object(config);
-                Object.assign(final_object, {
-                    ...internal_functions_object,
-                    user: user_functions_object,
-                });
-                break;
-        }
-
+        Object.assign(final_object, {
+            js: await this.generate_formula_functions(),
+        });
+        console.log("sasdinal_object");
         return final_object;
     }
 }

src/automations/formula_functions/FormulaFunctions.ts

@@ -3,10 +3,10 @@ import { UserScriptFunctions } from "automations/formula_functions/ScriptFunctio
 import { LocalSettings } from "cdm/SettingsModel";
 
 export class FormulaFunctions implements IGenerateObject {
-    private user_script_functions: UserScriptFunctions;
+    private js_script_functions: UserScriptFunctions;
 
     constructor(private config: LocalSettings) {
-        this.user_script_functions = new UserScriptFunctions(config);
+        this.js_script_functions = new UserScriptFunctions(config);
     }
 
     async generate_object(
@@ -16,7 +16,7 @@ export class FormulaFunctions implements IGenerateObject {
 
         if (config.formula_folder_path) {
             user_script_functions =
-                await this.user_script_functions.generate_object();
+                await this.js_script_functions.generate_object();
         }
 
         return {

src/automations/formula_functions/ScriptFunctions.ts

@@ -1,4 +1,4 @@
-import { App, Notice, TFile } from "obsidian";
+import { Notice, TFile } from "obsidian";
 import { IGenerateObject } from "automations/IGenerateObject";
 import { get_tfiles_from_folder } from "helpers/FileManagement";
 import { LocalSettings } from "cdm/SettingsModel";

src/stateManagement/automations/handlers/RunFormulaHandlerAction.ts

@@ -8,17 +8,27 @@ export default class RunFormulaHandlerAction extends AbstractTableAction<Automat
     handle(tableActionResponse: TableActionResponse<AutomationState>): TableActionResponse<AutomationState> {
         const { implementation, get } = tableActionResponse;
         implementation.info.runFormula = (input: string, row: RowDataType, ddbbConfig: LocalSettings) => {
-            return this.evalInput(input, row, ddbbConfig, get().formula);
+            return this.proxyFunction(input, row, ddbbConfig, get().formula);
         };
 
         tableActionResponse.implementation = implementation;
         return this.goNext(tableActionResponse);
     }
-    evalInput(input: string, row: RowDataType, ddbbConfig: LocalSettings, formulas: {
+    evalInput(input: string, row: RowDataType, config: LocalSettings, db: {
         [key: string]: unknown;
     }): Literal {
         const dynamicJS = 'return `' + input + '`';
-        const func = new Function('row', 'ddbbConfig', 'formulas', dynamicJS);
-        return func(row, ddbbConfig, formulas);
+        const func = new Function('row', 'ddbbConfig', 'db', dynamicJS);
+        return func(row, config, db);
     }
+    proxyFunction(input: string, row: RowDataType, config: LocalSettings, db: {
+        [key: string]: unknown;
+    }): Literal {
+        try {
+            return this.evalInput(input, row, config, db);
+        } catch (e) {
+            return `Error: ${e}`;
+        }
+    }
+
 }