@cyberismo/data-handler 0.0.13 → 0.0.15

package/src/commands/create.ts

@@ -12,29 +12,25 @@
 */
 
 // node
-import { basename, join, resolve, sep } from 'node:path';
-import {
-  constants as fsConstants,
-  copyFile,
-  mkdir,
-  writeFile,
-} from 'node:fs/promises';
-
-import { errorFunction } from '../utils/log-utils.js';
+import { join, resolve } from 'node:path';
+import { mkdir, writeFile } from 'node:fs/promises';
+
+import { errorFunction } from '../utils/error-utils.js';
 import { Project } from '../containers/project.js';
 import { Validate } from './index.js';
 
 import { EMPTY_RANK, sortItems } from '../utils/lexorank.js';
+import { isModulePath } from '../utils/card-utils.js';
 import type {
   DataType,
   Link,
   LinkType,
 } from '../interfaces/resource-interfaces.js';
-import { pathExists } from '../utils/file-utils.js';
 import type { Card, ProjectFile } from '../interfaces/project-interfaces.js';
 import { resourceName, resourceNameToString } from '../utils/resource-utils.js';
 import { writeJsonFile } from '../utils/json.js';
 
+import { CalculationResource } from '../resources/calculation-resource.js';
 import { CardTypeResource } from '../resources/card-type-resource.js';
 import { FieldTypeResource } from '../resources/field-type-resource.js';
 import { GraphModelResource } from '../resources/graph-model-resource.js';
@@ -44,8 +40,6 @@ import { ReportResource } from '../resources/report-resource.js';
 import { TemplateResource } from '../resources/template-resource.js';
 import { WorkflowResource } from '../resources/workflow-resource.js';
 
-const MODULES_PATH = `${sep}modules${sep}`;
-
 // todo: Is there a easy to way to make JSON schema into a TypeScript interface/type?
 //       Check this out: https://www.npmjs.com/package/json-schema-to-ts
 
@@ -113,24 +107,14 @@ export class Create {
     if (cardTypeName === undefined) {
       throw new Error(`Input validation error: card type cannot be empty`);
     }
-    // Use slice to get a copy of a string.
-    const origTemplateName = templateName.slice(0);
     const templateResource = new TemplateResource(
       this.project,
       resourceName(templateName),
     );
     const templateObject = templateResource.templateObject();
+    const specificCard = card ? templateObject.findCard(card) : undefined;
 
-    const specificCard = card
-      ? await templateObject.findSpecificCard(card)
-      : undefined;
-    if (card && !specificCard) {
-      throw new Error(
-        `Card '${card}' was not found from template '${origTemplateName}'`,
-      );
-    }
-
-    if (templateObject.templateFolder().includes(`${sep}modules${sep}`)) {
+    if (isModulePath(templateObject.templateFolder())) {
       throw new Error(`Cannot add cards to imported module templates`);
     }
 
@@ -181,66 +165,27 @@ export class Create {
     attachment: string,
     buffer?: Buffer,
   ) {
-    if (!buffer && !pathExists(attachment)) {
-      throw new Error(
-        `Input validation error: cannot find attachment '${attachment}'`,
-      );
-    }
-    const attachmentFolder = await this.project.cardAttachmentFolder(cardKey);
-
-    // Imported templates cannot be modified.
-    // @todo: make MODULES_PATH project level constant
-    if (attachmentFolder.includes(MODULES_PATH)) {
-      throw new Error(`Cannot modify imported module`);
-    }
-
     try {
-      await mkdir(attachmentFolder, { recursive: true }).then(async () => {
-        if (!buffer) {
-          return copyFile(
-            attachment,
-            join(attachmentFolder, basename(attachment)),
-            fsConstants.COPYFILE_EXCL,
-          );
-        }
-        return writeFile(join(attachmentFolder, basename(attachment)), buffer, {
-          flag: 'wx',
-        });
-      });
+      await this.project.createCardAttachment(
+        cardKey,
+        attachment,
+        buffer || attachment,
+      );
     } catch (error) {
       throw new Error(errorFunction(error));
     }
   }
 
   /**
-   * Creates a calculation file.
-   * @param fileName name for the calculation file (without .lp extension)
+   * Creates a calculation resource.
+   * @param calculationName name for the calculation resource
    */
-  public async createCalculation(fileName: string) {
-    const calculationFolder = this.project.paths.calculationProjectFolder;
-
-    await mkdir(calculationFolder, { recursive: true });
-
-    const calculationFileName = fileName.endsWith('.lp')
-      ? fileName
-      : `${fileName}.lp`;
-    const calculationFilePath = join(calculationFolder, calculationFileName);
-
-    const calculationContent = `% Calculation file: ${calculationFileName}
-% Add your logic programming rules here
-`;
-
-    await writeFile(calculationFilePath, calculationContent, { flag: 'wx' });
-
-    // add to cache manually
-    // TODO: remove once calculations are a proper resource
-    const resourceName = `${this.project.projectPrefix}/calculations/${fileName.replace('.lp', '')}`;
-    const resource = {
-      name: resourceName,
-      path: calculationFolder,
-    };
-
-    this.project.addResource(resource, {} as JSON);
+  public async createCalculation(calculationName: string) {
+    const calculation = new CalculationResource(
+      this.project,
+      resourceName(calculationName),
+    );
+    await calculation.create();
   }
 
   /**
@@ -258,7 +203,7 @@ export class Create {
       resourceName(templateName),
     );
 
-    await Validate.getInstance().validResourceName(
+    Validate.getInstance().validResourceName(
       'templates',
       resourceNameToString(resourceName(templateName)),
       await this.project.projectPrefixes(),
@@ -267,15 +212,8 @@ export class Create {
     await templateResource.validate();
 
     const specificCard = parentCardKey
-      ? await this.project.findSpecificCard(parentCardKey, {
-          metadata: true,
-          children: true,
-        })
+      ? this.project.findCard(parentCardKey)
       : undefined;
-    if (parentCardKey && !specificCard) {
-      throw new Error(`Card '${parentCardKey}' not found from project`);
-    }
-
     const templateObject = templateResource.templateObject();
     if (!templateObject || !templateObject.isCreated()) {
       throw new Error(`Template '${templateName}' not found from project`);
@@ -283,7 +221,6 @@ export class Create {
 
     const createdCards = await templateObject.createCards(specificCard);
     if (createdCards.length > 0) {
-      await this.project.handleNewCards(createdCards);
       // Note: This assumes that parent keys will be ahead of 'a' in the sort order.
       const sorted = sortItems(createdCards, (item) => {
         return `${item.parent === 'root' ? 'a' : item.parent}${item.metadata?.rank || EMPTY_RANK}`;
@@ -354,13 +291,8 @@ export class Create {
       throw new Error(`Not a valid label name'`);
     }
 
-    const card = await this.project.findSpecificCard(cardKey, {
-      metadata: true,
-    });
-    if (!card) {
-      throw new Error(`Card '${cardKey}' does not exist in the project`);
-    }
-    const labels = card.metadata?.labels ?? [];
+    const card = this.project.findCard(cardKey);
+    const labels = structuredClone(card.metadata?.labels) ?? [];
 
     if (labels.includes(label)) {
       throw new Error('Label already exists');
@@ -400,26 +332,10 @@ export class Create {
     }
 
     // Determine the card path
-    const card = await this.project.findSpecificCard(cardKey, {
-      metadata: true,
-    });
-    if (!card) {
-      throw new Error(`Card '${cardKey}' does not exist in the project`);
-    }
-
-    const destinationCard = await this.project.findSpecificCard(
-      destinationCardKey,
-      {
-        metadata: true,
-      },
-    );
-    if (!destinationCard) {
-      throw new Error(
-        `Card '${destinationCardKey}' does not exist in the project`,
-      );
-    }
+    const card = this.project.findCard(cardKey);
+    const destinationCard = this.project.findCard(destinationCardKey);
     // make sure the link type exists
-    const linkTypeObject = await this.project.resource<LinkType>(linkType);
+    const linkTypeObject = this.project.resource<LinkType>(linkType);
     if (!linkTypeObject) {
       throw new Error(`Link type '${linkType}' does not exist in the project`);
     }

package/src/commands/edit.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
@@ -16,18 +17,10 @@ import { homedir } from 'node:os';
 import { spawnSync } from 'node:child_process';
 
 import { ActionGuard } from '../permissions/action-guard.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';
-import { writeFile } from 'node:fs/promises';
+
+import type { MetadataContent } from '../interfaces/project-interfaces.js';
 
 export class Edit {
   private project: Project;
@@ -36,54 +29,12 @@ export class Edit {
     this.project = project;
   }
 
-  /**
-   * Updates a calculation file.
-   * @param resourceName The name of the resource to update.
-   * @param changedContent The new content for the calculation.
-   */
-  public async editCalculation(
-    resourceName: ResourceName,
-    changedContent: string,
-  ) {
-    if (resourceName.prefix !== this.project.projectPrefix) {
-      throw new Error(
-        `Resource '${resourceName.identifier}' is not a local resource`,
-      );
-    }
-    const resourceNameString = resourceNameToString(resourceName);
-    if (
-      !(await this.project.resourceExists(
-        resourceName.type as ResourceFolderType,
-        resourceNameString,
-      ))
-    ) {
-      throw new Error(
-        `Resource '${resourceNameString}' does not exist in the project`,
-      );
-    }
-    await writeFile(
-      join(
-        this.project.paths.calculationProjectFolder,
-        resourceName.identifier + '.lp',
-      ),
-      changedContent,
-      {
-        encoding: 'utf-8',
-        flag: 'r+',
-      },
-    );
-  }
-
   /**
    * Opens the content and metadata files for a card in the code editor
    * @param cardKey - The key of the card to open. Required.
    */
-  public async editCard(cardKey: string) {
-    // Determine the card path
-    const cardPath = this.project.pathToCard(cardKey);
-    if (!cardPath) {
-      throw new Error(`Card '${cardKey}' does not exist in the project`);
-    }
+  public editCard(cardKey: string) {
+    const card = this.project.findCard(cardKey);
 
     // Read the user preferences
     const prefs = new UserPreferences(
@@ -91,9 +42,8 @@ export class Edit {
     ).getPreferences();
 
     // Construct paths for the card components (json and adoc)
-    const cardDirPath = join(this.project.paths.cardRootFolder, cardPath);
-    const cardContentPath = join(cardDirPath, Project.cardContentFile);
-    const cardJsonPath = join(cardDirPath, Project.cardMetadataFile);
+    const cardContentPath = join(card.path, Project.cardContentFile);
+    const cardJsonPath = join(card.path, Project.cardMetadataFile);
 
     // Extract the editor settings from the preferences.
     const editorPrefs = prefs.editCommand[process.platform];
@@ -104,7 +54,7 @@ export class Edit {
     const editorArgs = editorArgPrefs.map((arg) => {
       arg = arg.replace(/\{\{\s*cardContentPath\s*\}\}/, cardContentPath);
       arg = arg.replace(/\{\{\s*cardJsonPath\s*\}\}/, cardJsonPath);
-      arg = arg.replace(/\{\{\s*cardDirPath\s*\}\}/, cardDirPath);
+      arg = arg.replace(/\{\{\s*cardDirPath\s*\}\}/, card.path);
 
       return arg;
     });
@@ -127,19 +77,14 @@ export class Edit {
    * @param changedContent New content for the card.
    */
   public async editCardContent(cardKey: string, changedContent: string) {
-    const isTemplateCard = await this.project.isTemplateCard(cardKey);
-    if (isTemplateCard) {
+    if (this.project.hasTemplateCard(cardKey)) {
       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`);
+    if (this.project.findCard(cardKey)) {
+      const actionGuard = new ActionGuard(this.project.calculationEngine);
+      await actionGuard.checkPermission('editContent', cardKey);
+      await this.project.updateCardContent(cardKey, changedContent);
     }
-
-    const actionGuard = new ActionGuard(this.project.calculationEngine);
-    await actionGuard.checkPermission('editContent', cardKey);
-
-    await this.project.updateCardContent(cardKey, changedContent);
   }
 
   /**
@@ -156,51 +101,15 @@ export class Edit {
     if (!changedKey) {
       throw new Error(`Changed key cannot be empty`);
     }
-    const isTemplateCard = await this.project.isTemplateCard(cardKey);
-    if (isTemplateCard) {
+    if (this.project.hasTemplateCard(cardKey)) {
       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`);
-    }
-
     // check for editing rights
-    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 resourceNameString = resourceNameToString(resourceName);
-    if (
-      !(await this.project.resourceExists(
-        resourceName.type as ResourceFolderType,
-        resourceNameString,
-      ))
-    ) {
-      throw new Error(
-        `Resource '${resourceNameString}' does not exist in the project`,
-      );
-    }
-    const resource = Project.resourceObject(this.project, resourceName);
-    if (!(resource instanceof FolderResource)) {
-      throw new Error(
-        `Resource '${resourceNameString}' is not a folder resource`,
-      );
+    if (this.project.findCard(cardKey)) {
+      const actionGuard = new ActionGuard(this.project.calculationEngine);
+      await actionGuard.checkPermission('editField', cardKey, changedKey);
+      await this.project.updateCardMetadataKey(cardKey, changedKey, newValue);
     }
-    return resource.updateFile(fileName, changedContent);
   }
 }

package/src/commands/export.ts

@@ -23,10 +23,7 @@ import {
 import { dirname, join } from 'node:path';
 import { spawn } from 'node:child_process';
 
-import type {
-  Card,
-  FetchCardDetails,
-} from '../interfaces/project-interfaces.js';
+import type { Card } from '../interfaces/project-interfaces.js';
 import type { CardType } from '../interfaces/resource-interfaces.js';
 import { evaluateMacros } from '../macros/index.js';
 import type { ExportPdfOptions } from '../interfaces/project-interfaces.js';
@@ -144,7 +141,10 @@ export class Export {
       }
 
       if (card.children) {
-        await this.toAdocFileAsContent(path, card.children);
+        await this.toAdocFileAsContent(
+          path,
+          this.project.cardKeysToCards(card.children),
+        );
       }
     }
   }
@@ -187,22 +187,7 @@ export class Export {
       children: [],
       attachments: [],
     };
-
-    // Get content and attachments separately, not included in queries
-    const fetchCardDetails: FetchCardDetails = {
-      attachments: true,
-      children: false,
-      content: true,
-      contentType: 'adoc',
-      metadata: true,
-      parent: false,
-    };
-
-    const cardDetailsResponse = await this.showCmd.showCardDetails(
-      fetchCardDetails,
-      card.key,
-    );
-
+    const cardDetailsResponse = this.showCmd.showCardDetails(card.key, 'adoc');
     let asciiDocContent = '';
     const project = this.project;
     try {
@@ -227,7 +212,7 @@ export class Export {
     card.attachments = cardDetailsResponse.attachments;
 
     for (const result of treeQueryResult.children ?? []) {
-      card.children!.push(await this.treeQueryResultToCard(result));
+      card.children!.push((await this.treeQueryResultToCard(result)).key);
     }
 
     return card;
@@ -332,13 +317,7 @@ export class Export {
     let cards: Card[] = [];
 
     // If doing a partial tree export, put the parent information as it would have already been gathered.
-    if (cardKey) {
-      const card = await this.project.findSpecificCard(cardKey);
-      if (!card) {
-        throw new Error(
-          `Input validation error: cannot find card '${cardKey}'`,
-        );
-      }
+    if (cardKey && this.project.findCard(cardKey)) {
       cards.push({
         key: cardKey,
         path: sourcePath,

package/src/commands/fetch.ts

@@ -18,7 +18,8 @@ import type { Project } from '../containers/project.js';
 import { writeJsonFile } from '../utils/json.js';
 import { validateJson } from '../utils/validate.js';
 import { type ModuleSetting } from '../interfaces/project-interfaces.js';
-import { errorFunction, getChildLogger } from '../utils/log-utils.js';
+import { errorFunction } from '../utils/error-utils.js';
+import { getChildLogger } from '../utils/log-utils.js';
 
 const FETCH_TIMEOUT = 30000; // 30s timeout for fetching a hub file.
 const MAX_RESPONSE_SIZE = 1024 * 1024; // 1MB limit for safety

package/src/commands/import.ts

@@ -62,7 +62,7 @@ export class Import {
         throw new Error(`Template '${template}' not found`);
       }
 
-      const templateCards = await templateObject.cards();
+      const templateCards = templateObject.cards();
       if (templateCards.length !== 1) {
         console.warn(
           `Template '${template}' for card '${title}' does not have exactly one card. Skipping row.`,
@@ -77,11 +77,9 @@ export class Import {
         throw new Error('Card not created');
       }
       const cardKey = cards[0].key;
-      const card = await this.project.findSpecificCard(cardKey, {
-        metadata: true,
-      });
-      const cardType = await this.project.resource<CardType>(
-        card?.metadata?.cardType || '',
+      const card = this.project.findCard(cardKey);
+      const cardType = this.project.resource<CardType>(
+        card.metadata?.cardType || '',
       );
 
       if (!cardType) {