fix(template): preserve wikilink lists in frontmatter

Author: chhoumann

src/engine/CaptureChoiceEngine.template-property-types.test.ts

@@ -147,7 +147,7 @@ describe("CaptureChoiceEngine template property types", () => {
 		};
 	});
 
-	it("post-processes capture frontmatter arrays into YAML lists", async () => {
+	it("writes a YAML-safe placeholder before post-processing capture frontmatter arrays", async () => {
 		const targetPath = "Journal/Test.md";
 		const createdContent: Record<string, string> = {};
 		let writtenContent = "";
@@ -270,7 +270,9 @@ describe("CaptureChoiceEngine template property types", () => {
 
 		await engine.run();
 
-		expect(writtenContent).toContain("tags: foo,bar");
+		// The raw file write only needs to stay YAML-parseable; processFrontMatter
+		// applies the final structured array value afterward.
+		expect(writtenContent).toContain("tags: []");
 		expect(processFrontMatter).toHaveBeenCalledTimes(1);
 		expect(appliedFrontmatter?.tags).toEqual(["foo", "bar"]);
 	});

src/formatters/formatter-template-property-types.test.ts

@@ -129,6 +129,15 @@ describe('Formatter template property type inference', () => {
 		expect(vars.get('projects')).toEqual(['project1', 'project2']);
 	});
 
+	it('uses a YAML-safe placeholder for collected arrays before post-processing', async () => {
+		(formatter as any).variables.set('tags', ['[[John Doe]]', '[[Jane Doe]]']);
+		const output = await formatter.testFormat('---\ntags: {{VALUE:tags}}\n---');
+		const vars = formatter.getAndClearTemplatePropertyVars();
+
+		expect(output).toBe('---\ntags: []\n---');
+		expect(vars.get('tags')).toEqual(['[[John Doe]]', '[[Jane Doe]]']);
+	});
+
 	it('ignores wiki links with commas to avoid incorrect splitting', async () => {
 		(formatter as any).variables.set('source', '[[test, a]]');
 		await formatter.testFormat('---\nsource: {{VALUE:source}}\n---');

src/formatters/formatter.ts

@@ -27,6 +27,7 @@ import { TemplatePropertyCollector } from "../utils/TemplatePropertyCollector";
 import { settingsStore } from "../settingsStore";
 import { normalizeDateInput } from "../utils/dateAliases";
 import { transformCase } from "../utils/caseTransform";
+import { getYamlPlaceholder } from "../utils/yamlValues";
 import {
 	parseAnonymousValueOptions,
 	parseValueToken,
@@ -386,7 +387,7 @@ export abstract class Formatter {
 					: rawValue;
 
 			// Offer this variable to the property collector for YAML post-processing
-			this.propertyCollector.maybeCollect({
+			const structuredYamlValue = this.propertyCollector.maybeCollect({
 				input: output,
 				matchStart: match.index,
 				matchEnd: match.index + match[0].length,
@@ -395,8 +396,11 @@ export abstract class Formatter {
 				featureEnabled: propertyTypesEnabled,
 			});
 
-			// Always use string replacement initially
-			const rawReplacement = this.getVariableValue(effectiveKey);
+			// Keep the interim frontmatter YAML-parseable until post-processing
+			// writes the real structured value back through Obsidian.
+			const rawReplacement =
+				getYamlPlaceholder(structuredYamlValue) ??
+				this.getVariableValue(effectiveKey);
 			const replacement = transformCase(rawReplacement, caseStyle);
 
 			// Replace in output and adjust regex position

src/utils/TemplatePropertyCollector.ts

@@ -4,6 +4,7 @@ import {
 	parseStructuredPropertyValueFromString,
 	type ParseOptions,
 } from "./templatePropertyStringParser";
+import { isStructuredYamlValue } from "./yamlValues";
 
 const PATH_SEPARATOR = "\u0000";
 
@@ -26,13 +27,13 @@ export class TemplatePropertyCollector {
    * Collects a variable for YAML post-processing when it is a complete value for a YAML key
    * and the raw value is a structured type (object/array/number/boolean/null).
    */
-  public maybeCollect(args: CollectArgs): void {
+  public maybeCollect(args: CollectArgs): unknown | undefined {
     const { input, matchStart, matchEnd, rawValue, fallbackKey, featureEnabled } = args;
-    if (!featureEnabled) return;
+    if (!featureEnabled) return undefined;
     const yamlRange = findYamlFrontMatterRange(input);
     const context = getYamlContextForMatch(input, matchStart, matchEnd, yamlRange);
 
-    if (!context.isInYaml) return;
+    if (!context.isInYaml) return undefined;
 
     const lineContent = input.slice(context.lineStart, context.lineEnd);
     const trimmedLine = lineContent.trim();
@@ -49,7 +50,7 @@ export class TemplatePropertyCollector {
       propertyPath = this.findListParentPath(input, context.lineStart, context.baseIndent ?? "");
     }
 
-    if (!propertyPath || propertyPath.length === 0) return;
+    if (!propertyPath || propertyPath.length === 0) return undefined;
     const effectiveKey = propertyPath[propertyPath.length - 1];
 
     let structuredValue = rawValue;
@@ -61,17 +62,11 @@ export class TemplatePropertyCollector {
       }
     }
 
-    const isStructured =
-      typeof structuredValue !== "string" &&
-      (Array.isArray(structuredValue) ||
-        (typeof structuredValue === "object" && structuredValue !== null) ||
-        typeof structuredValue === "number" ||
-        typeof structuredValue === "boolean" ||
-        structuredValue === null);
-    if (!isStructured) return;
+    if (!isStructuredYamlValue(structuredValue)) return undefined;
 
     const mapKey = propertyPath.join(PATH_SEPARATOR);
     this.map.set(mapKey, structuredValue);
+    return structuredValue;
   }
 
   /** Returns a copy and clears the collector. */

src/utils/yamlValues.test.ts

@@ -1,5 +1,9 @@
 import { describe, expect, it } from "vitest";
-import { coerceYamlValue } from "./yamlValues";
+import {
+	coerceYamlValue,
+	getYamlPlaceholder,
+	isStructuredYamlValue,
+} from "./yamlValues";
 
 describe("coerceYamlValue", () => {
   it("converts @date:ISO to Date", () => {
@@ -23,3 +27,33 @@ describe("coerceYamlValue", () => {
     expect(coerceYamlValue(arr)).toBe(arr);
   });
 });
+
+describe("isStructuredYamlValue", () => {
+	it("accepts structured YAML property values", () => {
+		expect(isStructuredYamlValue(["a"])).toBe(true);
+		expect(isStructuredYamlValue({ a: 1 })).toBe(true);
+		expect(isStructuredYamlValue(42)).toBe(true);
+		expect(isStructuredYamlValue(false)).toBe(true);
+		expect(isStructuredYamlValue(null)).toBe(true);
+	});
+
+	it("rejects plain string placeholders", () => {
+		expect(isStructuredYamlValue("hello")).toBe(false);
+		expect(isStructuredYamlValue(undefined)).toBe(false);
+	});
+});
+
+describe("getYamlPlaceholder", () => {
+	it("returns YAML-safe placeholders for structured values", () => {
+		expect(getYamlPlaceholder(["a"])).toBe("[]");
+		expect(getYamlPlaceholder({ a: 1 })).toBe("{}");
+		expect(getYamlPlaceholder(42)).toBe("42");
+		expect(getYamlPlaceholder(true)).toBe("true");
+		expect(getYamlPlaceholder(null)).toBe("null");
+	});
+
+	it("returns undefined for non-structured values", () => {
+		expect(getYamlPlaceholder("hello")).toBeUndefined();
+		expect(getYamlPlaceholder(undefined)).toBeUndefined();
+	});
+});

src/utils/yamlValues.ts

@@ -37,3 +37,29 @@ export function coerceYamlValue(v: unknown): unknown {
   // Return original value for non-@date: strings and invalid dates
   return v;
 }
+
+/**
+ * Returns whether a value should be written back through Obsidian's YAML
+ * processor as a structured property type instead of plain string text.
+ */
+export function isStructuredYamlValue(v: unknown): boolean {
+  return typeof v !== "string" && (
+    Array.isArray(v) ||
+    (typeof v === "object" && v !== null) ||
+    typeof v === "number" ||
+    typeof v === "boolean" ||
+    v === null
+  );
+}
+
+/**
+ * Produces a YAML-parseable placeholder for structured values so frontmatter
+ * stays valid until processFrontMatter rewrites the final value.
+ */
+export function getYamlPlaceholder(v: unknown): string | undefined {
+  if (!isStructuredYamlValue(v)) return undefined;
+  if (Array.isArray(v)) return "[]";
+  if (v === null) return "null";
+  if (typeof v === "object") return "{}";
+  return String(v);
+}

tests/e2e/template-property-links.test.ts

@@ -0,0 +1,188 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, it } from "vitest";
+import {
+	acquireVaultRunLock,
+	captureFailureArtifacts,
+	clearVaultRunLockMarker,
+	createObsidianClient,
+	createSandboxApi,
+} from "obsidian-e2e";
+import type {
+	ObsidianClient,
+	PluginHandle,
+	SandboxApi,
+	VaultRunLock,
+} from "obsidian-e2e";
+
+const VAULT = "dev";
+const PLUGIN_ID = "quickadd";
+const WAIT_OPTS = { timeoutMs: 10_000, intervalMs: 200 };
+
+let obsidian: ObsidianClient;
+let sandbox: SandboxApi;
+let qa: PluginHandle;
+let lock: VaultRunLock | undefined;
+
+type QuickAddData = {
+	choices: Record<string, unknown>[];
+	migrations: Record<string, boolean>;
+	enableTemplatePropertyTypes?: boolean;
+};
+
+function templateChoice(id: string, templatePath: string, format: string) {
+	return {
+		id,
+		name: id,
+		type: "Template",
+		command: false,
+		templatePath,
+		fileNameFormat: { enabled: true, format },
+		folder: {
+			enabled: false,
+			folders: [],
+			chooseWhenCreatingNote: false,
+			createInSameFolderAsActiveFile: false,
+			chooseFromSubfolders: false,
+		},
+		appendLink: false,
+		openFile: false,
+		fileOpening: {
+			location: "tab",
+			direction: "vertical",
+			mode: "source",
+			focus: false,
+		},
+	};
+}
+
+function clearTestChoices(data: QuickAddData) {
+	data.choices = data.choices.filter(
+		(choice) => !String(choice.id ?? "").startsWith("__qa-test-1140-"),
+	);
+}
+
+async function seedTemplate(path: string, content: string) {
+	await sandbox.write(path, content, {
+		waitForContent: true,
+		waitOptions: WAIT_OPTS,
+	});
+}
+
+async function runChoice(name: string, vars: Record<string, unknown>) {
+	await obsidian.exec("quickadd:run", {
+		choice: name,
+		vars: JSON.stringify(vars),
+	});
+}
+
+async function runChoiceAndWaitForContent(
+	name: string,
+	vars: Record<string, unknown>,
+	file: string,
+	expected: string,
+) {
+	await runChoice(name, vars);
+	return sandbox.waitForContent(
+		file,
+		(content) => content.includes(expected),
+		WAIT_OPTS,
+	);
+}
+
+beforeAll(async () => {
+	obsidian = createObsidianClient({ vault: VAULT });
+	await obsidian.verify();
+
+	lock = await acquireVaultRunLock({
+		vaultName: VAULT,
+		vaultPath: await obsidian.vaultPath(),
+	});
+	await lock.publishMarker(obsidian);
+
+	qa = obsidian.plugin(PLUGIN_ID);
+	sandbox = await createSandboxApi({
+		obsidian,
+		sandboxRoot: "__obsidian_e2e__",
+		testName: "template-property-links",
+	});
+}, 30_000);
+
+afterAll(async () => {
+	await qa.restoreData();
+	await qa.reload();
+	await sandbox.cleanup();
+	await clearVaultRunLockMarker(obsidian).catch(() => {});
+	await lock?.release();
+}, 15_000);
+
+beforeEach((ctx) => {
+	ctx.onTestFailed(async () => {
+		await captureFailureArtifacts(
+			{ id: ctx.task.id, name: ctx.task.name },
+			obsidian,
+			{ plugin: qa, captureOnFailure: true },
+		);
+	});
+});
+
+describe("issue 1140: list properties with links", () => {
+	beforeAll(async () => {
+		const root = sandbox.root;
+		const templatePath = sandbox.path("issue-1140-template.md");
+
+		await seedTemplate(
+			"issue-1140-template.md",
+			[
+				"---",
+				"authors: {{VALUE:authors}}",
+				"---",
+				"",
+			].join("\n"),
+		);
+
+		await qa.data<QuickAddData>().patch((data) => {
+			clearTestChoices(data);
+			data.enableTemplatePropertyTypes = true;
+			data.choices.push(
+				templateChoice(
+					"__qa-test-1140-single-link",
+					templatePath,
+					`${root}/qa-1140-single-link`,
+				),
+				templateChoice(
+					"__qa-test-1140-multi-link",
+					templatePath,
+					`${root}/qa-1140-multi-link`,
+				),
+			);
+		});
+
+		await qa.reload({ waitUntilReady: true });
+	}, 15_000);
+
+	it("formats a single wikilink list item as a YAML list", async () => {
+		const content = await runChoiceAndWaitForContent(
+			"__qa-test-1140-single-link",
+			{ authors: ["[[John Doe]]"] },
+			"qa-1140-single-link.md",
+			'  - "[[John Doe]]"',
+		);
+
+		expect(content).toContain("authors:");
+		expect(content).toContain('  - "[[John Doe]]"');
+		expect(content).not.toContain("authors: [[John Doe]]");
+	});
+
+	it("formats multiple wikilinks as separate YAML list items", async () => {
+		const content = await runChoiceAndWaitForContent(
+			"__qa-test-1140-multi-link",
+			{ authors: ["[[John Doe]]", "[[Jane Doe]]"] },
+			"qa-1140-multi-link.md",
+			'  - "[[Jane Doe]]"',
+		);
+
+		expect(content).toContain("authors:");
+		expect(content).toContain('  - "[[John Doe]]"');
+		expect(content).toContain('  - "[[Jane Doe]]"');
+		expect(content).not.toContain("authors: [[John Doe]],[[Jane Doe]]");
+	});
+});