@cyberismo/data-handler 0.0.14 → 0.0.15

package/src/commands/show.ts

@@ -12,7 +12,7 @@
 */
 
 // node
-import { existsSync, readFileSync } from 'node:fs';
+import { readFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join, resolve } from 'node:path';
 import { spawn } from 'node:child_process';
@@ -20,22 +20,21 @@ import { writeFile } from 'node:fs/promises';
 
 import { MODULE_LIST_FULL_PATH } from './fetch.js';
 
-import mime from 'mime-types';
-
 import type { attachmentPayload } from '../interfaces/request-status-interfaces.js';
 import type {
-  CardAttachment,
   Card,
+  CardAttachment,
   CardListContainer,
-  ModuleContent,
+  CardLocation,
+  CardWithChildrenCards,
+  Context,
+  FetchCardDetails,
+  FileContentType,
   HubSetting,
+  ModuleContent,
   ModuleSettingFromHub,
-  ProjectFetchCardDetails,
   ProjectMetadata,
   Resource,
-  CardLocation,
-  Context,
-  ResourceFolderType,
 } from '../interfaces/project-interfaces.js';
 import type {
   CardType,
@@ -44,20 +43,16 @@ import type {
   Workflow,
 } from '../interfaces/resource-interfaces.js';
 import { Project, type ResourcesFrom } from '../containers/project.js';
-import {
-  type ResourceName,
-  resourceName,
-  resourceNameToString,
-} from '../utils/resource-utils.js';
+import { type ResourceName, resourceName } 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 { evaluateMacros } from '../macros/index.js';
-import { FolderResource } from '../resources/folder-resource.js';
 import { readJsonFile } from '../utils/json.js';
 import { getChildLogger } from '../utils/log-utils.js';
+import { buildCardHierarchy } from '../utils/card-utils.js';
 
 /**
  * Show command.
@@ -94,28 +89,13 @@ export class Show {
       if (card.metadata?.labels) {
         labels.push(...card.metadata.labels);
       }
-      // Recursively collect labels from subcards, if they exist
-      if (card.children) {
-        labels.push(...this.collectLabels(card.children));
-      }
       return labels;
     }, []);
   };
 
   // Returns attachment details
-  private async getAttachment(cardKey: string, filename: string) {
-    const details = {
-      content: false,
-      metadata: true,
-      children: false,
-      parent: false,
-      attachments: true,
-    };
-    const card = await this.project.cardDetailsById(cardKey, details);
-    if (card === undefined) {
-      throw new Error(`Card '${cardKey}' does not exist in the project`);
-    }
-
+  private getAttachment(cardKey: string, filename: string) {
+    const card = this.project.findCard(cardKey);
     const attachment =
       card.attachments?.find((a) => a.fileName === filename) ?? undefined;
     return attachment;
@@ -141,17 +121,20 @@ export class Show {
    * @returns all template cards in a project.
    */
   public async showAllTemplateCards(): Promise<
-    { name: string; cards: Card[] }[]
+    { name: string; cards: CardWithChildrenCards[] }[]
   > {
     return Promise.all(
-      (await this.project.templates()).map(async (template) => {
+      (await this.project.templates()).map((template) => {
         const templateResource = new TemplateResource(
           this.project,
           resourceName(template.name),
         );
+        const cards = templateResource.templateObject().listCards();
+        const buildCards = buildCardHierarchy(cards);
+
         return {
           name: template.name,
-          cards: await templateResource.templateObject().showTemplateCards(),
+          cards: buildCards,
         };
       }),
     );
@@ -162,20 +145,8 @@ export class Show {
    * @returns array of card attachments
    */
   public async showAttachments(): Promise<CardAttachment[]> {
-    const attachments: CardAttachment[] = await this.project.attachments();
-    const templateAttachments: CardAttachment[] = [];
-    const templates = await this.project.templates();
-    for (const template of templates) {
-      const templateResource = new TemplateResource(
-        this.project,
-        resourceName(template.name),
-      );
-      const templateObject = templateResource.templateObject();
-      if (templateObject) {
-        templateAttachments.push(...(await templateObject.attachments()));
-      }
-    }
-
+    const attachments = this.project.attachments();
+    const templateAttachments = await this.project.attachmentsFromTemplates();
     attachments.push(...templateAttachments);
     return attachments;
   }
@@ -186,32 +157,22 @@ export class Show {
    * @param filename attachment filename
    * @returns attachment details
    */
-  public async showAttachment(
-    cardKey: string,
-    filename: string,
-  ): Promise<attachmentPayload> {
+  public showAttachment(cardKey: string, filename: string): attachmentPayload {
     if (!cardKey) {
       throw new Error(`Mandatory parameter 'cardKey' missing`);
     }
 
-    const attachment = await this.getAttachment(cardKey, filename);
-
-    let attachmentPath: string = '';
-    if (attachment) {
-      attachmentPath = `${attachment.path}/${attachment.fileName}`;
-    }
+    const attachment = this.getAttachment(cardKey, filename);
 
-    if (!attachment || !existsSync(attachmentPath)) {
+    if (!attachment) {
       throw new Error(`Attachment '${filename}' not found for card ${cardKey}`);
-    } else {
-      const fileBuffer = readFileSync(attachmentPath);
-      let mimeType = mime.lookup(attachmentPath);
-      if (mimeType === false) {
-        mimeType = 'application/octet-stream';
-      }
-      const payload: attachmentPayload = { fileBuffer, mimeType };
-      return payload;
     }
+
+    const attachmentPath = `${attachment.path}/${attachment.fileName}`;
+    const fileBuffer = readFileSync(attachmentPath);
+    const mimeType = attachment.mimeType || 'application/octet-stream';
+    const payload: attachmentPayload = { fileBuffer, mimeType };
+    return payload;
   }
 
   /**
@@ -226,7 +187,7 @@ export class Show {
     filename: string,
     waitDelay: number = 1000,
   ) {
-    const attachment = await this.getAttachment(cardKey, filename);
+    const attachment = this.getAttachment(cardKey, filename);
 
     if (!attachment) {
       throw new Error(`Attachment '${filename}' not found for card ${cardKey}`);
@@ -273,22 +234,29 @@ export class Show {
   /**
    * Shows details of a particular card (template card, or project card)
    * @note Note that parameter 'cardKey' is optional due to technical limitations of class calling this class. It must be defined to get valid results.
-   * @param details card details to show
    * @param cardKey card key to find
+   * @param contentType Content format in which content is to be shown
    * @returns card details
    */
-  public async showCardDetails(
-    details: ProjectFetchCardDetails,
+  public showCardDetails(
     cardKey?: string,
-  ): Promise<Card> {
+    contentType?: FileContentType,
+  ): Card {
     if (!cardKey) {
       throw new Error(`Mandatory parameter 'cardKey' missing`);
     }
-    const cardDetails = await this.project.cardDetailsById(cardKey, details);
-    if (cardDetails === undefined) {
-      throw new Error(`Card '${cardKey}' does not exist in the project`);
+    // todo: Make a constant about this
+    const details: FetchCardDetails = {
+      parent: true,
+      metadata: true,
+      children: true,
+      attachments: true,
+      content: true,
+    };
+    if (contentType) {
+      details.contentType = contentType;
     }
-    return cardDetails;
+    return this.project.findCard(cardKey, details);
   }
 
   /**
@@ -329,62 +297,6 @@ export class Show {
     return results.filter((item) => item);
   }
 
-  /**
-   * Shows the content of a file in a resource.
-   * TODO: To be removed
-   * @deprecated
-   * @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.
-   * TODO: To be removed
-   * @deprecated
-   * @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();
-  }
-
   /**
    * Shows importable modules.
    * @param showAll - When true, shows all importable modules, even if they have already been imported
@@ -436,12 +348,9 @@ export class Show {
    * Returns all unique labels in a project
    * @returns labels in a list
    */
-  public async showLabels(): Promise<string[]> {
-    const cards = await this.project.showProjectCards();
-    const templateCards = await this.project.allTemplateCards({
-      metadata: true,
-      children: true,
-    });
+  public showLabels(): string[] {
+    const cards = this.project.showProjectCards();
+    const templateCards = this.project.allTemplateCards();
 
     const labels = this.collectLabels([...cards, ...templateCards]);
     return Array.from(new Set(labels));
@@ -479,12 +388,10 @@ export class Show {
 
   /**
    * Returns all project cards in the project. Cards don't have content and nor metadata.
-   * @note AppUi uses this method.
    * @returns array of cards
    */
-  public async showProjectCards(): Promise<Card[]> {
-    const projectCards = await this.project.showProjectCards();
-    return projectCards;
+  public showProjectCards(): Card[] {
+    return this.project.showProjectCards();
   }
 
   /**

package/src/commands/transition.ts

@@ -29,21 +29,15 @@ export class Transition {
    * @param transition which transition to do
    */
   public async cardTransition(cardKey: string, transition: WorkflowState) {
-    // Card details
-    const details = await this.project.cardDetailsById(cardKey, {
-      metadata: true,
-    });
-    if (!details || !details.metadata) {
-      throw new Error(`Card ${cardKey} does not exist in the project`);
-    }
+    const card = this.project.findCard(cardKey);
 
     // Card type
-    const cardType = await this.project.resource<CardType>(
-      details.metadata?.cardType,
+    const cardType = this.project.resource<CardType>(
+      card.metadata?.cardType || '',
     );
     if (cardType === undefined) {
       throw new Error(
-        `Card's card type '${details.metadata?.cardType}' does not exist in the project`,
+        `Card's card type '${card.metadata?.cardType}' does not exist in the project`,
       );
     }
 
@@ -58,13 +52,13 @@ export class Transition {
     // Check that the state transition can be made "from".
     const foundFrom = workflow.transitions.find(
       (item) =>
-        (details.metadata &&
-          item.fromState.includes(details.metadata?.workflowState)) ||
+        (card.metadata &&
+          item.fromState.includes(card.metadata?.workflowState)) ||
         item.fromState.includes('*'),
     );
     if (!foundFrom) {
       throw new Error(
-        `Card's workflow '${cardType.workflow}' does not contain transition from card's current state '${details.metadata?.workflowState}'`,
+        `Card's workflow '${cardType.workflow}' does not contain transition from card's current state '${card.metadata?.workflowState}'`,
       );
     }
 
@@ -80,36 +74,39 @@ export class Transition {
 
     if (
       !(
-        found.fromState.includes(details.metadata?.workflowState) ||
+        (card.metadata?.workflowState &&
+          found.fromState.includes(card.metadata.workflowState)) ||
         found.fromState.includes('*')
       )
     ) {
       throw new Error(
-        `Card's workflow '${cardType.workflow}' does not contain state transition from state '${details.metadata?.workflowState}' for '${transition.name}`,
+        `Card's workflow '${cardType.workflow}' does not contain state transition from state '${card.metadata?.workflowState}' for '${transition.name}`,
       );
     }
 
     const actionGuard = new ActionGuard(this.project.calculationEngine);
     await actionGuard.checkPermission('transition', cardKey, transition.name);
 
-    details.metadata.workflowState = found.toState;
-    details.metadata.lastUpdated = new Date().toISOString();
-    details.metadata.lastTransitioned = new Date().toISOString();
-    return this.project
-      .updateCardMetadata(details, details.metadata)
-      .then(async () => this.transitionChangesQuery(cardKey, transition.name))
-      .then(async (queryResult) => {
-        if (
-          !queryResult ||
-          queryResult.at(0) === undefined ||
-          queryResult.at(0)?.updateFields === undefined
-        ) {
-          return;
-        }
-        const fieldsToUpdate = queryResult.at(0)!.updateFields;
-        return CardMetadataUpdater.apply(this.project, fieldsToUpdate);
-      })
-      .catch((error) => console.error(error));
+    if (card.metadata) {
+      card.metadata.workflowState = found.toState;
+      card.metadata.lastUpdated = new Date().toISOString();
+      card.metadata.lastTransitioned = new Date().toISOString();
+      return this.project
+        .updateCardMetadata(card, card.metadata)
+        .then(async () => this.transitionChangesQuery(cardKey, transition.name))
+        .then(async (queryResult) => {
+          if (
+            !queryResult ||
+            queryResult.at(0) === undefined ||
+            queryResult.at(0)?.updateFields === undefined
+          ) {
+            return;
+          }
+          const fieldsToUpdate = queryResult.at(0)!.updateFields;
+          return CardMetadataUpdater.apply(this.project, fieldsToUpdate);
+        })
+        .catch((error) => console.error(error));
+    }
   }
 
   // Wrapper to run onTransition query.

package/src/commands/update.ts

@@ -21,6 +21,7 @@ import type {
 } from '../resources/resource-object.js';
 import { Project } from '../containers/project.js';
 import { resourceName } from '../utils/resource-utils.js';
+import type { UpdateKey } from '../interfaces/resource-interfaces.js';
 
 /**
  * Class that handles 'update' commands.
@@ -32,7 +33,7 @@ export class Update {
    * Updates single resource property.
    * @param name Name of the resource to operate on.
    * @param operation Operation to perform ('add', 'remove', 'change', 'rank')
-   * @param key Property to change in resource JSON
+   * @param key Property to change in resource JSON. If content, content/<property>
    * @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)
@@ -75,26 +76,43 @@ export class Update {
         ? optionalDetail
         : undefined;
     }
+    const splitKey = key.split('/');
+    if (splitKey.length !== 1 && splitKey.length !== 2) {
+      throw new Error(
+        `Invalid key format: ${key}. Use 'property' or 'content/<property>'.`,
+      );
+    }
 
-    await this.applyResourceOperation(name, key, op);
+    if (splitKey.length === 2 && splitKey[0] !== 'content') {
+      throw new Error(
+        `Invalid key format: ${key}. When using 'content', always use as 'content/<property>'.`,
+      );
+    }
+    const [parsedKey, subKey] = splitKey;
+    if (parsedKey === 'content') {
+      await this.applyResourceOperation(name, { key: parsedKey, subKey }, op);
+    } else {
+      await this.applyResourceOperation(name, { key: parsedKey }, op);
+    }
   }
 
   /**
    * Update single resource property
    * This is similar to updateValue, but allows the operation to be fully specified
    * @param name Name of the resource to operate on.
-   * @param key Property to change in resource JSON
+   * @param updateKey Property to change in resource or in resource content.
    * @param operation The full operation object
    * @template Type Type of the target of the operation
    * @template T Type of operation ('add', 'remove', 'change', 'rank')
+   * @template K Type of the key to change
    */
-  public async applyResourceOperation<Type, T extends UpdateOperations>(
-    name: string,
-    key: string,
-    operation: OperationFor<Type, T>,
-  ) {
+  public async applyResourceOperation<
+    Type,
+    T extends UpdateOperations,
+    K extends string,
+  >(name: string, updateKey: UpdateKey<K>, operation: OperationFor<Type, T>) {
     const resource = Project.resourceObject(this.project, resourceName(name));
-    await resource?.update(key, operation);
+    await resource?.update(updateKey, operation);
     this.project.collectLocalResources();
   }
 }

package/src/commands/validate.ts

@@ -169,21 +169,16 @@ export class Validate {
 
   // Puts resource to a local cache if found and returns the resource.
   // If value is already cached, returns from cache.
-  private async getAndCacheResource<Type>(
+  private getAndCacheResource<Type>(
     project: Project,
     cachedValues: Map<string, Type>,
     valueName: string,
-  ): Promise<Type | undefined> {
-    return (
-      cachedValues.get(valueName) ||
-      project.resource<Type>(valueName).then((resource) => {
-        if (!resource) {
-          return undefined;
-        }
-        cachedValues.set(valueName, resource);
-        return resource;
-      })
-    );
+  ): Type | undefined {
+    const resource = project.resource<Type>(valueName);
+    if (resource) {
+      cachedValues.set(valueName, resource);
+    }
+    return resource;
   }
 
   private parseValidatorMessage(errorObject: object[]): string {
@@ -395,7 +390,7 @@ export class Validate {
     const errors: string[] = [];
     if (cardType && fieldArray) {
       const validationPromises = fieldArray.map(async (field) => {
-        const fieldType = await this.getAndCacheResource(
+        const fieldType = this.getAndCacheResource(
           project,
           this.validatedFieldTypes,
           field,
@@ -550,6 +545,7 @@ export class Validate {
       } else {
         const errorMsg: string[] = [];
         const project = projectFn();
+        await project.populateCaches();
 
         // Then, validate that each 'contentSchema' children as well.
         const result = await this.readAndValidateContentFiles(
@@ -561,8 +557,8 @@ export class Validate {
         }
 
         // Finally, validate that each card is correct
-        const cards = await project.cards();
-        cards.push(...(await project.allTemplateCards()));
+        const cards = project.cards();
+        cards.push(...project.allTemplateCards());
 
         const cardIds = new Map<string, number>();
 
@@ -574,12 +570,8 @@ export class Validate {
           }
 
           if (card.metadata) {
-            // validate card's workflow
             if (!isTemplateCard(card)) {
-              const validWorkflow = await this.validateWorkflowState(
-                project,
-                card,
-              );
+              const validWorkflow = this.validateWorkflowState(project, card);
               if (validWorkflow.length !== 0) {
                 errorMsg.push(validWorkflow);
               }
@@ -604,7 +596,7 @@ export class Validate {
             await evaluateMacros(card.content, {
               context: 'localApp',
               mode: 'validate',
-              project,
+              project: project,
               cardKey: card.key,
             });
           }
@@ -673,19 +665,15 @@ export class Validate {
    * @param prefixes currently used project prefixes
    * @returns resource name as valid resource name; throws in error cases.
    */
-  public async validResourceName(
+  public validResourceName(
     resourceType: ResourceTypes,
     name: string,
     prefixes: string[],
-  ): Promise<string> {
+  ): string {
     const resource = resourceName(name);
     resource.type = resource.type ? resource.type : resourceType;
-    // a bit shaky way to ensure that prefix is set; first of the project prefixes should be the actual project prefix.
     if (resource.prefix === '') {
-      resource.prefix = prefixes.length > 0 ? prefixes.at(0) || '' : '';
-      if (resource.prefix === '') {
-        throw new Error(`Project prefix cannot be empty string`);
-      }
+      throw new Error(`Project prefix cannot be empty string`);
     }
     if (!prefixes.includes(resource.prefix)) {
       throw new Error(
@@ -735,7 +723,7 @@ export class Validate {
       );
     }
 
-    const cardType = await this.getAndCacheResource(
+    const cardType = this.getAndCacheResource(
       project,
       this.validatedCardTypes,
       card.metadata?.cardType,
@@ -836,7 +824,7 @@ export class Validate {
    * Validates the labels of a card
    * @param card card to validate. Card must have metadata.
    */
-  public async validateCardLabels(card: Card): Promise<string> {
+  public validateCardLabels(card: Card): string {
     const validationErrors: string[] = [];
     if (!card.metadata) {
       validationErrors.push(
@@ -870,10 +858,7 @@ export class Validate {
    * @param card Card object to validate
    * @returns string containing all validation errors
    */
-  public async validateWorkflowState(
-    project: Project,
-    card: Card,
-  ): Promise<string> {
+  public validateWorkflowState(project: Project, card: Card): string {
     const validationErrors: string[] = [];
 
     if (!card.metadata) {
@@ -883,7 +868,7 @@ export class Validate {
     }
 
     // Use caches for cardTypes and workflows, to avoid re-reading the same JSON files multiple times.
-    const cardType = await this.getAndCacheResource(
+    const cardType = this.getAndCacheResource(
       project,
       this.validatedCardTypes,
       card.metadata?.cardType || '',
@@ -901,7 +886,7 @@ export class Validate {
       return validationErrors.join('\n');
     }
 
-    const workflow = await this.getAndCacheResource(
+    const workflow = this.getAndCacheResource(
       project,
       this.validatedWorkflows,
       cardType.workflow,