obsidian-confluence 5.6.0

package/src/MyBaseClient.ts

@@ -0,0 +1,220 @@
+import {
+	Api,
+	Callback,
+	Client,
+	Config,
+	RequestConfig,
+	AuthenticationService,
+} from "confluence.js";
+import { requestUrl } from "obsidian";
+import { RequiredConfluenceClient } from "md-confluence-lib";
+
+const ATLASSIAN_TOKEN_CHECK_FLAG = "X-Atlassian-Token";
+const ATLASSIAN_TOKEN_CHECK_NOCHECK_VALUE = "no-check";
+
+export class MyBaseClient implements Client {
+	protected urlSuffix = "/wiki/rest";
+
+	constructor(protected readonly config: Config) {}
+
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	protected paramSerializer(parameters: Record<string, any>): string {
+		const parts: string[] = [];
+
+		Object.entries(parameters).forEach(([key, value]) => {
+			if (value === null || typeof value === "undefined") {
+				return;
+			}
+
+			if (Array.isArray(value)) {
+				// eslint-disable-next-line no-param-reassign
+				value = value.join(",");
+			}
+
+			if (value instanceof Date) {
+				// eslint-disable-next-line no-param-reassign
+				value = value.toISOString();
+			} else if (value !== null && typeof value === "object") {
+				// eslint-disable-next-line no-param-reassign
+				value = JSON.stringify(value);
+			} else if (value instanceof Function) {
+				const part = value();
+
+				return part && parts.push(part);
+			}
+
+			parts.push(`${this.encode(key)}=${this.encode(value)}`);
+
+			return;
+		});
+
+		return parts.join("&");
+	}
+
+	protected encode(value: string) {
+		return encodeURIComponent(value)
+			.replace(/%3A/gi, ":")
+			.replace(/%24/g, "$")
+			.replace(/%2C/gi, ",")
+			.replace(/%20/g, "+")
+			.replace(/%5B/gi, "[")
+			.replace(/%5D/gi, "]");
+	}
+
+	protected removeUndefinedProperties(
+		// eslint-disable-next-line @typescript-eslint/no-explicit-any
+		obj: Record<string, any>,
+		// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	): Record<string, any> {
+		return Object.entries(obj)
+			.filter(([, value]) => typeof value !== "undefined")
+			.reduce(
+				(accumulator, [key, value]) => ({
+					...accumulator,
+					[key]: value,
+				}),
+				{},
+			);
+	}
+
+	async sendRequest<T>(
+		requestConfig: RequestConfig,
+		callback: never,
+		// eslint-disable-next-line @typescript-eslint/no-explicit-any
+		telemetryData?: any,
+	): Promise<T>;
+	async sendRequest<T>(
+		requestConfig: RequestConfig,
+		callback: Callback<T>,
+		// eslint-disable-next-line @typescript-eslint/no-explicit-any
+		telemetryData?: any,
+	): Promise<void>;
+	async sendRequest<T>(
+		requestConfig: RequestConfig,
+		callback: Callback<T> | never,
+	): Promise<void | T> {
+		try {
+			const contentType = (requestConfig.headers ?? {})[
+				"content-type"
+			]?.toString();
+			if (requestConfig.headers && contentType) {
+				requestConfig.headers["Content-Type"] = contentType;
+				delete requestConfig?.headers["content-type"];
+			}
+
+			const params = this.paramSerializer(requestConfig.params);
+
+			const requestContentType =
+				(requestConfig.headers ?? {})["Content-Type"]?.toString() ??
+				"application/json";
+
+			const requestBody = requestContentType.startsWith(
+				"multipart/form-data",
+			)
+				? [
+						requestConfig.data.getHeaders(),
+						requestConfig.data.getBuffer().buffer,
+				  ]
+				: [{}, JSON.stringify(requestConfig.data)];
+
+			const modifiedRequestConfig = {
+				...requestConfig,
+				headers: this.removeUndefinedProperties({
+					"User-Agent": "Obsidian.md",
+					Accept: "application/json",
+					[ATLASSIAN_TOKEN_CHECK_FLAG]: this.config
+						.noCheckAtlassianToken
+						? ATLASSIAN_TOKEN_CHECK_NOCHECK_VALUE
+						: undefined,
+					...this.config.baseRequestConfig?.headers,
+					Authorization:
+						await AuthenticationService.getAuthenticationToken(
+							this.config.authentication,
+							{
+								// eslint-disable-next-line @typescript-eslint/naming-convention
+								baseURL: this.config.host,
+								url: `${this.config.host}${this.urlSuffix}`,
+								method: requestConfig.method ?? "GET",
+							},
+						),
+					...requestConfig.headers,
+					"Content-Type": requestContentType,
+					...requestBody[0],
+				}),
+				url: `${this.config.host}${this.urlSuffix}${requestConfig.url}?${params}`,
+				body: requestBody[1],
+				method: requestConfig.method?.toUpperCase() ?? "GET",
+				contentType: requestContentType,
+				throw: false,
+			};
+			delete modifiedRequestConfig.data;
+
+			const response = await requestUrl(modifiedRequestConfig);
+
+			if (response.status >= 400) {
+				throw new HTTPError(`Received a ${response.status}`, {
+					status: response.status,
+					data: response.text,
+				});
+			}
+
+			const callbackResponseHandler =
+				callback && ((data: T): void => callback(null, data));
+			const defaultResponseHandler = (data: T): T => data;
+
+			const responseHandler =
+				callbackResponseHandler ?? defaultResponseHandler;
+
+			this.config.middlewares?.onResponse?.(response.json);
+
+			return responseHandler(response.json);
+			// eslint-disable-next-line @typescript-eslint/no-explicit-any
+		} catch (e: any) {
+			console.warn({ httpError: e, requestConfig });
+			const err =
+				this.config.newErrorHandling && e.isAxiosError
+					? e.response.data
+					: e;
+
+			const callbackErrorHandler =
+				callback && ((error: Config.Error) => callback(error));
+			const defaultErrorHandler = (error: Error) => {
+				throw error;
+			};
+
+			const errorHandler = callbackErrorHandler ?? defaultErrorHandler;
+
+			this.config.middlewares?.onError?.(err);
+
+			return errorHandler(err);
+		}
+	}
+}
+
+export interface ErrorData {
+	data: unknown;
+	status: number;
+}
+
+export class HTTPError extends Error {
+	constructor(
+		msg: string,
+		public response: ErrorData,
+	) {
+		super(msg);
+
+		// Set the prototype explicitly.
+		Object.setPrototypeOf(this, HTTPError.prototype);
+	}
+}
+
+export class ObsidianConfluenceClient
+	extends MyBaseClient
+	implements RequiredConfluenceClient
+{
+	content = new Api.Content(this);
+	space = new Api.Space(this);
+	contentAttachments = new Api.ContentAttachments(this);
+	contentLabels = new Api.ContentLabels(this);
+	users = new Api.Users(this);
+}

package/src/adaptors/obsidian.ts

@@ -0,0 +1,146 @@
+import { Vault, MetadataCache, App, TFile } from "obsidian";
+import {
+	ConfluenceUploadSettings,
+	BinaryFile,
+	FilesToUpload,
+	LoaderAdaptor,
+	MarkdownFile,
+	ConfluencePageConfig,
+} from "md-confluence-lib";
+import { lookup } from "mime-types";
+
+export default class ObsidianAdaptor implements LoaderAdaptor {
+	vault: Vault;
+	metadataCache: MetadataCache;
+	settings: ConfluenceUploadSettings.ConfluenceSettings;
+	app: App;
+
+	constructor(
+		vault: Vault,
+		metadataCache: MetadataCache,
+		settings: ConfluenceUploadSettings.ConfluenceSettings,
+		app: App,
+	) {
+		this.vault = vault;
+		this.metadataCache = metadataCache;
+		this.settings = settings;
+		this.app = app;
+	}
+
+	async getMarkdownFilesToUpload(): Promise<FilesToUpload> {
+		const files = this.vault.getMarkdownFiles();
+		const filesToPublish = [];
+		for (const file of files) {
+			try {
+				if (file.path.endsWith(".excalidraw")) {
+					continue;
+				}
+
+				const fileFM = this.metadataCache.getCache(file.path);
+				if (!fileFM) {
+					throw new Error("Missing File in Metadata Cache");
+				}
+				const frontMatter = fileFM.frontmatter;
+
+				if (
+					(file.path.startsWith(this.settings.folderToPublish) &&
+						(!frontMatter ||
+							frontMatter["connie-publish"] !== false)) ||
+					(frontMatter && frontMatter["connie-publish"] === true)
+				) {
+					filesToPublish.push(file);
+				}
+			} catch {
+				//ignore
+			}
+		}
+		const filesToUpload = [];
+
+		for (const file of filesToPublish) {
+			const markdownFile = await this.loadMarkdownFile(file.path);
+			filesToUpload.push(markdownFile);
+		}
+
+		return filesToUpload;
+	}
+
+	async loadMarkdownFile(absoluteFilePath: string): Promise<MarkdownFile> {
+		const file = this.app.vault.getAbstractFileByPath(absoluteFilePath);
+		if (!(file instanceof TFile)) {
+			throw new Error("Not a TFile");
+		}
+
+		const fileFM = this.metadataCache.getCache(file.path);
+		if (!fileFM) {
+			throw new Error("Missing File in Metadata Cache");
+		}
+		const frontMatter = fileFM.frontmatter;
+
+		const parsedFrontMatter: Record<string, unknown> = {};
+		if (frontMatter) {
+			for (const [key, value] of Object.entries(frontMatter)) {
+				parsedFrontMatter[key] = value;
+			}
+		}
+
+		return {
+			pageTitle: file.basename,
+			folderName: file.parent.name,
+			absoluteFilePath: file.path,
+			fileName: file.name,
+			contents: await this.vault.cachedRead(file),
+			frontmatter: parsedFrontMatter,
+		};
+	}
+
+	async readBinary(
+		path: string,
+		referencedFromFilePath: string,
+	): Promise<BinaryFile | false> {
+		const testing = this.metadataCache.getFirstLinkpathDest(
+			path,
+			referencedFromFilePath,
+		);
+		if (testing) {
+			const files = await this.vault.readBinary(testing);
+			const mimeType =
+				lookup(testing.extension) || "application/octet-stream";
+			return {
+				contents: files,
+				filePath: testing.path,
+				filename: testing.name,
+				mimeType: mimeType,
+			};
+		}
+
+		return false;
+	}
+	async updateMarkdownValues(
+		absoluteFilePath: string,
+		values: Partial<ConfluencePageConfig.ConfluencePerPageAllValues>,
+	): Promise<void> {
+		const config = ConfluencePageConfig.conniePerPageConfig;
+		const file = this.app.vault.getAbstractFileByPath(absoluteFilePath);
+		if (file instanceof TFile) {
+			this.app.fileManager.processFrontMatter(file, (fm) => {
+				for (const propertyKey in config) {
+					if (!config.hasOwnProperty(propertyKey)) {
+						continue;
+					}
+
+					const { key } =
+						config[
+							propertyKey as keyof ConfluencePageConfig.ConfluencePerPageConfig
+						];
+					const value =
+						values[
+							propertyKey as keyof ConfluencePageConfig.ConfluencePerPageAllValues
+						];
+					if (propertyKey in values) {
+						fm[key] = value;
+					}
+				}
+			});
+		}
+	}
+}

package/src/custom.d.ts

@@ -0,0 +1,19 @@
+declare module "*.txt" {
+	const content: string;
+	export default content;
+}
+
+declare module "*.json" {
+	const content: unknown;
+	export default content;
+}
+
+declare module "mermaid_renderer.esbuild" {
+	const content: Buffer;
+	export default content;
+}
+
+declare module "sort-any" {
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	export default function sortAny<T>(item: T): T;
+}