@cyberismo/data-handler 0.0.8 → 0.0.9

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'];
 
@@ -547,7 +546,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 +560,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 +597,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 +610,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 +928,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;
+  }
 }