hdoc-tools 0.8.21 → 0.8.23

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Hornbill Docs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/hdoc-build-db.js

@@ -0,0 +1,141 @@
+(function () {
+    'use strict';
+
+    const   path = require('path'),
+            hdoc_index = require(path.join(__dirname, 'hdoc-db.js')),
+            database = require('better-sqlite3');
+
+    const db_schema = {
+        hdoc_index: [
+            'relative_url UNINDEXED',
+            'book_id',
+            'book_audience UNINDEXED',
+            'book_tags',
+            'doc_title',
+            'doc_content',
+            'doc_preview UNINDEXED',
+            'doc_family_id'
+        ],
+        hdoc_meta: [
+            'doc_id INTEGER',
+            'contributor_count INTEGER UNINDEXED',
+            'edit_url UNINDEXED',
+            'last_commit UNINDEXED'
+        ],
+        hdoc_contributors: [
+            'doc_id INTEGER',
+            'login',
+            'name',
+            'avatar UNINDEXED',
+            'url UNINDEXED'
+        ]
+    };
+
+    exports.create_table = function (db, table, cols, virtual, fts5) {
+        const table_created = hdoc_index.create_table(db, table, cols, virtual, fts5);
+        if (table_created !== null) {
+            return `\nError creating table: ${table_created}`;
+        } else {
+            console.log(`\nTable created: ${table}`);
+        }
+        return null;
+    };
+
+    exports.create_db = function (db_path, doc_id) {
+        let response = {
+            error: null,
+            db: null
+        };
+        console.log('Performing SQlite index creation...');
+        let db_name = path.join(db_path, doc_id, 'index.db');
+        response.db = new database(db_name);
+        response.db.pragma('encoding="UTF-8"');
+        console.log(`\nDatabase created: ${db_name}`);
+
+        // Create tables
+        for (const key in db_schema) {
+            if (db_schema.hasOwnProperty(key)) {
+                const virtual = key === 'hdoc_index' ? true : false;
+                const fts5 = key === 'hdoc_index' ? true : false;
+                const table_created_error = this.create_table(response.db, key, db_schema[key], virtual, fts5);
+                if (table_created_error !== null) {
+                    console.log(table_created_error);
+                }
+            }
+        }
+        return response;
+    };
+
+    exports.populate_index = function (db, doc_id, book_config, index_records, verbose = false) {
+        let response = {
+            success: false,
+            index_success_count: 0,
+            error: ''
+        };
+
+        if (!book_config.tags) book_config.tags = [];
+
+        for (let i = 0; i < index_records.length; i++) {
+            let index_path_name = index_records[i].relative_path.replace('\\', '/').replace(`${doc_id}/`, '');
+            index_path_name = index_path_name.replace(path.extname(index_records[i].relative_path), '');
+            const index_vals = [
+                index_path_name,
+                doc_id,
+                book_config.audience.join(','),
+                book_config.tags.join(','),
+                index_records[i].index_html.fm_props.title,
+                index_records[i].index_html.text,
+                index_records[i].index_html.preview,
+                book_config.productFamily
+            ];
+            const index_response = hdoc_index.insert_record(db, 'hdoc_index', db_schema.hdoc_index, index_vals);
+            if (!index_response.success) {
+                console.log(`Index record creation failed - ${doc_id}/${index_records[i].index_html.fm_props.title}: ${index_response.error}`);
+                continue;
+            }
+
+            // Now add metadata
+            const meta_vals = [
+                parseInt(index_response.row_id, 10),
+                index_records[i].metadata.contributor_count,
+                index_records[i].metadata.edit_url,
+                index_records[i].metadata.last_commit
+            ];
+            const meta_response = hdoc_index.insert_record(db, 'hdoc_meta', db_schema.hdoc_meta, meta_vals);
+            if (!meta_response.success) {
+                console.log(`Index metadata record creation failed - ${doc_id}/${index_response.row_id}/${index_records[i].index_html.fm_props.title}: ${meta_response.error}`);
+                continue;
+            }
+            if (verbose) {
+                console.log(`Inserted index record ${index_response.row_id}: ${doc_id} - ${index_records[i].index_html.fm_props.title}`);
+                console.log(`Inserted index metadata record for index ID: ${meta_response.row_id}`);
+            }
+
+            // Now add contributor records
+            for (let j = 0; j < index_records[i].contributors.length; j++) {
+                const contrib_vals = [
+                    parseInt(index_response.row_id, 10),
+                    index_records[i].contributors[j].login,
+                    index_records[i].contributors[j].name,
+                    index_records[i].contributors[j].avatar_url,
+                    index_records[i].contributors[j].html_url
+                ];
+                const cont_response = hdoc_index.insert_record(db, 'hdoc_contributors', db_schema.hdoc_contributors, contrib_vals);
+                if (!cont_response.success) {
+                    console.log(`Index document contributor record creation failed - ${doc_id}/${index_response.row_id}/${index_records[i].index_html.fm_props.title}: ${cont_response.error}`);
+                    continue;
+                }
+                if (verbose) {
+                    console.log(`Inserted document contributor recordL ${cont_response.row_id}`);
+                }   
+            }
+
+            response.index_success_count++;
+            
+        }
+        response.success = true;
+        console.log(`\nIndex Build Complete:`);
+        console.log(`${response.index_success_count} document index records created.`);
+        return response;
+    };
+})();

package/hdoc-build.js

@@ -1,32 +1,21 @@
 (function () {
     'use strict';
 
-    const {
-        createHash
-    } = require('crypto'),
+    const crypto = require('crypto'),
         dree = require('dree'),
         fs = require('fs-extra'),
         mdfm = require('markdown-it-front-matter'),
         path = require('path'),
-        Database = require('better-sqlite3'),
         URL = require("url").URL,
         validate = require(path.join(__dirname, 'hdoc-validate.js')),
         hdoc = require(path.join(__dirname, 'hdoc-module.js')),
+        hdoc_build_db = require(path.join(__dirname, 'hdoc-build-db.js')),
         hdoc_index = require(path.join(__dirname, 'hdoc-db.js')),
         zipper = require('zip-local');
 
     const h_tags_to_search = ['h1', 'h2', 'h3'],
-        index_cols = [
-            'relative_url UNINDEXED',
-            'book_id',
-            'book_audience UNINDEXED',
-            'book_tags',
-            'doc_title',
-            'doc_content',
-            'doc_preview UNINDEXED',
-            'doc_family_id'
-        ],
-        doc_header_template_path = path.join(__dirname, 'templates', 'doc-header.html');
+        doc_header_template_path = path.join(__dirname, 'templates', 'doc-header.html'),
+        non_git_doc_header_template_path = path.join(__dirname, 'templates', 'doc-header-non-git.html');
 
     let bc = {}, // Breadcrumbs map
         book_read_time = 0,
@@ -35,6 +24,7 @@
         conversion_success = 0,
         conversion_failed = 0,
         doc_header_template = '',
+        doc_header_template_non_git = '',
         doc_id = '',
         git_token = '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', // Github fine-grained personal access token that has minimum read-only access to Hornbill Docs org repo content
         hdocbook_config = {},
@@ -47,16 +37,15 @@
         static_html_files = [],
         work_path_content = '';
 
-    const transform_static_html = function (file_path) {
+    const transform_static_html = async function (file_path) {
         if (fs.existsSync(file_path.path)) {
             // Load HTML file
             let html_txt = fs.readFileSync(file_path.path, 'utf8');
             html_txt = html_txt.replace(/\r/gm, ''); // Remove CR's so we're just dealing with newlines
 
-            let html_txt_updated = false;
-
             let fm_headers = [];
             let existing_fm_headers = false;
+            let doc_type = 'Article';
 
             // Check if we have a frontmatter comment
             const fm_header = hdoc.getHTMLFrontmatterHeader(html_txt);
@@ -85,10 +74,13 @@
 
                 for (const key in fm_header.fm_properties) {
                     if (fm_header.fm_properties.hasOwnProperty(key)) {
-                        fm_headers.push({
-                            id: key,
-                            value: fm_header.fm_properties[key]
-                        });
+                        if (key === 'type') doc_type = fm_header.fm_properties[key];
+                        else {
+                            fm_headers.push({
+                                id: key,
+                                value: fm_header.fm_properties[key]
+                            });
+                        }
                     }
                 }
 
@@ -133,36 +125,93 @@
                 });
             }
 
+            // Add doc type
+            fm_headers.push({
+                id: 'type',
+                value: doc_type
+            });
+
+            let metadata = {};
+
+            // Get contributor data from Github, if exists
+            let contribs = [];
+            if (hdocbook_config.publicSource && hdocbook_config.publicSource !== '' && hdocbook_config.publicSource.includes('github.com/Hornbill-Docs')) {
+                // Remove the first <h1>title</h1> from the HTML as we'll add that in the document header
+                html_txt = html_txt.replace(/(<h1.*?>)\s*.*\s*(.*<\/h1>)/, '');
+
+                const github_paths = hdoc.get_github_api_path(hdocbook_config.publicSource, file_path.relativePath);
+                const contributors = hdoc.get_github_contributors(github_paths.api_path, git_token);
+
+                if (!contributors.success) {
+                    console.log(`Error retrieving contributors from Github: ${contributors.error}`);
+                } else {
+                    metadata.last_commit = contributors.last_commit_date;
+                    metadata.contributor_count = contributors.contributor_count;
+                    metadata.edit_url = github_paths.edit_path;
+                    contribs = contributors.contributors;
+                    contributors.editPath = github_paths.edit_path;
+                    fm_headers.push({
+                        id: 'contributor-count',
+                        value: contributors.contributor_count
+                    });
+                    fm_headers.push({
+                        id: 'last-commit',
+                        value: contributors.last_commit_date
+                    });
+                    const target_file = file_path.path.replace(path.extname(file_path.path), '._info.json');
+                    delete contributors.success;
+                    delete contributors.error;
+                    contributors.editPath = github_paths.edit_path;
+                    try {
+                        fs.writeFileSync(target_file, JSON.stringify(contributors, null, 2));
+                    } catch (err) {
+                        console.log('Error writing:', target_file, '\n', err);
+                    }
+                }
+                fm_headers.push({
+                    id: 'edit-path',
+                    value: github_paths.edit_path
+                });
+            }
+
+            let fm_header_content = '<!--[[FRONTMATTER\n';
             if (fm_headers.length > 0) {
-                let fm_headers_content = '[[FRONTMATTER\n';
                 for (let i = 0; i < fm_headers.length; i++) {
-                    fm_headers_content += `${fm_headers[i].id}: ${fm_headers[i].value}\n`;
+                    fm_header_content += `${fm_headers[i].id}: ${fm_headers[i].value}\n`;
                 }
-                fm_headers_content += ']]';
+                fm_header_content += ']]-->';
 
                 if (existing_fm_headers) {
-                    html_txt = html_txt.replace(fm_header.fm_header, fm_headers_content);
-                    html_txt_updated = true;
-                } else {
-                    html_txt = `<!--${fm_headers_content}-->\n${html_txt}`;
-                    html_txt_updated = true;
+                    html_txt = html_txt.replace('<!--' + fm_header.fm_header + '-->', '');
                 }
             }
 
+            let doc_header = '';
+            if (hdocbook_config.publicSource.includes('github.com/Hornbill-Docs')) {
+                // Build doc header from template and frontmatter tags
+                doc_header = process_doc_header(fm_headers, file_path.relativePath, doc_header_template);
+            } else {
+                doc_header = process_doc_header(fm_headers, file_path.relativePath, doc_header_template_non_git);
+            }
+
+            html_txt = `${fm_header_content}\n${doc_header}\n${html_txt}`;
+
             index_records.push({
                 relative_path: file_path.relativePath,
-                index_html: hdoc_index.transform_html_for_index(html_txt)
+                index_html: hdoc_index.transform_html_for_index(html_txt),
+                metadata: metadata,
+                contributors: contribs
             });
-            if (html_txt_updated) {
-                // Save HTML into HTML file
-                fs.writeFile(file_path.path, html_txt, function writeJSON(err) {
-                    if (err) return console.log('Error writing:', target_file, '\n', err);
-                });
+            // Save HTML into HTML file
+            try {
+                fs.writeFileSync(file_path.path, html_txt);
+            } catch (err) {
+                console.log('Error writing:', target_file, '\n', err);
             }
         }
     };
 
-    const transform_markdown_and_save_html = function (file_path) {
+    const transform_markdown_and_save_html = async function (file_path) {
         conversion_attempted++;
         if (fs.existsSync(file_path.path)) {
             // Load markdown file
@@ -226,7 +275,6 @@
                             doc_title = fm_property[1].trim();
                         }
                         if (fm_property[0].trim() === 'type') {
-                            fm_contains_type = true;
                             doc_type = fm_property[1].trim();
                         }
                         if (fm_property[0].trim() === 'reading-time') {
@@ -270,8 +318,10 @@
                     value: read_time_mins
                 });
             }
+            let metadata = {};
 
             // Get contributor data from Github, if exists
+            let contribs = [];
             if (hdocbook_config.publicSource && hdocbook_config.publicSource !== '' && hdocbook_config.publicSource.includes('github.com/Hornbill-Docs')) {
                 // Remove the first <h1>title</h1> from the HTML as we'll add that in the document header
                 html_txt = html_txt.replace(/(<h1.*?>)\s*.*\s*(.*<\/h1>)/, '');
@@ -282,6 +332,12 @@
                 if (!contributors.success) {
                     console.log(`Error retrieving contributors from Github: ${contributors.error}`);
                 } else {
+                    metadata.last_commit = contributors.last_commit_date;
+                    metadata.contributor_count = contributors.contributor_count;
+                    metadata.edit_url = github_paths.edit_path;
+                    contribs = contributors.contributors;
+                    contributors.editPath = github_paths.edit_path;
+
                     fm_headers.push({
                         id: 'contributor-count',
                         value: contributors.contributor_count
@@ -290,25 +346,23 @@
                         id: 'last-commit',
                         value: contributors.last_commit_date
                     });
+                    const target_file = file_path.path.replace(path.extname(file_path.path), '._info.json');
+                    delete contributors.success;
+                    delete contributors.error;
+                    contributors.editPath = github_paths.edit_path;
+                    try {
+                        fs.writeFileSync(target_file, JSON.stringify(contributors, null, 2));
+                    } catch (err) {
+                        console.log('Error writing:', target_file, '\n', err);
+                    }
                 }
                 fm_headers.push({
                     id: 'edit-path',
                     value: github_paths.edit_path
                 });
-                const target_file = file_path.path.replace(path.extname(file_path.path), '._info.json');
-                delete contributors.success;
-                delete contributors.error;
-                contributors.editPath = github_paths.edit_path;
-                try {
-                    fs.writeFileSync(target_file, JSON.stringify(contributors, null, 2));
-                } catch (err) {
-                    console.log('Error writing:', target_file, '\n', err);
-                }
             }
 
-            
-            // Add frontmatter tags as comment to front of HTML
-            
+            // Add frontmatter tags as comment
             let fm_header = '<!--[[FRONTMATTER\n';
             if (fm_headers.length > 0) {
                 for (let i = 0; i < fm_headers.length; i++) {
@@ -316,29 +370,37 @@
                 }
             }
             fm_header += ']]-->';
-            
+
+            let doc_header = '';
             if (hdocbook_config.publicSource.includes('github.com/Hornbill-Docs')) {
                 // Build doc header from template and frontmatter tags
-                const doc_header = process_doc_header(fm_headers, file_path.relativePath);
-                html_txt = `${fm_header}\n${doc_header}\n${html_txt}`;
+                doc_header = process_doc_header(fm_headers, file_path.relativePath, doc_header_template);
             } else {
-                html_txt = `${fm_header}\n${html_txt}`;
+                // Build doc header from template and frontmatter tags
+                doc_header = process_doc_header(fm_headers, file_path.relativePath, doc_header_template_non_git);
             }
-
-            
+            /*
+            const pdf_html = `${fm_header}\n${doc_header}\n${html_txt}`;
+            const pdf_file = file_path.path.replace(path.extname(file_path.path), '.pdf');
+            */
+            html_txt = `${fm_header}\n${doc_header}\n${html_txt}`;
 
             // Save HTML into HTML file
             const target_file = file_path.path.replace(path.extname(file_path.path), '.html');
             const relative_path = file_path.relativePath.replace(path.extname(file_path.path), '.html');
-            fs.writeFile(target_file, html_txt, function writeJSON(err) {
-                if (err) return console.log('Error writing:', target_file, '\n', err);
-            });
+            try {
+                fs.writeFileSync(target_file, html_txt);
+            } catch (err) {
+                console.log('Error writing:', target_file, '\n', err);
+            }
 
             const index_details = hdoc_index.transform_html_for_index(html_txt);
 
             index_records.push({
                 relative_path: relative_path,
-                index_html: index_details
+                index_html: index_details,
+                metadata: metadata,
+                contributors: contribs
             });
 
             // Delete MD file from _work path
@@ -355,8 +417,8 @@
         return false;
     };
 
-    const process_doc_header = function (fm_headers, doc_path) {
-        let wip_doc_header = doc_header_template;
+    const process_doc_header = function (fm_headers, doc_path, template) {
+        let wip_doc_header = template;
 
         // Process fm_headers properties first
         for (let i = 0; i < fm_headers.length; i++) {
@@ -430,10 +492,7 @@
 
     const md5DreeOptions = {
         hash: true,
-        hashAlgorithm: 'md5',
-        hashEncoding: 'hex',
         normalize: true,
-        size: true,
         sorted: true
     };
 
@@ -507,6 +566,10 @@
                                 for (let d = 0; d < nav_c.items.length; d++) {
                                     const nav_d = nav_c.items[d];
                                     if (nav_d.link) {
+                                        if (nav_d.link.includes('\\')) {
+                                            console.log(`Navigation items should not contain backslashes: ${nav_d.link}`);
+                                            process.exit(1);
+                                        }
                                         if (bc[nav_c.link]) {
                                             bc[nav_d.link] = bc[nav_c.link];
                                         } else {
@@ -529,7 +592,7 @@
                                         });
                                     }
                                 }
-        
+
                             }
                         }
                     }
@@ -540,11 +603,11 @@
         //console.log(JSON.stringify(bc, null, 2));
     };
 
-    exports.run = function (source_path, verbose, github_api_token) {
+    exports.run = async function (source_path, verbose, github_api_token) {
         if (github_api_token !== '') {
             git_token = github_api_token;
         }
-            
+
         // GERRY: The purpose of this function is to create a zip file containing the hdocbook content, 
         // * Create a _work folder 
         // * copy the hdocbook content to the work folder
@@ -591,9 +654,10 @@
             process.exit(1);
         }
 
-        // Load document header template
+        // Load document header templates
         try {
             doc_header_template = fs.readFileSync(doc_header_template_path, 'utf8');
+            doc_header_template_non_git = fs.readFileSync(non_git_doc_header_template_path, 'utf8');
         } catch (err) {
             console.log(`Error reading document header template: ${err}`);
             process.exit(1);
@@ -605,15 +669,16 @@
         dree.scan(work_path, dreeOptions, build_file_callback);
 
         // Work through MD files and convert to HTML
-        md_files.forEach(function (md_file) {
-            transform_markdown_and_save_html(md_file);
-        });
-
+        for (let i = 0; i < md_files.length; i++) {
+            await transform_markdown_and_save_html(md_files[i]);
+        }
+        
         // Work through Static HTML files and add Frontmatter tags
-        static_html_files.forEach(function (static_html_file) {
-            transform_static_html(static_html_file);
-        });
+        for (let i = 0; i < static_html_files.length; i++) {
+            await transform_static_html(static_html_files[i]);
+        }
 
+        // Output to console
         console.log(`                MD files found: ${conversion_attempted}`);
         console.log(`Successfully converted to HTML: ${conversion_success}`);
         console.log(`             Failed to convert: ${conversion_failed}\n`);
@@ -628,47 +693,18 @@
             process.exit(1);
         }
 
-        // Now build the index
-        console.log('Performing SQlite index creation...');
-        let db_name = path.join(work_path, doc_id, 'index.db');
-        const db = new Database(db_name);
-        db.pragma('encoding="UTF-8"');
-        console.log(`\nDatabase created: ${db_name}`);
-
-        // Now add the table
-        const table_name = 'hdoc_index';
-        const table_created = hdoc_index.create_virtual_table(db, table_name, index_cols);
+        // Build the index
+        // Create the DB and tables
+        let db = hdoc_build_db.create_db(work_path, doc_id);
+        if (db.error && db.error !== null) {
+            console.log(db.error);
+            process.exit(1);
+        }
 
-        if (table_created !== null) {
-            console.log(`\nError creating table: ${table_created}`);
-        } else {
-            console.log(`\nVirtual table created: ${table_name}`);
-            if (!hdocbook_config.tags) hdocbook_config.tags = [];
-            let index_success_count = 0;
-            for (let i = 0; i < index_records.length; i++) {
-                let index_path_name = index_records[i].relative_path.replace('\\', '/').replace(`${doc_id}/`, '');
-                index_path_name = index_path_name.replace(path.extname(index_records[i].relative_path), '');
-                const index_vals = [
-                    index_path_name,
-                    doc_id,
-                    hdocbook_config.audience.join(','),
-                    hdocbook_config.tags.join(','),
-                    index_records[i].index_html.fm_props.title,
-                    index_records[i].index_html.text,
-                    index_records[i].index_html.preview,
-                    hdocbook_config.productFamily
-                ];
-                const index_response = hdoc_index.insert_record(db, table_name, index_cols, index_vals, doc_id, index_records[i].index_html.fm_props.title);
-                if (!index_response.success) {
-                    console.log(`Index record creation failed - ${doc_id}/${index_records[i].index_html.fm_props.title}: ${index_response.error}`);
-                    continue;
-                }
-                index_success_count++;
-                if (verbose) {
-                    console.log(`Inserted index record ${index_response.row_id}: ${doc_id} - ${index_records[i].index_html.fm_props.title}`);
-                }
-            }
-            console.log(`\nIndex Build Complete: ${index_success_count} records created.`);
+        const index = hdoc_build_db.populate_index(db.db, doc_id, hdocbook_config, index_records, verbose);
+        if (!index.success) {
+            console.log(index.error);
+            process.exit(1);
         }
 
         // Now create MD5 hash of built content
@@ -682,7 +718,7 @@
             process.exit(1);
         }
 
-        const hash = createHash("md5").update(concat_hash).digest("hex");
+        const hash = crypto.createHash("md5").update(concat_hash).digest("hex");
         const checksum_path = path.join(work_path_content, 'checksum.md5');
         try {
             fs.writeFileSync(checksum_path, hash);

package/hdoc-db.js

@@ -5,9 +5,13 @@
         path = require('path'),
         hdoc = require(path.join(__dirname, 'hdoc-module.js'));
 
-    exports.create_virtual_table = function (db, table_name, columns) {
-        let create_sql = [];
-        create_sql.push(`create VIRTUAL table ${table_name} USING fts5(`);
+    exports.create_table = function (db, table_name, columns, virtual, fts5) {
+        let create_sql = ['CREATE'];
+        if (virtual) create_sql.push('VIRTUAL');
+        create_sql.push('TABLE');
+        create_sql.push(table_name);
+        if (fts5) create_sql.push('USING fts5(');
+        else create_sql.push('(');
         for (let i = 0; i < columns.length; i++) {
             if (i !== 0) create_sql.push(`,${columns[i]}`);
             else create_sql.push(columns[i]);
@@ -21,7 +25,7 @@
         }
     };
 
-    exports.insert_record = function (db, table, columns, values, book_id, doc_title) {
+    exports.insert_record = function (db, table, columns, values) {
         let response = {
             success: false,
             row_id: 0,
@@ -33,11 +37,11 @@
         let vals = 'VALUES (';
         for (let i = 0; i < columns.length; i++) {
             if (i === 0) {
-                cols += `${columns[i].replace('UNINDEXED', '').trim()}`;
+                cols += `${columns[i].replace('UNINDEXED', '').replace('INTEGER', '').trim()}`;
                 vals += '?';
             } else {
-                cols += `,${columns[i].replace('UNINDEXED', '').trim()}`;
-                vals += ',?';
+                cols += `, ${columns[i].replace('UNINDEXED', '').replace('INTEGER', '').trim()}`;
+                vals += ', ?';
             }
         }
         cols += ')';
@@ -46,7 +50,7 @@
         queryProps.push(vals);
 
         try {
-            const stmt = db.prepare(queryProps.join('\n'));
+            const stmt = db.prepare(queryProps.join(' '));
             const info = stmt.run(values);
             response.row_id = info.lastInsertRowid;
             response.success = true;

package/hdoc-validate.js

@@ -12,6 +12,7 @@ const parseLinkDestination = require('markdown-it/lib/helpers/parse_link_destina
 
     let errors = {},
         messages = {},
+        warnings = {},
         errorcount = 0,
         filecount = 0,
         htmlFiles = [];
@@ -58,11 +59,11 @@ const parseLinkDestination = require('markdown-it/lib/helpers/parse_link_destina
 
         // Replace /_books/ with /
         file_path = file_path.replace(path.sep + '_books' + path.sep, path.sep);
-        if (!fs.existsSync(file_path) && !fs.existsSync(file_path + '.htm') && !fs.existsSync(file_path + '.html')) {
-            errors[html_path.relativePath].push(`Book resource does not exist: ${file_path}`);
+        if (!fs.existsSync(file_path) && !fs.existsSync(file_path + path.sep + 'index.htm') && !fs.existsSync(file_path + 'index.html') && !fs.existsSync(file_path + '.htm') && !fs.existsSync(file_path + '.html')) {
+            errors[html_path.relativePath].push(`Book resource does not exist: ${relative_path}`);
             return false;
         } else {
-            messages[html_path.relativePath].push(`Book resource exists: ${file_path}`);
+            messages[html_path.relativePath].push(`Book resource exists: ${relative_path}`);
         }
         return true;
     };
@@ -96,6 +97,7 @@ const parseLinkDestination = require('markdown-it/lib/helpers/parse_link_destina
             // Initiate maps for errors and verbose messages for HTML file
             errors[htmlFiles[i].relativePath] = [];
             messages[htmlFiles[i].relativePath] = [];
+            warnings[htmlFiles[i].relativePath] = [];
 
             const links = getLinks(htmlFiles[i]);
             if (links.length === 0) {

package/hdoc.js

@@ -1,6 +1,6 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 
-(function () {
+(async function () {
    'use strict';
 
    const preRun = require('./validateNodeVer.js'),
@@ -71,7 +71,7 @@
       server.run(ui_path, source_path);
    } else if (command == 'build') {
       const builder = require(path.join(__dirname, 'hdoc-build.js'));
-      builder.run(source_path, verbose, git_token);
+      await builder.run(source_path, verbose, git_token);
    } else if (command == 'stats') {
       const stats = require(path.join(__dirname, 'hdoc-stats.js'));
       stats.run(ui_path, source_path, verbose);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hdoc-tools",
-  "version": "0.8.21",
+  "version": "0.8.23",
   "description": "Hornbill HDocBook Development Support Tool",
   "main": "hdoc.js",
   "bin": {
@@ -10,6 +10,7 @@
     "hdoc.js",
     "hdoc-db.js",
     "hdoc-build.js",
+    "hdoc-build-db.js",
     "hdoc-help.js",
     "hdoc-init.js",
     "hdoc-module.js",
@@ -38,10 +39,12 @@
     "highlight.js": "^11.6.0",
     "html-to-text": "^8.2.1",
     "js-yaml": "^4.1.0",
+    "jspdf": "^2.5.1",
     "markdown-it": "^13.0.1",
     "markdown-it-container": "^3.0.0",
     "markdown-it-front-matter": "^0.2.3",
     "multer": "^1.4.5-lts.1",
+    "pdf-creator-node": "^2.3.5",
     "prompt": "^1.3.0",
     "stream": "0.0.2",
     "sync-request": "^6.1.0",

package/templates/doc-header-non-git.html

@@ -0,0 +1,23 @@
+<div class="document-header">
+    <div class="hb-container-horizontal">
+        <div class="hb-center-v hb-container-expand">
+            <ul class="ps-0 nav-bar-nav-list noeffects after-fslash overflow-ellipsis">{{breadcrumbs}}</ul>
+        </div> 
+        <div class="toolbar-right hb-center-v">
+            <a class="toolbar-action documentation-menu-popper">
+                <i class="bi bi-three-dots-vertical"></i>
+            </a>
+        </div>
+    </div> 
+    
+    <h1>{{title}}</h1>
+    
+    <div class="hb-container-horizontal">
+        <div class="hb-center-v hb-container-expand">
+            <ul class="ps-0 nav-bar-nav-list noeffects after-bullets overflow-ellipsis text-light-2">
+                <li class="ps-0 mt-0 nav-bar-item">{{doc-type}}</li>
+                <li class="ps-0 mt-0 nav-bar-item">{{reading-time}} minutes to read</li> 
+            </ul>
+        </div> 
+    </div>
+</div>