@cyberismo/data-handler 0.0.15 → 0.0.16

package/src/commands/remove.ts

@@ -14,15 +14,18 @@
 import { ActionGuard } from '../permissions/action-guard.js';
 import { isModuleCard } from '../utils/card-utils.js';
 import { ModuleManager } from '../module-manager.js';
-import { Project } from '../containers/project.js';
+import type { Project } from '../containers/project.js';
 import type { RemovableResourceTypes } from '../interfaces/project-interfaces.js';
-import { resourceName } from '../utils/resource-utils.js';
 
 /**
  * Remove command.
  */
 export class Remove {
   private moduleManager: ModuleManager;
+  /**
+   * Creates a new instance of Remove command.
+   * @param project Project instance to use
+   */
   constructor(private project: Project) {
     this.moduleManager = new ModuleManager(this.project);
   }
@@ -152,14 +155,15 @@ export class Remove {
    * @param rest Additional arguments
    * @note removing attachment requires card id and attachment filename
    * @note removing link requires card ids of source card, and optionally link type and link description
+   * @throws when removing an attachment, but attachment parameter is missing, or
+   *         when removing link, some of the mandatory parameters are missing, or
+   *         when trying to remove unknown type
    */
   public async remove(
     type: RemovableResourceTypes,
     targetName: string,
     ...rest: any[] // eslint-disable-line @typescript-eslint/no-explicit-any
   ) {
-    const strictNameCheck = true;
-
     if (type === 'attachment' && rest.length !== 1 && !rest[0]) {
       throw new Error(
         `Input validation error: must pass argument 'detail' if requesting to remove attachment`,
@@ -177,9 +181,9 @@ export class Remove {
       );
     }
     if (this.projectResource(type)) {
-      const resource = Project.resourceObject(
-        this.project,
-        resourceName(targetName, strictNameCheck),
+      const resource = this.project.resources.byType(
+        targetName,
+        this.project.resources.resourceTypeFromSingularType(type),
       );
       return resource?.delete();
     } else {

package/src/commands/rename.ts

@@ -20,17 +20,6 @@ import type { Card } from '../interfaces/project-interfaces.js';
 import { isTemplateCard } from '../utils/card-utils.js';
 import { type Project, ResourcesFrom } from '../containers/project.js';
 import { resourceName } from '../utils/resource-utils.js';
-import { Template } from '../containers/template.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';
-import { GraphViewResource } from '../resources/graph-view-resource.js';
-import { LinkTypeResource } from '../resources/link-type-resource.js';
-import { ReportResource } from '../resources/report-resource.js';
-import { TemplateResource } from '../resources/template-resource.js';
-import { WorkflowResource } from '../resources/workflow-resource.js';
 
 const FILE_TYPES_WITH_PREFIX_REFERENCES = ['adoc', 'hbs', 'json', 'lp'];
 
@@ -41,6 +30,10 @@ export class Rename {
   private from: string = '';
   private to: string = '';
 
+  /**
+   * Creates an instance of Rename command.
+   * @param project Project instance to use.
+   */
   constructor(private project: Project) {}
 
   // Renames a card and all of its attachments (if it is a project card).
@@ -183,93 +176,6 @@ export class Rename {
       : name;
   }
 
-  // @todo: merge all update-functions
-  // Updates card type's metadata.
-  private async updateCardTypeMetadata(cardTypeName: string) {
-    const cardType = new CardTypeResource(
-      this.project,
-      resourceName(cardTypeName),
-    );
-    return cardType.rename(resourceName(this.updateResourceName(cardTypeName)));
-  }
-
-  // Rename calculations.
-  private async updateCalculation(calculationName: string) {
-    const calculation = new CalculationResource(
-      this.project,
-      resourceName(calculationName),
-    );
-    return calculation.rename(
-      resourceName(this.updateResourceName(calculationName)),
-    );
-  }
-
-  // Updates field type's metadata.
-  private async updateFieldTypeMetadata(fieldTypeName: string) {
-    const fieldType = new FieldTypeResource(
-      this.project,
-      resourceName(fieldTypeName),
-    );
-    return fieldType.rename(
-      resourceName(this.updateResourceName(fieldTypeName)),
-    );
-  }
-
-  // Updates graph model's metadata.
-  private async updateGraphModelMetadata(graphModelName: string) {
-    const graphModel = new GraphModelResource(
-      this.project,
-      resourceName(graphModelName),
-    );
-    return graphModel.rename(
-      resourceName(this.updateResourceName(graphModelName)),
-    );
-  }
-
-  // Updates graph view's metadata.
-  private async updateGraphViewMetadata(graphViewName: string) {
-    const graphView = new GraphViewResource(
-      this.project,
-      resourceName(graphViewName),
-    );
-    return graphView.rename(
-      resourceName(this.updateResourceName(graphViewName)),
-    );
-  }
-
-  // Updates link type's metadata.
-  private async updateLinkTypeMetadata(linkTypeName: string) {
-    const linkType = new LinkTypeResource(
-      this.project,
-      resourceName(linkTypeName),
-    );
-    return linkType.rename(resourceName(this.updateResourceName(linkTypeName)));
-  }
-
-  // Updates reports' metadata.
-  private async updateReport(reportName: string) {
-    const report = new ReportResource(this.project, resourceName(reportName));
-    return report.rename(resourceName(this.updateResourceName(reportName)));
-  }
-
-  // Rename templates.
-  private async updateTemplate(templateName: string) {
-    const template = new TemplateResource(
-      this.project,
-      resourceName(templateName),
-    );
-    return template.rename(resourceName(this.updateResourceName(templateName)));
-  }
-
-  // Rename workflows.
-  private async updateWorkflowMetadata(workflowName: string) {
-    const workflow = new WorkflowResource(
-      this.project,
-      resourceName(workflowName),
-    );
-    return workflow.rename(resourceName(this.updateResourceName(workflowName)));
-  }
-
   /**
    * Renames project prefix.
    * @throws if trying to use empty 'to'
@@ -294,72 +200,60 @@ export class Rename {
     await this.project.configuration.setCardPrefix(to);
     console.info(`Rename: New prefix: '${this.project.projectPrefix}'`);
     // Update the resources collection, since project prefix has changed.
-    this.project.collectLocalResources();
+    this.project.resources.changed();
 
     // Rename local resources.
-    // It is better to rename the resources in this order: card types, field types, then others
+    // It is better to rename the resources in this order: card types, workflows, field types, then the rest
 
     // Rename all card types and custom fields in them.
-    const cardTypes = await this.project.cardTypes(ResourcesFrom.localOnly);
-    for (const cardType of cardTypes) {
-      await this.updateCardTypeMetadata(cardType.name);
+    for (const cardType of this.project.resources.cardTypes(
+      ResourcesFrom.localOnly,
+    )) {
+      const name = this.updateResourceName(cardType.data?.name || '');
+      await cardType.rename(resourceName(name));
     }
     console.info('Updated card types');
 
-    const workflows = await this.project.workflows(ResourcesFrom.localOnly);
-    for (const workflow of workflows) {
-      await this.updateWorkflowMetadata(workflow.name);
+    for (const workflow of this.project.resources.workflows(
+      ResourcesFrom.localOnly,
+    )) {
+      const name = this.updateResourceName(workflow.data?.name || '');
+      await workflow.rename(resourceName(name));
     }
     console.info('Updated workflows');
 
-    const fieldTypes = await this.project.fieldTypes(ResourcesFrom.localOnly);
-    for (const fieldType of fieldTypes) {
-      await this.updateFieldTypeMetadata(fieldType.name);
+    for (const fieldType of this.project.resources.fieldTypes(
+      ResourcesFrom.localOnly,
+    )) {
+      const name = this.updateResourceName(fieldType.data?.name || '');
+      await fieldType.rename(resourceName(name));
     }
     console.info('Updated field types');
 
-    const graphModels = await this.project.graphModels(ResourcesFrom.localOnly);
-    for (const graphModel of graphModels) {
-      await this.updateGraphModelMetadata(graphModel.name);
-    }
-    console.info('Updated graph models');
-
-    const graphViews = await this.project.graphViews(ResourcesFrom.localOnly);
-    for (const graphView of graphViews) {
-      await this.updateGraphViewMetadata(graphView.name);
-    }
-    console.info('Updated graph views');
-
-    const linkTypes = await this.project.linkTypes(ResourcesFrom.localOnly);
-    for (const linkType of linkTypes) {
-      await this.updateLinkTypeMetadata(linkType.name);
-    }
-    console.info('Updated link types');
-
-    const reports = await this.project.reports(ResourcesFrom.localOnly);
-    for (const report of reports) {
-      await this.updateReport(report.name);
-    }
-    console.info('Updated reports');
-
-    let templates = await this.project.templates(ResourcesFrom.localOnly);
-    for (const template of templates) {
-      await this.updateTemplate(template.name);
+    const restOfResourceTypes = [
+      'graphModels',
+      'graphViews',
+      'linkTypes',
+      'reports',
+      'templates',
+      'calculations',
+    ] as const;
+
+    for (const resourceType of restOfResourceTypes) {
+      for (const resource of this.project.resources.resourceTypes(
+        resourceType,
+        ResourcesFrom.localOnly,
+      )) {
+        const name = this.updateResourceName(resource.data?.name || '');
+        await resource.rename(resourceName(name));
+      }
     }
-    console.info('Updated templates');
 
-    const calculations = await this.project.calculations(
+    // Rename all local template cards. This must be done after calculations have been renamed.
+    for (const template of this.project.resources.templates(
       ResourcesFrom.localOnly,
-    );
-    for (const calculation of calculations) {
-      await this.updateCalculation(calculation.name);
-    }
-    console.info('Updated calculations');
-
-    // Rename all local template cards.
-    templates = await this.project.templates(ResourcesFrom.localOnly);
-    for (const template of templates) {
-      const templateObject = new Template(this.project, template);
+    )) {
+      const templateObject = template.templateObject();
       await this.renameCards(templateObject.cards());
     }
     console.info('Renamed template cards and updated the content');
@@ -376,7 +270,7 @@ export class Rename {
     console.info('Renamed all remaining references in .cards folder');
 
     // It is best that the resources are re-collected after all the renaming has occurred.
-    this.project.collectLocalResources();
+    this.project.resources.changed();
     console.info('Collected renamed resources');
 
     return this.project.calculationEngine.generate();

package/src/commands/show.ts

@@ -34,47 +34,47 @@ import type {
   ModuleContent,
   ModuleSettingFromHub,
   ProjectMetadata,
-  Resource,
+  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 } 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 { readJsonFile } from '../utils/json.js';
 import { getChildLogger } from '../utils/log-utils.js';
-import { buildCardHierarchy } from '../utils/card-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({
@@ -82,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) => {
@@ -120,24 +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: CardWithChildrenCards[] }[]
-  > {
-    return Promise.all(
-      (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: buildCards,
-        };
-      }),
-    );
+  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,
+      };
+    });
   }
 
   /**
@@ -146,7 +164,7 @@ export class Show {
    */
   public async showAttachments(): Promise<CardAttachment[]> {
     const attachments = this.project.attachments();
-    const templateAttachments = await this.project.attachmentsFromTemplates();
+    const templateAttachments = await this.attachmentsFromTemplates();
     attachments.push(...templateAttachments);
     return attachments;
   }
@@ -284,17 +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);
+    return container;
   }
 
   /**
@@ -317,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);
         },
       );
 
@@ -349,7 +363,10 @@ export class Show {
    * @returns labels in a list
    */
   public showLabels(): string[] {
-    const cards = this.project.showProjectCards();
+    const cards = flattenCardArray(
+      this.project.showProjectCards(),
+      this.project,
+    );
     const templateCards = this.project.allTemplateCards();
 
     const labels = this.collectLabels([...cards, ...templateCards]);
@@ -398,8 +415,8 @@ export class Show {
    * 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();
   }
 
   /**
@@ -415,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
@@ -427,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`);
     }
@@ -471,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() : [],
@@ -502,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();
   }
 
   /**
@@ -512,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;
   }
 }