@cyberismo/data-handler 0.0.8 → 0.0.10

package/src/commands/show.ts

@@ -16,7 +16,7 @@ import { existsSync, readFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join, resolve } from 'node:path';
 import { spawn } from 'node:child_process';
-import { writeFile } from 'node:fs/promises';
+import { readFile, writeFile } from 'node:fs/promises';
 
 import mime from 'mime-types';
 
@@ -30,6 +30,8 @@ import type {
   ProjectMetadata,
   Resource,
   CardLocation,
+  Context,
+  ResourceFolderType,
 } from '../interfaces/project-interfaces.js';
 import type {
   CardType,
@@ -38,13 +40,19 @@ import type {
   Workflow,
 } from '../interfaces/resource-interfaces.js';
 import { Project, type ResourcesFrom } from '../containers/project.js';
-import { resourceName } from '../utils/resource-utils.js';
+import {
+  type ResourceName,
+  resourceName,
+  resourceNameToPath,
+  resourceNameToString,
+} from '../utils/resource-utils.js';
 import { TemplateResource } from '../resources/template-resource.js';
 import { UserPreferences } from '../utils/user-preferences.js';
 
 import ReportMacro from '../macros/report/index.js';
 import TaskQueue from '../macros/task-queue.js';
-import type { Calculate } from './calculate.js';
+import { evaluateMacros } from '../macros/index.js';
+import { FolderResource } from '../resources/folder-resource.js';
 
 /**
  * Show command.
@@ -54,11 +62,9 @@ export class Show {
     string,
     (from?: ResourcesFrom) => Promise<Resource[]>
   >;
-  constructor(
-    private project: Project,
-    private calculate: Calculate,
-  ) {
+  constructor(private project: Project) {
     this.resourceFunction = new Map([
+      ['calculations', this.project.calculations.bind(this.project)],
       ['cardTypes', this.project.cardTypes.bind(this.project)],
       ['fieldTypes', this.project.fieldTypes.bind(this.project)],
       ['graphModels', this.project.graphModels.bind(this.project)],
@@ -119,6 +125,27 @@ export class Show {
     }
   }
 
+  /**
+   * Shows all template cards in a project.
+   * @returns all template cards in a project.
+   */
+  public async showAllTemplateCards(): Promise<
+    { name: string; cards: Card[] }[]
+  > {
+    return Promise.all(
+      (await this.project.templates()).map(async (template) => {
+        const templateResource = new TemplateResource(
+          this.project,
+          resourceName(template.name),
+        );
+        return {
+          name: template.name,
+          cards: await templateResource.templateObject().showTemplateCards(),
+        };
+      }),
+    );
+  }
+
   /**
    * Shows all attachments (either template or project attachments) from a project.
    * @returns array of card attachments
@@ -264,6 +291,15 @@ export class Show {
     return this.project.listCards(cardsFrom);
   }
 
+  /**
+   * Shows the content of a logic program.
+   * @param cardKey The key of the card.
+   * @returns the content of the logic program.
+   */
+  public async showCardLogicProgram(cardKey: string) {
+    return this.project.calculationEngine.cardLogicProgram(cardKey);
+  }
+
   /**
    * Shows all card types in a project.
    * @returns array of card type details
@@ -282,6 +318,57 @@ export class Show {
     return results.filter((item) => item);
   }
 
+  /**
+   * Shows the content of a file in a resource.
+   * @param resourceName Name of the resource.
+   * @param fileName Name of the file to show.
+   * @returns the content of the file.
+   */
+  public async showFile(
+    resourceName: ResourceName,
+    fileName: string,
+  ): Promise<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.showFile(fileName);
+  }
+
+  /**
+   * Shows all file names in a folder resource.
+   * @param resourceName Name of the resource.
+   * @returns all file names in the resource.
+   */
+  public async showFileNames(resourceName: ResourceName): Promise<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.showFileNames();
+  }
   /**
    * Returns all unique labels in a project
    * @returns labels in a list
@@ -297,6 +384,15 @@ export class Show {
     return Array.from(new Set(labels));
   }
 
+  /**
+   * Shows the content of a logic program.
+   * @param resource Name of the resource.
+   * @returns the content of the logic program.
+   */
+  public async showLogicProgram(resource: ResourceName) {
+    return this.project.calculationEngine.resourceLogicProgram(resource);
+  }
+
   /**
    * Shows details of a module.
    * @param moduleName name of a module
@@ -349,6 +445,7 @@ export class Show {
     reportName: string,
     cardKey: string,
     parameters: object,
+    context: Context,
     outputPath?: string,
   ): Promise<string> {
     if (
@@ -359,16 +456,25 @@ export class Show {
       throw new Error(`Report '${reportName}' does not exist`);
     }
 
-    const reportMacro = new ReportMacro(new TaskQueue(), this.calculate);
-    const result = await reportMacro.handleInject(
+    await this.project.calculationEngine.generate();
+    const reportMacro = new ReportMacro(new TaskQueue());
+    let result = await reportMacro.handleStatic(
       {
         project: this.project,
         cardKey: cardKey,
         mode: 'static',
+        context,
       },
       { name: reportName, ...parameters },
     );
 
+    result = await evaluateMacros(result, {
+      project: this.project,
+      cardKey: cardKey,
+      mode: 'static',
+      context,
+    });
+
     // Show the results either in the console or write to a file.
     if (outputPath) {
       try {
@@ -393,6 +499,17 @@ export class Show {
     name: string,
     showUse: boolean = false,
   ): Promise<ResourceContent | undefined> {
+    // TODO: remove this workaround once calculations are implemented as a resource class
+    if (resourceName(name).type === 'calculations') {
+      const nameObj = resourceName(name);
+      const path = resourceNameToPath(this.project, nameObj, '.lp');
+      return {
+        name,
+        displayName: nameObj.identifier,
+        calculation: await readFile(path, 'utf-8'),
+      };
+    }
+
     const strictNameCheck = true;
     const resource = Project.resourceObject(
       this.project,

package/src/commands/transition.ts

@@ -12,7 +12,6 @@
 */
 
 import { ActionGuard } from '../permissions/action-guard.js';
-import type { Calculate } from './calculate.js';
 import type {
   CardType,
   Workflow,
@@ -22,10 +21,7 @@ import { CardMetadataUpdater } from '../card-metadata-updater.js';
 import type { Project } from '../containers/project.js';
 
 export class Transition {
-  constructor(
-    private project: Project,
-    private calculateCmd: Calculate,
-  ) {}
+  constructor(private project: Project) {}
 
   /**
    * Transitions a card from its current state to a new state.
@@ -93,7 +89,7 @@ export class Transition {
       );
     }
 
-    const actionGuard = new ActionGuard(this.calculateCmd);
+    const actionGuard = new ActionGuard(this.project.calculationEngine);
     await actionGuard.checkPermission('transition', cardKey, transition.name);
 
     details.metadata.workflowState = found.toState;
@@ -119,7 +115,7 @@ export class Transition {
   // Wrapper to run onTransition query.
   private async transitionChangesQuery(cardKey: string, transition: string) {
     if (!cardKey || !transition) return undefined;
-    return this.calculateCmd.runQuery('onTransition', {
+    return this.project.calculationEngine.runQuery('onTransition', 'localApp', {
       cardKey,
       transition,
     });

package/src/commands/update.ts

@@ -34,6 +34,7 @@ export class Update {
    * @param key Property to change in resource JSON
    * @param value Value for 'key'
    * @param optionalDetail Additional detail needed for some operations. For example, 'update' needs a new value.
+   * @param mappingTable Optional mapping table for workflow state transitions (only used for workflow changes)
    */
   public async updateValue<Type>(
     name: string,
@@ -41,6 +42,7 @@ export class Update {
     key: string,
     value: Type,
     optionalDetail?: Type, // todo: for 'rank' it might be reasonable to accept also 'number'
+    mappingTable?: { stateMapping: Record<string, string> },
   ) {
     const resource = Project.resourceObject(this.project, resourceName(name));
     const op: Operation<Type> = {
@@ -60,6 +62,10 @@ export class Update {
       (op as ChangeOperation<Type>).to = optionalDetail
         ? optionalDetail
         : (value as Type);
+      // Add mapping table if provided (for workflow changes)
+      if (mappingTable) {
+        (op as ChangeOperation<Type>).mappingTable = mappingTable;
+      }
     } else if (operation === 'rank') {
       (op as RankOperation<Type>).newIndex = optionalDetail as number;
       (op as RankOperation<Type>).target = value;

package/src/commands/validate.ts

@@ -42,7 +42,7 @@ import { isTemplateCard } from '../utils/card-utils.js';
 import { pathExists } from '../utils/file-utils.js';
 import { Project } from '../containers/project.js';
 import { readJsonFile } from '../utils/json.js';
-import { resourceName } from '../utils/resource-utils.js';
+import { type ResourceName, resourceName } from '../utils/resource-utils.js';
 
 const invalidNames = new RegExp(
   '[<>:"/\\|?*\x00-\x1F]|^(?:aux|con|clock$|nul|prn|com[1-9]|lpt[1-9])$', // eslint-disable-line no-control-regex
@@ -52,7 +52,6 @@ const SHORT_TEXT_MAX_LENGTH = 80;
 
 import * as EmailValidator from 'email-validator';
 import { evaluateMacros } from '../macros/index.js';
-import { Calculate } from './calculate.js';
 const baseDir = dirname(fileURLToPath(import.meta.url));
 const subFoldersToValidate = ['.cards', 'cardRoot'];
 
@@ -482,7 +481,8 @@ export class Validate {
    * returns true if identifier is valid, and false otherwise.
    */
   public static isValidIdentifierName(identifier: string): boolean {
-    const validIdentifier = new RegExp('^[A-Za-z0-9 ._-]+$');
+    const validIdentifier = new RegExp('^[A-Za-z0-9._-]+$');
+
     const contentValidated = validIdentifier.test(identifier);
     const lengthValidated = identifier.length > 0 && identifier.length < 256;
     const notInvalidIdentifier = !invalidNames.test(identifier);
@@ -547,7 +547,6 @@ export class Validate {
       } else {
         const errorMsg: string[] = [];
         const project = new Project(projectPath);
-        const calculate = new Calculate(project);
 
         // Then, validate that each 'contentSchema' children as well.
         const result = await this.readAndValidateContentFiles(
@@ -562,7 +561,15 @@ export class Validate {
         const cards = await project.cards();
         cards.push(...(await project.allTemplateCards()));
 
+        const cardIds = new Map<string, number>();
+
         for (const card of cards) {
+          if (cardIds.has(card.key)) {
+            cardIds.set(card.key, (cardIds.get(card.key) || 0) + 1);
+          } else {
+            cardIds.set(card.key, 1);
+          }
+
           if (card.metadata) {
             // validate card's workflow
             if (!isTemplateCard(card)) {
@@ -591,15 +598,12 @@ export class Validate {
 
           // Validate macros in content
           if (card.content) {
-            await evaluateMacros(
-              card.content,
-              {
-                mode: 'validate',
-                project,
-                cardKey: card.key,
-              },
-              calculate,
-            );
+            await evaluateMacros(card.content, {
+              context: 'localApp',
+              mode: 'validate',
+              project,
+              cardKey: card.key,
+            });
           }
         }
         if (errorMsg.length) {
@@ -607,6 +611,12 @@ export class Validate {
             .filter(this.removeDuplicateEntries)
             .join('\n');
         }
+        // Validate that there are no duplicate card keys
+        for (const [key, count] of cardIds) {
+          if (count > 1) {
+            validationErrors += `Duplicate card key '${key}' found ${count} times\n`;
+          }
+        }
       }
     } catch (error) {
       validationErrors += errorFunction(error);
@@ -919,6 +929,24 @@ export class Validate {
     return validationErrors.join('\n');
   }
 
+  /**
+   * Validates a single resource.
+   * @param resource Resource to validate
+   * @returns string containing all validation errors
+   */
+  public async validateResource(
+    resourceName: ResourceName,
+    project: Project,
+  ): Promise<string> {
+    try {
+      const resource = Project.resourceObject(project, resourceName);
+      await resource.validate();
+      return '';
+    } catch (error) {
+      return errorFunction(error);
+    }
+  }
+
   /**
    * Possibly creates (if no instance exists) and returns an instance of Validate command.
    * @returns instance of Validate command.

package/src/containers/card-container.ts

@@ -17,6 +17,8 @@ import { basename, join, sep } from 'node:path';
 import type { Dirent } from 'node:fs';
 import { readdir, readFile, writeFile } from 'node:fs/promises';
 
+import { findParentPath } from '../utils/card-utils.js';
+import { readJsonFile } from '../utils/json.js';
 import { writeJsonFile } from '../utils/json.js';
 import { getFilesSync } from '../utils/file-utils.js';
 
@@ -24,6 +26,7 @@ import { getFilesSync } from '../utils/file-utils.js';
 import {
   type CardAttachment,
   type Card,
+  type CardMetadata,
   CardNameRegEx,
   type FetchCardDetails,
 } from '../interfaces/project-interfaces.js';
@@ -375,4 +378,75 @@ export class CardContainer {
       await writeJsonFile(metadataFile, card.metadata);
     }
   }
+
+  /**
+   * Show cards with hierarchy structure from a given path.
+   * @param path The path to read cards from
+   * @returns an array of cards with proper parent-child relationships.
+   */
+  protected async showCards(path: string): Promise<Card[]> {
+    const cards: Card[] = [];
+    const cardPathMap = new Map<string, Card>();
+    const entries = await readdir(path, {
+      withFileTypes: true,
+      recursive: true,
+    });
+
+    // Checks if Dirent folder is a card folder
+    function cardFolder(
+      entry: Dirent,
+      cardPathMap: Map<string, Card>,
+    ): Card | undefined {
+      const fullPath = join(entry.parentPath, entry.name);
+      if (!cardPathMap.has(fullPath)) {
+        const newCard: Card = {
+          key: entry.name,
+          path: fullPath,
+          children: [],
+          attachments: [],
+        };
+        cardPathMap.set(fullPath, newCard);
+        return newCard;
+      }
+    }
+
+    // Process card directories first
+    entries
+      .filter((entry) => entry.isDirectory() && CardNameRegEx.test(entry.name))
+      .forEach((entry) => {
+        const card = cardFolder(entry, cardPathMap);
+        if (card) cards.push(card);
+      });
+
+    // Process metadata files in parallel
+    await Promise.all(
+      entries
+        .filter(
+          (entry) =>
+            entry.isFile() && entry.name === CardContainer.cardMetadataFile,
+        )
+        .map(async (entry) => {
+          const parentCard = cardPathMap.get(entry.parentPath);
+          if (!parentCard) return;
+          parentCard.metadata = (await readJsonFile(
+            join(entry.parentPath, entry.name),
+          )) as CardMetadata;
+        }),
+    );
+
+    // Finally, build the card hierarchy
+    Array.from(cardPathMap.entries()).map(([cardPath, card]) => {
+      const parentPath = findParentPath(cardPath);
+      if (!parentPath) return;
+      const parentCard = cardPathMap.get(parentPath);
+      if (!parentCard) return;
+
+      parentCard.children.push(card);
+      const index = cards.indexOf(card);
+      if (index > -1) {
+        cards.splice(index, 1);
+      }
+    });
+    return cards;
+  }
 }