feat: allow specifying title and tags in templates

Author: nishantwrp

src/actions.ts

@@ -1,29 +1,39 @@
 import joplin from "api";
+import { NewNote } from "./parser";
 import { getSelectedFolder } from "./utils/folders";
+import { applyTagToNote, getAnyTagWithTitle } from "./utils/tags";
 
 export enum TemplateAction {
     NewNote = "newNote",
     NewTodo = "newTodo",
     InsertText = "insertText"
 }
 
-const performInsertTextAction = async (template: string) => {
-    await joplin.commands.execute("insertText", template);
+const performInsertTextAction = async (template: NewNote) => {
+    await joplin.commands.execute("insertText", template.body);
 }
 
-const performNewNoteAction = async (template: string) => {
+const performNewNoteAction = async (template: NewNote) => {
     const currentFolder = await getSelectedFolder();
-    const note = await joplin.data.post(["notes"], null, { body: template, parent_id: currentFolder });
+    const note = await joplin.data.post(["notes"], null, { body: template.body, parent_id: currentFolder, title: template.title });
+    for (const tag of template.tags) {
+        const tagId = (await getAnyTagWithTitle(tag)).id;
+        await applyTagToNote(tagId, note.id);
+    }
     await joplin.commands.execute("openNote", note.id);
 }
 
-const performNewTodoAction = async (template: string) => {
+const performNewTodoAction = async (template: NewNote) => {
     const currentFolder = await getSelectedFolder();
-    const note = await joplin.data.post(["notes"], null, { body: template, parent_id: currentFolder, is_todo: 1 });
+    const note = await joplin.data.post(["notes"], null, { body: template.body, parent_id: currentFolder, is_todo: 1, title: template.title });
+    for (const tag of template.tags) {
+        const tagId = (await getAnyTagWithTitle(tag)).id;
+        await applyTagToNote(tagId, note.id);
+    }
     await joplin.commands.execute("openNote", note.id);
 }
 
-export const performAction = async (action: TemplateAction, template: string): Promise<void> => {
+export const performAction = async (action: TemplateAction, template: NewNote): Promise<void> => {
     switch (action) {
         case TemplateAction.InsertText:
             await performInsertTextAction(template);

src/parser.ts

@@ -11,10 +11,20 @@ import { setTemplateVariablesView } from "./views/templateVariables";
 // eslint-disable-next-line @typescript-eslint/no-var-requires
 const frontmatter = require("front-matter");
 
+export interface NewNote {
+    title: string;
+    tags: string[];
+    body: string;
+}
+
+const NOTE_TITLE_VARIABLE_NAME = "template_title";
+const NOTE_TAGS_VARIABLE_NAME = "template_tags";
+
 export class Parser {
     private utils: DateAndTimeUtils;
     private dialog: string;
     private logger: Logger;
+    private specialVariableNames = [NOTE_TITLE_VARIABLE_NAME, NOTE_TAGS_VARIABLE_NAME];
 
     constructor(dateAndTimeUtils: DateAndTimeUtils, dialogViewHandle: string, logger: Logger) {
         this.utils = dateAndTimeUtils;
@@ -105,33 +115,92 @@ export class Parser {
         return this.mapUserResponseToVariables(variables, userResponse);
     }
 
-    public async parseTemplate(template: Note | null): Promise<string> {
+    private parseSpecialVariables(specialVariables: Record<string, unknown>, customVariableInputs: Record<string, string>) {
+        const res: Record<string, string> = {};
+        const context = {
+            ...this.getDefaultContext(),
+            ...customVariableInputs
+        };
+
+        for (const variable of Object.keys(specialVariables)) {
+            if (typeof specialVariables[variable] !== "string") {
+                throw new Error(`${variable} should be a string, found ${typeof specialVariables[variable]}.`);
+            }
+
+            const compiledText = Handlebars.compile(specialVariables[variable]);
+            res[variable] = compiledText(context);
+        }
+
+        return res;
+    }
+
+    private getNoteMetadata(parsedSpecialVariables: Record<string, string>) {
+        const meta = {
+            title: parsedSpecialVariables.fallback_note_title,
+            tags: []
+        };
+
+        if (NOTE_TITLE_VARIABLE_NAME in parsedSpecialVariables) {
+            meta.title = parsedSpecialVariables[NOTE_TITLE_VARIABLE_NAME];
+        }
+
+        if (NOTE_TAGS_VARIABLE_NAME in parsedSpecialVariables) {
+            meta.tags = parsedSpecialVariables[NOTE_TAGS_VARIABLE_NAME].split(",").map(t => t.trim());
+        }
+
+        return meta;
+    }
+
+    public async parseTemplate(template: Note | null): Promise<NewNote> {
         if (!template) {
-            return "";
+            return null;
         }
 
         try {
             const processedTemplate = frontmatter(template.body);
             const templateVariables = processedTemplate.attributes;
 
-            const variableInputs = await this.getVariableInputs(template.title, templateVariables);
+            const customVariables = {};
+            const specialVariables = {
+                fallback_note_title: template.title
+            };
+
+            for (const variable of Object.keys(templateVariables)) {
+                if (this.specialVariableNames.includes(variable)) {
+                    specialVariables[variable] = templateVariables[variable];
+                } else {
+                    customVariables[variable] = templateVariables[variable];
+                }
+            }
+
+            const variableInputs = await this.getVariableInputs(template.title, customVariables);
             if (variableInputs === null) {
-                return "";
+                return null;
             }
 
+            const parsedSpecialVariables = this.parseSpecialVariables(specialVariables, variableInputs);
+            const newNoteMeta = this.getNoteMetadata(parsedSpecialVariables);
+
+            // Remove the fallback property because it's not actually a variable defined by the user.
+            delete parsedSpecialVariables.fallback_note_title;
+
             const context = {
                 ...this.getDefaultContext(),
-                ...variableInputs
+                ...variableInputs,
+                ...parsedSpecialVariables
             };
 
             const templateBody = processedTemplate.body;
             const compiledTemplate = Handlebars.compile(templateBody);
 
-            return compiledTemplate(context);
+            return {
+                ...newNoteMeta,
+                body: compiledTemplate(context)
+            };
         } catch (err) {
             console.error("Error in parsing template.", err);
             await joplin.views.dialogs.showMessageBox(`There was an error parsing this template, please review it and try again.\n\n${err}`);
-            return "";
+            return null;
         }
     }
 }