Merge branch '49-fr-formula-column-type'

Author: RafaelGB

src/DatabaseView.tsx

@@ -1,3 +1,4 @@
+import { obtainFormulasFromFolder } from "automations/AutomationsHelper";
 import { DatabaseColumn } from "cdm/DatabaseModel";
 import { ViewEvents } from "cdm/EmitterModel";
 import {
@@ -44,6 +45,7 @@ export class DatabaseView extends TextFileView implements HoverParent {
   columns: Array<TableColumn>;
   shadowColumns: Array<TableColumn>;
   initial: InitialType;
+  formulas: Record<string, unknown>;
 
   constructor(leaf: WorkspaceLeaf, plugin: DBFolderPlugin) {
     super(leaf);
@@ -151,7 +153,6 @@ export class DatabaseView extends TextFileView implements HoverParent {
       );
       let yamlColumns: Record<string, DatabaseColumn> =
         this.diskConfig.yaml.columns;
-      this.diskConfig.yaml.config;
       // Complete the columns with the metadata columns
       yamlColumns = await obtainMetadataColumns(
         yamlColumns,
@@ -167,6 +168,10 @@ export class DatabaseView extends TextFileView implements HoverParent {
       );
 
       this.initial = obtainInitialType(this.columns);
+
+      this.formulas = await obtainFormulasFromFolder(
+        this.diskConfig.yaml.config
+      );
       // Define table properties
       this.shadowColumns = this.columns.filter((col) => col.skipPersist);
       const tableProps: TableDataType = {

src/Settings.ts

@@ -14,6 +14,7 @@ import { DatabaseSettings } from "cdm/SettingsModel";
 import editing_engine_settings_section from "settings/EditingEngineSection";
 import rows_settings_section from "settings/RowsSection";
 import csv_settings_section from "settings/CSVSection";
+import automation_settings_section from "settings/AutomationSection";
 
 export type SettingRetriever = <K extends keyof DatabaseSettings>(
   key: K,
@@ -91,6 +92,8 @@ export class SettingsManager {
     rows_settings_section.run(settingHandlerResponse);
     /** Editing engine section */
     editing_engine_settings_section.run(settingHandlerResponse);
+    /** Automation section */
+    automation_settings_section.run(settingHandlerResponse);
     if (!settingHandlerResponse.local) {
       /** Media section */
       media_settings_section(settingHandlerResponse);

src/automations/AutomationsHelper.ts

@@ -0,0 +1,8 @@
+import { LocalSettings } from "cdm/SettingsModel";
+import { FormulaGenerator } from "automations/FormulaGenerator";
+
+export async function obtainFormulasFromFolder(config: LocalSettings) {
+    const generator = new FormulaGenerator(config);
+    return await generator.generate_object();
+}
+

src/automations/FormulaGenerator.ts

@@ -0,0 +1,26 @@
+import { FormulaFunctions } from "automations/formula_functions/FormulaFunctions";
+import { IGenerateObject } from "automations/IGenerateObject";
+import { LocalSettings } from "cdm/SettingsModel";
+import { RowDataType } from "cdm/FolderModel";
+import { Literal } from "obsidian-dataview";
+export class FormulaGenerator implements IGenerateObject {
+    public formula_functions: FormulaFunctions;
+
+    constructor(private config: LocalSettings) {
+        this.formula_functions = new FormulaFunctions(config);
+    }
+
+    private async generate_formula_functions(): Promise<Record<string, unknown>> {
+
+        return await this.formula_functions.generate_object(this.config);
+    }
+
+    async generate_object(): Promise<Record<string, unknown>> {
+        const final_object: Record<string, any> = {};
+        Object.assign(final_object, {
+            js: await this.generate_formula_functions(),
+        });
+        console.log("sasdinal_object");
+        return final_object;
+    }
+}

src/automations/IGenerateObject.ts

@@ -0,0 +1,5 @@
+import { LocalSettings } from "cdm/SettingsModel";
+
+export interface IGenerateObject {
+    generate_object(config: LocalSettings): Promise<Record<string, unknown>>;
+}

src/automations/formula_functions/FormulaFunctions.ts

@@ -0,0 +1,26 @@
+import { IGenerateObject } from "automations/IGenerateObject";
+import { UserScriptFunctions } from "automations/formula_functions/ScriptFunctions";
+import { LocalSettings } from "cdm/SettingsModel";
+
+export class FormulaFunctions implements IGenerateObject {
+    private js_script_functions: UserScriptFunctions;
+
+    constructor(private config: LocalSettings) {
+        this.js_script_functions = new UserScriptFunctions(config);
+    }
+
+    async generate_object(
+        config: LocalSettings
+    ): Promise<Record<string, unknown>> {
+        let user_script_functions = {};
+
+        if (config.formula_folder_path) {
+            user_script_functions =
+                await this.js_script_functions.generate_object();
+        }
+
+        return {
+            ...user_script_functions,
+        };
+    }
+}

src/automations/formula_functions/ScriptFunctions.ts

@@ -0,0 +1,73 @@
+import { Notice, TFile } from "obsidian";
+import { IGenerateObject } from "automations/IGenerateObject";
+import { get_tfiles_from_folder } from "helpers/FileManagement";
+import { LocalSettings } from "cdm/SettingsModel";
+import { LOGGER } from "services/Logger";
+
+export class UserScriptFunctions implements IGenerateObject {
+    constructor(private config: LocalSettings) { }
+
+    async generate_user_script_functions(
+    ): Promise<Map<string, Function>> {
+        const user_script_functions: Map<string, Function> = new Map();
+        const files =
+            get_tfiles_from_folder(
+                this.config.formula_folder_path,
+            );
+
+        if (!files) {
+            return new Map();
+        }
+
+        for (const file of files) {
+            if (file.extension.toLowerCase() === "js") {
+                await this.load_user_script_function(
+                    file,
+                    user_script_functions
+                );
+            }
+        }
+        return user_script_functions;
+    }
+
+    async load_user_script_function(
+        file: TFile,
+        user_script_functions: Map<string, Function>
+    ): Promise<void> {
+        let req = (s: string) => {
+            return window.require && window.require(s);
+        };
+        let exp: Record<string, unknown> = {};
+        let mod = {
+            exports: exp
+        };
+
+        const file_content = await app.vault.read(file);
+        const wrapping_fn = window.eval("(function anonymous(require, module, exports){" + file_content + "\n})");
+        wrapping_fn(req, mod, exp);
+        const formula_function = exp['default'] || mod.exports;
+
+        if (!formula_function) {
+            const msg = `Failed to load user script ${file.path}. No exports detected.`;
+            LOGGER.error(msg);
+            new Notice(
+                msg
+                , 3000);
+            throw new Error(msg);
+        }
+        if (!(formula_function instanceof Function)) {
+            const msg = `Failed to load user script ${file.path}. Default export is not a function.`
+            LOGGER.error(msg);
+            new Notice(
+                msg
+                , 3000);
+            throw new Error(msg);
+        }
+        user_script_functions.set(`${file.basename}`, formula_function);
+    }
+
+    async generate_object(): Promise<Record<string, unknown>> {
+        const user_script_functions = await this.generate_user_script_functions();
+        return Object.fromEntries(user_script_functions);
+    }
+}

src/cdm/FolderModel.ts

@@ -40,6 +40,7 @@ export interface ConfigColumn {
     media_height: number;
     isInline: boolean;
     task_hide_completed?: boolean;
+    formula_query?: string;
     [key: string]: Literal;
 }
 

src/cdm/SettingsModel.ts

@@ -38,6 +38,7 @@ export interface LocalSettings {
     source_data: string;
     sticky_first_column: boolean;
     row_templates_folder: string;
+    formula_folder_path: string;
 }
 
 export interface FilterSettings {

src/cdm/TableStateInterface.ts

@@ -84,7 +84,19 @@ export interface RowTemplateState {
     update: (template: string) => void;
 }
 
+export interface AutomationState {
+    formula: { [key: string]: unknown };
+    info: {
+        getFormula: (name: string) => unknown;
+        runFormula: (input: string, row: RowDataType, dbbConfig: LocalSettings) => Literal;
+    },
+    actions: {
+        loadFormulas: (ddbbConfig: LocalSettings) => Promise<void>;
+    }
+}
+
 export interface TableStateInterface {
+    automations: UseBoundStore<StoreApi<AutomationState>>;
     configState: UseBoundStore<StoreApi<ConfigState>>;
     rowTemplate: UseBoundStore<StoreApi<RowTemplateState>>;
     data: UseBoundStore<StoreApi<DataState>>;