@cyberismo/data-handler 0.0.14 → 0.0.16

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,66 +20,61 @@ 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,
+  ResourceType,
 } from '../interfaces/project-interfaces.js';
 import type {
+  AnyResourceContent,
   CardType,
   ResourceContent,
   TemplateConfiguration,
   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 { TemplateResource } from '../resources/template-resource.js';
-import { UserPreferences } from '../utils/user-preferences.js';
+import type { Project, ResourcesFrom } from '../containers/project.js';
+import type { ResourceName } from '../utils/resource-utils.js';
+import type { ResourceMap } from '../containers/project/resource-cache.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, flattenCardArray } from '../utils/card-utils.js';
 
 /**
  * Show command.
  */
 export class Show {
-  private resourceFunction: Map<
+  private readonly resourceFunctions: Record<
     string,
-    (from?: ResourcesFrom) => Promise<Resource[]>
-  >;
-  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)],
-      ['graphViews', this.project.graphViews.bind(this.project)],
-      ['linkTypes', this.project.linkTypes.bind(this.project)],
-      ['reports', this.project.reports.bind(this.project)],
-      ['templates', this.project.templates.bind(this.project)],
-      ['workflows', this.project.workflows.bind(this.project)],
-    ]);
-  }
+    (from?: ResourcesFrom) => string[]
+  > = {
+    calculations: (from) => this.resourceNames('calculations', from),
+    cardTypes: (from) => this.resourceNames('cardTypes', from),
+    fieldTypes: (from) => this.resourceNames('fieldTypes', from),
+    graphModels: (from) => this.resourceNames('graphModels', from),
+    graphViews: (from) => this.resourceNames('graphViews', from),
+    linkTypes: (from) => this.resourceNames('linkTypes', from),
+    reports: (from) => this.resourceNames('reports', from),
+    templates: (from) => this.resourceNames('templates', from),
+    workflows: (from) => this.resourceNames('workflows', from),
+  };
+
+  constructor(private project: Project) {}
 
   private get logger() {
     return getChildLogger({
@@ -87,6 +82,29 @@ export class Show {
     });
   }
 
+  // Gets all template attachments
+  private async attachmentsFromTemplates() {
+    const templateAttachments: CardAttachment[] = [];
+    const templates = this.project.resources.templates();
+    for (const template of templates) {
+      const templateObject = template.templateObject();
+      if (templateObject) {
+        templateAttachments.push(...templateObject.attachments());
+      }
+    }
+    return templateAttachments;
+  }
+
+  // Fetch resource names as a list
+  private resourceNames<T extends keyof ResourceMap>(
+    resourceType: T,
+    from?: ResourcesFrom,
+  ): string[] {
+    return this.project.resources
+      .resourceTypes(resourceType, from)
+      .map((item) => item.data?.name || '');
+  }
+
   // Collect all labels from cards.
   private collectLabels = (cards: Card[]): string[] => {
     return cards.reduce<string[]>((labels, card) => {
@@ -94,28 +112,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;
@@ -140,21 +143,19 @@ 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(),
-        };
-      }),
-    );
+  public showAllTemplateCards(): {
+    name: string;
+    cards: CardWithChildrenCards[];
+  }[] {
+    return this.project.resources.templates().map((template) => {
+      const cards = template.templateObject().listCards();
+      const buildCards = buildCardHierarchy(cards);
+
+      return {
+        name: template.data?.name || '',
+        cards: buildCards,
+      };
+    });
   }
 
   /**
@@ -162,20 +163,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.attachmentsFromTemplates();
     attachments.push(...templateAttachments);
     return attachments;
   }
@@ -186,32 +175,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 +205,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 +252,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);
   }
 
   /**
@@ -316,73 +302,13 @@ export class Show {
    * @returns array of card type details
    */
   public async showCardTypesWithDetails(): Promise<(CardType | undefined)[]> {
-    const promiseContainer = [];
-    for (const cardType of await this.project.cardTypes()) {
-      const cardTypeDetails = await this.project.resource<CardType>(
-        cardType.name,
-      );
-      if (cardTypeDetails) {
-        promiseContainer.push(cardTypeDetails);
+    const container = [];
+    for (const cardType of this.project.resources.cardTypes()) {
+      if (cardType.data) {
+        container.push(cardType.data);
       }
     }
-    const results = await Promise.all(promiseContainer);
-    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();
+    return container;
   }
 
   /**
@@ -405,10 +331,10 @@ export class Show {
           resolve(this.project.basePath, MODULE_LIST_FULL_PATH),
         )
       ).modules;
-      const currentModules = await this.project.modules();
+      const currentModules = this.project.resources.moduleNames();
       const nonImportedModules = moduleList.filter(
         (item: ModuleSettingFromHub) => {
-          return !currentModules.some((module) => item.name === module.name);
+          return !currentModules.some((module) => item.name === module);
         },
       );
 
@@ -436,12 +362,12 @@ 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 = flattenCardArray(
+      this.project.showProjectCards(),
+      this.project,
+    );
+    const templateCards = this.project.allTemplateCards();
 
     const labels = this.collectLabels([...cards, ...templateCards]);
     return Array.from(new Set(labels));
@@ -479,20 +405,18 @@ 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();
   }
 
   /**
    * Shows all modules (if any) in a project.
    * @returns all modules in a project.
    */
-  public async showModules(): Promise<string[]> {
-    return (await this.project.modules()).map((item) => item.name).sort();
+  public showModules(): string[] {
+    return this.project.resources.moduleNames().sort();
   }
 
   /**
@@ -508,6 +432,7 @@ export class Show {
    * @param reportName Name of the report to show
    * @param cardKey Card key to use for the report
    * @param parameters Additional parameters for the report
+   * @param context Context for resource (includes a project instance)
    * @param outputPath Optional output path for the report
    * @returns Report results as a string
    * @throws Error if the report does not exist
@@ -520,9 +445,9 @@ export class Show {
     outputPath?: string,
   ): Promise<string> {
     if (
-      !(await this.project.reports()).some(
-        (report) => report.name === reportName,
-      )
+      !this.project.resources
+        .reports()
+        .some((report) => report.data?.name === reportName)
     ) {
       throw new Error(`Report '${reportName}' does not exist`);
     }
@@ -564,17 +489,35 @@ export class Show {
   /**
    * Shows details of certain resource.
    * @param name Name of resource.
+   * @param showUse If true, shows also where resource is used.
+   * @param resourceType If specified, checks that the resource is given type.
    * @returns resource metadata as JSON.
    */
   public async showResource(
     name: string,
-    showUse: boolean = false,
-  ): Promise<ResourceContent | undefined> {
-    const strictNameCheck = true;
-    const resource = Project.resourceObject(
-      this.project,
-      resourceName(name, strictNameCheck),
-    );
+    showUse?: boolean,
+  ): Promise<AnyResourceContent>;
+  public async showResource<T extends ResourceType>(
+    name: string,
+    resourceType: T,
+    showUse?: boolean,
+  ): Promise<ResourceContent<T>>;
+  public async showResource(
+    name: string,
+    arg2?: boolean | ResourceType,
+    arg3?: boolean,
+  ): Promise<AnyResourceContent> {
+    const hasResourceType = typeof arg2 === 'string';
+    const resourceType = hasResourceType ? arg2 : null;
+    const showUse = hasResourceType ? arg3 : arg2;
+
+    const type = this.project.resources.extractType(name);
+    if (resourceType !== null && resourceType !== type) {
+      throw new Error(
+        `While fetching '${name}': Expected type '${resourceType}', but got '${type}' instead`,
+      );
+    }
+    const resource = this.project.resources.byType(name, type);
     const [details, usage] = await Promise.all([
       resource?.show(),
       showUse ? resource?.usage() : [],
@@ -595,9 +538,9 @@ export class Show {
    * @returns sorted array of resources
    */
   public async showResources(type: string): Promise<string[]> {
-    const func = this.resourceFunction.get(type);
+    const func = this.resourceFunctions[type];
     if (!func) return [];
-    return (await func()).map((item) => item.name).sort();
+    return func().sort();
   }
 
   /**
@@ -605,23 +548,22 @@ export class Show {
    * @returns all templates in a project.
    */
   public async showTemplatesWithDetails(): Promise<TemplateConfiguration[]> {
-    const promiseContainer = (await this.project.templates()).map((template) =>
-      new TemplateResource(this.project, resourceName(template.name)).show(),
-    );
-    const result = await Promise.all(promiseContainer);
-    return result.filter(Boolean) as TemplateConfiguration[];
+    const templates = [];
+    for (const template of this.project.resources.templates()) {
+      templates.push(template.show());
+    }
+    return templates;
   }
 
   /**
    * Shows all workflows with full details in a project.
    * @returns workflows with full details
    */
-  public async showWorkflowsWithDetails(): Promise<(Workflow | undefined)[]> {
-    const promiseContainer = [];
-    for (const workflow of await this.project.workflows()) {
-      promiseContainer.push(this.project.resource<Workflow>(workflow.name));
+  public showWorkflowsWithDetails(): (Workflow | undefined)[] {
+    const workflows = [];
+    for (const workflow of this.project.resources.workflows()) {
+      workflows.push(workflow.data);
     }
-    const results = await Promise.all(promiseContainer);
-    return results.filter((item) => item);
+    return workflows;
   }
 }