Use models in confluence-syncer

Author: echetzakis

dist/index.js

@@ -1,14 +1,15 @@
-import path from 'node:path';
 import context from './context.js';
 import config from './config.js';
 import logger from './logger.js';
 import ConfluenceSDK from './confluence-sdk.js';
-import { Image, Graph, Meta } from '../lib/models/index.js';
+import { Meta, LocalPage } from '../lib/models/index.js';
 import AssetRenderer from './renderers/asset-renderer.js';
 
 const confluence = new ConfluenceSDK(config.confluence);
-const [majorVer, minorVer] = config.version.split('.');
 
+/**
+ * Sync local markdown documentation with Confluence
+ */
 export async function sync() {
     try {
         const { siteName, repo, pages: localPages, readMe, pageRefs } = context.getContext();
@@ -44,53 +45,47 @@ function errorHandler(error) {
 /**
  * Create or update home page from README.md
  * 
- * @typedef {import('../lib/models/local-page.js').default} LocalPage 
  * @param {string} repo 
  * @param {string} siteName 
- * @param {LocalPage} readMe 
+ * @param {LocalPage} localPage 
  * @param {AssetRenderer} renderer 
- * @returns {number} Home page id
+ * @returns {Promise<number>} Home page id
  */
-async function syncHome(repo, siteName, readMe, renderer) {
-    const parentPage = await findParentPage();
-    const homeTitle = siteName;
-    let homeHtml = `<h1>${siteName}</h1>`;
-    let attachments = [];
-    let homeMeta = new Meta(repo);
-    if (readMe) {
-        readMe.render(renderer);
-        homeMeta = readMe.meta;
-        homeHtml = readMe.html;
-        attachments = readMe.attachments;
+async function syncHome(repo, siteName, localPage, renderer) {
+    if (!localPage) {
+        localPage = new LocalPage(siteName, new Meta(repo));
+        localPage.html = `<h1>${siteName}</h1>`;
     }
-    const existingPage = await confluence.findPage(homeTitle);
-    if (existingPage) {
-        // check if repo matches
-        if (existingPage.meta.repo !== homeMeta.repo) {
-            throw new Error(`Page "${homeTitle}" already exist for another repo "${existingPage.meta.repo}"`);
-        }
-        if (config.confluence.forceUpdate || versionChange(existingPage) || existingPage.meta.sha !== homeMeta.sha) {
-            await confluence.updatePage(existingPage.id, existingPage.version + 1, homeTitle, homeHtml, parentPage, homeMeta);
-            await createAttachments(existingPage.id, attachments, renderer);
+    localPage.parentPageId = await findParentPage();
+    let homePage = localPage;
+    const remotePage = await confluence.findPage(siteName);
+    if (remotePage) {
+        homePage = remotePage;
+        homePage.localPage = localPage;
+        // check for potential repo conflict
+        if (homePage.repoConflict()) {
+            throw new Error(`Page "${siteName}" already exist for another repo "${homePage.meta.repo}"`);
         }
-        return existingPage.id;
-    } else {
-        const pageId = await confluence.createPage(homeTitle, homeHtml, parentPage, homeMeta);
-        await createAttachments(pageId, attachments, renderer);
-        return pageId;
     }
+    return homePage.sync(renderer, confluence).then(page => page.id);
 }
 
+/**
+ * Find the `id` of the Confluence page Configured to be the parent for our documents
+ * 
+ * @returns {number} The `id` of the configured parent page
+ * @throws `Error` if the configured parent page does not exist
+ */
 async function findParentPage() {
     const title = config.confluence.parentPage;
-    let parentPage = null;
-    if (title) {
-        parentPage = await confluence.findPage(title);
-        if (!parentPage) {
-            throw new Error(`The page configured as parent (${title}) does not exist in confluence`);
-        }
+    if (!title) {
+        return;
+    }
+    const parentPage = await confluence.findPage(title);
+    if (!parentPage) {
+        throw new Error(`The page configured as parent (${title}) does not exist in confluence`);
     }
-    return parentPage?.id;
+    return parentPage.id;
 }
 
 /**
@@ -101,50 +96,10 @@ async function findParentPage() {
  * @param {AssetRenderer} renderer - `AssetRenderer` instance 
  */
 async function syncPages(home, localPages, renderer) {
-    // get children of home
-    const remotePages = await confluence.getChildPages(home);
-    // compute diff between remote and local pages
-    const differences = diff(localPages, remotePages);
-    // delete removed pages
-    await unpublish(differences.delete);
-    // update changed pages
-    await update(differences.update, home, renderer);
-    // create added pages
-    await create(differences.create, home, renderer);
-}
-
-/**
- * 
- * @param {number} home - The id of the home page 
- * @param {Array<LocalPage>} localPages - Array of pages to be created
- * @param {AssetRenderer} renderer - `AssetRenderer` instance 
- */
-async function create(localPages, home, renderer) {
-    for (let page of localPages) {
-        page.render(renderer);
-        const pageId = await confluence.createPage(page.title, page.html, home, page.meta);
-        await createAttachments(pageId, page.attachments, renderer);
-        logger.debug(`Created Page: [${pageId}] ${page.title}`);
-    }
-}
-
-/**
- * 
- * @param {number} home - The id of the home page 
- * @param {Array<LocalPage>} localPages - Array of pages to be updated
- * @param {AssetRenderer} renderer - `AssetRenderer` instance 
- */
-async function update(localPages, home, renderer) {
-    for (let page of localPages) {
-        page.render(renderer);
-        await createAttachments(page.id, page.attachments, renderer);
-        await confluence
-            .updatePage(page.id, page.version, page.title, page.html, home, page.meta)
-            .then(() => {
-                logger.debug(
-                    `Updated Page: [${page.id}] ${page.title} v${page.version}`
-                );
-            });
+    // compute the union of local/remote pages that need to be synced
+    const pages = await union(home, localPages);
+    for (let page of pages) {
+        await page.sync(renderer, confluence);
     }
 }
 
@@ -156,77 +111,34 @@ async function unpublish(remotePages) {
     }
 }
 
-async function createAttachments(pageId, attachments, renderer) {
-    for (const attachment of attachments) {
-        if (attachment instanceof Image) {
-            await createImage(pageId, attachment);
-        } else if (attachment instanceof Graph) {
-            await createGraph(pageId, attachment, renderer);
-        }
-    }
-}
-
-async function createImage(pageId, image) {
-    await confluence.createAttachment(pageId, path.resolve(image.path));
-    logger.debug(`Attached image "${image.path}" to page #${pageId}`);
-}
-
 /**
+ * @typedef {import('../lib/models/remote-page.js').default} RemotePage
  * 
- * @param {number} pageId - The id of the page to attach the graph 
- * @param {Graph} graph - The graph to be created
- * @param {AssetRenderer} renderer
+ * @param {number} parentPageId - The parent page to all pages
+ * @param {Array<LocalPage>} localPages 
+ * @returns {Array<LocalPage|RemotePage>} An `array` of pages to be synced
  */
-async function createGraph(pageId, graph, renderer) {
-    const attachment = await graph.render(renderer);
-    if (!attachment) {
-        logger.warn(`Graph "${graph.path}" for page #${pageId} could not be processed`);
-        return;
-    }
-    await confluence.createAttachment(pageId, path.resolve(attachment));
-    logger.debug(`Attached ${graph.type} graph "${graph.path}" to page #${pageId}`);
-}
-
-function diff(localPages, remotePages) {
-    const results = {
-        create: [],
-        update: [],
-        delete: []
-    };
-
+async function union(parentPageId, localPages) {
+    const remotePages = await confluence.getChildPages(parentPageId);
+    const union = [];
     for (let localPage of localPages) {
+        localPage.parentPageId = parentPageId;
         const remotePage = remotePages.get(localPage.meta.path);
         if (!remotePage) {
-            // not exist on remote -> create
-            results.create.push(localPage);
-        } else {
-            remotePages.delete(localPage.meta.path);
-            // if forceUpdate or exist with different sha, then update the page
-            if (config.confluence.forceUpdate || versionChange(remotePage) || localPage.meta.sha !== remotePage.meta.sha) {
-                localPage.id = remotePage.id;
-                localPage.version = remotePage.version + 1;
-                results.update.push(localPage);
-            }
+            union.push(localPage);
+            continue;
         }
+        remotePages.delete(localPage.meta.path);
+        remotePage.localPage = localPage;
+        union.push(remotePage);
     }
-
     // Any remaining remote page not matching a local page should be deleted
     for (let remotePage of remotePages.values()) {
-        results.delete.push(remotePage);
+        union.push(remotePage);
     }
-
-    return results;
+    return union;
 }
 
-function versionChange(remotePage) {
-    if (typeof remotePage.meta.publisher_version !== 'string') {
-        return true;
-    }
-    const [pubMajor, pubMinor] = remotePage.meta.publisher_version.split('.');
-    return pubMajor !== majorVer || pubMinor !== minorVer;
-}
-
-
 export async function cleanup() {
     const { siteName } = await context.getContext();
     try {
@@ -237,7 +149,7 @@ export async function cleanup() {
         }
         const remotePages = await confluence.getChildPages(home.id);
         // Delete all children
-        await unpublish(remotePages);
+        await unpublish(remotePages.values());
         // Delete home
         await unpublish([home]);
         cleanupSummary(siteName);