@cyberismo/data-handler 0.0.7 → 0.0.9

package/src/commands/edit.ts

@@ -16,18 +16,23 @@ import { homedir } from 'node:os';
 import { spawnSync } from 'node:child_process';
 
 import { ActionGuard } from '../permissions/action-guard.js';
-import type { Calculate } from './index.js';
-import type { MetadataContent } from '../interfaces/project-interfaces.js';
+import type {
+  MetadataContent,
+  ResourceFolderType,
+} from '../interfaces/project-interfaces.js';
 import { Project } from '../containers/project.js';
 import { UserPreferences } from '../utils/user-preferences.js';
+import {
+  type ResourceName,
+  resourceNameToString,
+} from '../utils/resource-utils.js';
+import { FolderResource } from '../resources/folder-resource.js';
 
 export class Edit {
   private project: Project;
-  private calculateCmd: Calculate;
 
-  constructor(project: Project, calculateCmd: Calculate) {
+  constructor(project: Project) {
     this.project = project;
-    this.calculateCmd = calculateCmd;
   }
 
   /**
@@ -83,13 +88,16 @@ export class Edit {
    * @param changedContent New content for the card.
    */
   public async editCardContent(cardKey: string, changedContent: string) {
-    // Determine the card path
+    const isTemplateCard = await this.project.isTemplateCard(cardKey);
+    if (isTemplateCard) {
+      return this.project.updateCardContent(cardKey, changedContent);
+    }
     const cardPath = this.project.pathToCard(cardKey);
     if (!cardPath) {
       throw new Error(`Card '${cardKey}' does not exist in the project`);
     }
 
-    const actionGuard = new ActionGuard(this.calculateCmd);
+    const actionGuard = new ActionGuard(this.project.calculationEngine);
     await actionGuard.checkPermission('editContent', cardKey);
 
     await this.project.updateCardContent(cardKey, changedContent);
@@ -106,18 +114,52 @@ export class Edit {
     changedKey: string,
     newValue: MetadataContent,
   ) {
+    if (!changedKey) {
+      throw new Error(`Changed key cannot be empty`);
+    }
+    const isTemplateCard = await this.project.isTemplateCard(cardKey);
+    if (isTemplateCard) {
+      return this.project.updateCardMetadataKey(cardKey, changedKey, newValue);
+    }
+
     // Determine the card path
     const cardPath = this.project.pathToCard(cardKey);
     if (!cardPath) {
       throw new Error(`Card '${cardKey}' does not exist in the project`);
     }
-    if (!changedKey) {
-      throw new Error(`Changed key cannot be empty`);
-    }
 
     // check for editing rights
-    const actionGuard = new ActionGuard(this.calculateCmd);
+    const actionGuard = new ActionGuard(this.project.calculationEngine);
     await actionGuard.checkPermission('editField', cardKey, changedKey);
     await this.project.updateCardMetadataKey(cardKey, changedKey, newValue);
   }
+
+  /**
+   * Update a file of a folder resource. Cannot be used to create a new file.
+   * @param resourceName The name of the resource to update.
+   * @param fileName The name of the file to update.
+   * @param changedContent The new content for the file.
+   */
+  public async editResourceContent(
+    resourceName: ResourceName,
+    fileName: string,
+    changedContent: string,
+  ) {
+    const resourceNameStr = resourceNameToString(resourceName);
+    if (
+      !(await this.project.resourceExists(
+        resourceName.type as ResourceFolderType,
+        resourceNameStr,
+      ))
+    ) {
+      throw new Error(
+        `Resource '${resourceNameStr}' does not exist in the project`,
+      );
+    }
+    const resource = Project.resourceObject(this.project, resourceName);
+    if (!(resource instanceof FolderResource)) {
+      throw new Error(`Resource '${resourceNameStr}' is not a folder resource`);
+    }
+    return resource.updateFile(fileName, changedContent);
+  }
 }

package/src/commands/export.ts

@@ -13,27 +13,36 @@
 */
 
 // node
-import { appendFile, copyFile, mkdir, truncate } from 'node:fs/promises';
+import {
+  appendFile,
+  copyFile,
+  mkdir,
+  truncate,
+  writeFile,
+} from 'node:fs/promises';
 import { dirname, join } from 'node:path';
 
-// asciidoctor
-import Processor from '@asciidoctor/core';
-import type { Calculate, Show } from './index.js';
+import { Project } from '../containers/project.js';
+import { sortItems } from '../utils/lexorank.js';
+
 import type {
   Card,
   FetchCardDetails,
 } from '../interfaces/project-interfaces.js';
-import type { CardType } from '../interfaces/resource-interfaces.js';
-import { Project } from '../containers/project.js';
 import type { QueryResult } from '../types/queries.js';
-import { sortItems } from '../utils/lexorank.js';
+import type { CardType } from '../interfaces/resource-interfaces.js';
+import type { Show } from './index.js';
+import { generateReportContent } from '../utils/report.js';
+import { getStaticDirectoryPath, pdfReport } from '@cyberismo/assets';
+import { spawn } from 'node:child_process';
+import { evaluateMacros } from '../macros/index.js';
+import type { ExportPdfOptions } from '../interfaces/project-interfaces.js';
 
 const attachmentFolder: string = 'a';
 
 export class Export {
   constructor(
     protected project: Project,
-    protected calculateCmd: Calculate,
     protected showCmd: Show,
   ) {}
 
@@ -202,11 +211,11 @@ export class Export {
       asciiDocContent = await evaluateMacros(
         cardDetailsResponse.content || '',
         {
+          context: 'exportedDocument',
           mode: 'static',
           project,
           cardKey: card.key,
         },
-        this.calculateCmd,
       );
     } catch (error) {
       asciiDocContent = `Macro error: ${error instanceof Error ? error.message : 'Unknown error'}\n\n${asciiDocContent}`;
@@ -225,6 +234,91 @@ export class Export {
     return card;
   }
 
+  private async runAsciidoctorPdf(content: string): Promise<Buffer> {
+    const staticRootDir = await getStaticDirectoryPath();
+    const proc = spawn(
+      'asciidoctor-pdf',
+      [
+        '-a',
+        'pdf-theme=cyberismo',
+        '-a',
+        `pdf-themesdir=${join(staticRootDir, 'pdf-themes')}`,
+        '-a',
+        `pdf-fontsdir=${join(staticRootDir, 'pdf-themes', 'fonts')};GEM_FONTS_DIR`,
+        '-',
+      ],
+      {
+        timeout: 100000,
+        shell: process.platform === 'win32',
+      },
+    );
+    proc.stdin.end(content);
+    const result = await new Promise<Buffer>((resolve, reject) => {
+      const chunks: Buffer[] = [];
+      proc.stdout.on('data', (chunk) => {
+        chunks.push(chunk);
+      });
+      proc.stderr.on('data', (chunk) => {
+        process.stderr.write(chunk);
+      });
+      proc.on('error', (error) => {
+        if ('code' in error && error.code === 'ENOENT') {
+          reject(
+            new Error(
+              'Asciidoctor-pdf not found. Please install asciidoctor-pdf to use this feature.',
+            ),
+          );
+        }
+        reject(error);
+      });
+      proc.on('close', (code) => {
+        if (code === 0) {
+          resolve(Buffer.concat(chunks));
+        } else {
+          reject(new Error(`Asciidoctor-pdf failed with code ${code}`));
+        }
+      });
+    });
+    return result;
+  }
+
+  /**
+   * Exports the card(s) to pdf.
+   * @param destination Path to where the resulting file(s) will be created.
+   * @param options Export options.
+   * @returns status message
+   */
+  public async exportPdf(
+    destination: string,
+    options: ExportPdfOptions,
+  ): Promise<string> {
+    const opts = {
+      ...options,
+      date: options.date?.toISOString().split('T')[0],
+      recursive: options.recursive ?? false,
+    };
+
+    await this.project.calculationEngine.generate();
+
+    const result = await generateReportContent({
+      calculate: this.project.calculationEngine,
+      contentTemplate: pdfReport.content,
+      queryTemplate: pdfReport.query,
+      context: 'exportedDocument',
+      options: opts,
+    });
+
+    const evaluated = await evaluateMacros(result, {
+      context: 'exportedDocument',
+      mode: 'static',
+      project: this.project,
+      cardKey: '', // top level report does not contain any macros that use cardKey
+    });
+    const pdf = await this.runAsciidoctorPdf(evaluated);
+    await writeFile(destination, pdf);
+    return `Content exported as PDF to ${destination}`;
+  }
+
   /**
    * Exports the card(s) to ascii doc.
    * @param destination Path to where the resulting file(s) will be created.
@@ -254,8 +348,11 @@ export class Export {
       });
     }
 
-    await this.calculateCmd.generate();
-    const tree = await this.calculateCmd.runQuery('tree');
+    await this.project.calculationEngine.generate();
+    const tree = await this.project.calculationEngine.runQuery(
+      'tree',
+      'exportedDocument',
+    );
 
     if (cardKey) {
       const targetCard = this.findCardInTree(tree, cardKey);
@@ -290,27 +387,4 @@ export class Export {
     await this.toAdocFile(resultDocumentPath, cards);
     return message;
   }
-
-  /**
-   * Exports the card(s) to HTML and opens the browser.
-   * @param destination Path to where the resulting file(s) will be created.
-   * @param cardKey Optional; If not exporting the whole card tree, card key of parent card.
-   */
-  public async exportToHTML(
-    destination: string,
-    cardKey?: string,
-  ): Promise<string> {
-    let message = '';
-    await this.exportToADoc(destination, cardKey).then((msg) => {
-      message = msg;
-      const asciiDocProcessor = Processor();
-      const adocFile = join(destination, Project.cardContentFile);
-      asciiDocProcessor.convertFile(adocFile, {
-        safe: 'safe',
-        base_dir: '/',
-        standalone: true,
-      });
-    });
-    return message;
-  }
 }

package/src/commands/import.ts

@@ -134,7 +134,10 @@ export class Import {
     destination?: string,
     options?: ModuleSettingOptions,
   ) {
-    const gitModule = source.startsWith('https');
+    const beforeImportValidateErrors = await Validate.getInstance().validate(
+      this.project.basePath,
+    );
+    const gitModule = source.startsWith('https') || source.startsWith('git@');
     const modulePrefix = gitModule
       ? await this.moduleManager.importGitModule(source, options)
       : await this.moduleManager.importFileModule(source, destination);
@@ -156,7 +159,33 @@ export class Import {
     await this.moduleManager.updateModule(moduleSettings, options?.credentials);
 
     // Add module as a dependency.
-    return this.project.importModule(moduleSettings);
+    await this.project.importModule(moduleSettings);
+
+    // Validate the project after module has been imported
+    const afterImportValidateErrors = await Validate.getInstance().validate(
+      this.project.basePath,
+    );
+    if (afterImportValidateErrors.length > beforeImportValidateErrors.length) {
+      console.error(
+        `There are new validations errors after importing the module. Check the project`,
+      );
+    }
+  }
+
+  /**
+   * Updates a specific imported module.
+   * @param moduleName Name (prefix) of module to update.
+   * @param credentials Optional credentials for a private module.
+   * @throws if module is not part of the project
+   */
+  public async updateModule(moduleName: string, credentials?: Credentials) {
+    const module = this.project.configuration.modules.find(
+      (item) => item.name === moduleName,
+    );
+    if (!module) {
+      throw new Error(`Module '${moduleName}' is not part of the project`);
+    }
+    return this.moduleManager.updateModule(module, credentials);
   }
 
   /**

package/src/commands/move.ts

@@ -1,13 +1,14 @@
 /**
-    Cyberismo
-    Copyright © Cyberismo Ltd and contributors 2024
-
-    This program is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General Public License version 3 as published by the Free Software Foundation.
-
-    This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more details.
-
-    You should have received a copy of the GNU Affero General Public
-    License along with this program.  If not, see <https://www.gnu.org/licenses/>.
+  Cyberismo
+  Copyright © Cyberismo Ltd and contributors 2024
+  This program is free software: you can redistribute it and/or modify it under
+  the terms of the GNU Affero General Public License version 3 as published by
+  the Free Software Foundation.
+  This program is distributed in the hope that it will be useful, but WITHOUT
+  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+  FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
+  details. You should have received a copy of the GNU Affero General Public
+  License along with this program. If not, see <https://www.gnu.org/licenses/>.
 */
 
 // node
@@ -15,7 +16,6 @@ import { join, sep } from 'node:path';
 
 import { ActionGuard } from '../permissions/action-guard.js';
 import { copyDir, deleteDir } from '../utils/file-utils.js';
-import type { Calculate } from './index.js';
 import type {
   Card,
   FetchCardDetails,
@@ -37,10 +37,7 @@ import { TemplateResource } from '../resources/template-resource.js';
 const ROOT: string = 'root';
 
 export class Move {
-  constructor(
-    private project: Project,
-    private calculateCmd: Calculate,
-  ) {}
+  constructor(private project: Project) {}
 
   // Fetches a card (either template or project card).
   private async getCard(cardKey: string, options: FetchCardDetails) {
@@ -192,7 +189,7 @@ export class Move {
     }
 
     // if both are project cards, make sure source card can be moved
-    const actionGuard = new ActionGuard(this.calculateCmd);
+    const actionGuard = new ActionGuard(this.project.calculationEngine);
     await actionGuard.checkPermission('move', source);
 
     // rerank the card in the new location

package/src/commands/remove.ts

@@ -15,8 +15,8 @@
 import { join, sep } from 'node:path';
 
 import { ActionGuard } from '../permissions/action-guard.js';
-import type { Calculate } from './index.js';
 import { deleteDir, deleteFile } from '../utils/file-utils.js';
+import { ModuleManager } from '../module-manager.js';
 import { Project } from '../containers/project.js';
 import type { RemovableResourceTypes } from '../interfaces/project-interfaces.js';
 import { resourceName } from '../utils/resource-utils.js';
@@ -27,10 +27,10 @@ const MODULES_PATH = `${sep}modules${sep}`;
  * Remove command.
  */
 export class Remove {
-  constructor(
-    private project: Project,
-    private calculateCmd: Calculate,
-  ) {}
+  private moduleManager: ModuleManager;
+  constructor(private project: Project) {
+    this.moduleManager = new ModuleManager(this.project);
+  }
 
   // True, if resource is a project resource
   private projectResource(type: RemovableResourceTypes): boolean {
@@ -83,7 +83,7 @@ export class Remove {
 
     // Make sure card can be removed if it's a project card
     if (!(await this.project.isTemplateCard(cardKey))) {
-      const actionGuard = new ActionGuard(this.calculateCmd);
+      const actionGuard = new ActionGuard(this.project.calculationEngine);
       await actionGuard.checkPermission('delete', cardKey);
     }
 
@@ -111,10 +111,10 @@ export class Remove {
       content: false,
       parent: false,
     });
+    await deleteDir(cardFolder);
     if (card) {
-      await this.calculateCmd.handleDeleteCard(card);
+      await this.project.handleDeleteCard(card);
     }
-    await deleteDir(cardFolder);
   }
 
   // removes label from project
@@ -182,16 +182,6 @@ export class Remove {
     await this.project.updateCardMetadataKey(sourceCardKey, 'links', newLinks);
   }
 
-  // Removes modules from project
-  private async removeModule(moduleName: string) {
-    const module = await this.project.module(moduleName);
-    if (!module) {
-      throw new Error(`Module '${moduleName}' not found`);
-    }
-    await this.project.removeModule(moduleName);
-    await deleteDir(module.path);
-  }
-
   /**
    * Removes either attachment, card, imported module, link or resource from project.
    * @param type Type of resource
@@ -236,7 +226,8 @@ export class Remove {
       else if (type == 'card') return this.removeCard(targetName);
       else if (type == 'link')
         return this.removeLink(targetName, rest[0], rest[1], rest.at(2));
-      else if (type == 'module') return this.removeModule(targetName);
+      else if (type == 'module')
+        return this.moduleManager.removeModule(targetName);
       else if (type == 'label') return this.removeLabel(targetName, rest[0]);
     }
     throw new Error(`Unknown resource type '${type}'`);

package/src/commands/rename.ts

@@ -16,7 +16,6 @@ import { assert } from 'node:console';
 import { join } from 'node:path';
 import { rename, readdir, readFile, writeFile } from 'node:fs/promises';
 
-import type { Calculate } from './index.js';
 import type { Card } from '../interfaces/project-interfaces.js';
 import { isTemplateCard } from '../utils/card-utils.js';
 import { type Project, ResourcesFrom } from '../containers/project.js';
@@ -41,10 +40,7 @@ export class Rename {
   private from: string = '';
   private to: string = '';
 
-  constructor(
-    private project: Project,
-    private calculateCmd: Calculate,
-  ) {}
+  constructor(private project: Project) {}
 
   // Renames a card and all of its attachments (if it is a project card).
   private async renameCard(re: RegExp, card: Card): Promise<void> {
@@ -110,12 +106,7 @@ export class Rename {
             join(attachment.path, attachment.fileName),
             join(attachment.path, newAttachmentFileName),
           );
-
-          const attachmentRe = new RegExp(`image::${attachment.fileName}`, 'g');
-          card.content = card.content?.replace(
-            attachmentRe,
-            `image::${newAttachmentFileName}`,
-          );
+          // NOTE: content is renamed by updateFiles method
         }),
       );
     }
@@ -373,6 +364,6 @@ export class Rename {
     this.project.collectLocalResources();
     console.info('Collected renamed resources');
 
-    return this.calculateCmd.generate();
+    return this.project.calculationEngine.generate();
   }
 }