@cyberismo/data-handler 0.0.15 → 0.0.17

package/src/commands/show.ts

@@ -18,7 +18,7 @@ import { join, resolve } from 'node:path';
 import { spawn } from 'node:child_process';
 import { writeFile } from 'node:fs/promises';
 
-import { MODULE_LIST_FULL_PATH } from './fetch.js';
+import { type Fetch, MODULE_LIST_FULL_PATH } from './fetch.js';
 
 import type { attachmentPayload } from '../interfaces/request-status-interfaces.js';
 import type {
@@ -34,47 +34,50 @@ 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 fetchCmd: Fetch,
+  ) {}
 
   private get logger() {
     return getChildLogger({
@@ -82,6 +85,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 +146,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 +167,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 +305,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;
   }
 
   /**
@@ -312,15 +329,18 @@ export class Show {
     showDetails?: boolean,
   ): Promise<ModuleSettingFromHub[]> {
     try {
+      // Ensure module list is up to date before showing
+      await this.fetchCmd.ensureModuleListUpToDate();
+
       const moduleList = (
         await readJsonFile(
           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 +369,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]);
@@ -382,7 +405,9 @@ export class Show {
    * Shows hubs of the project.
    * @returns list of hubs.
    */
-  public showHubs(): HubSetting[] {
+  public async showHubs(): Promise<HubSetting[]> {
+    // Ensure module list is up to date before showing
+    await this.fetchCmd.ensureModuleListUpToDate();
     return this.project.configuration.hubs;
   }
 
@@ -398,8 +423,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 +440,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 +453,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 +497,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 +546,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 +556,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;
   }
 }

package/src/commands/transition.ts

@@ -12,17 +12,29 @@
 */
 
 import { ActionGuard } from '../permissions/action-guard.js';
-import type {
-  CardType,
-  Workflow,
-  WorkflowState,
-} from '../interfaces/resource-interfaces.js';
 import { CardMetadataUpdater } from '../card-metadata-updater.js';
 import type { Project } from '../containers/project.js';
+import type { WorkflowState } from '../interfaces/resource-interfaces.js';
 
+/**
+ * Handles transitions.
+ */
 export class Transition {
+  /**
+   * Creates an instance of Transition command.
+   * @param project Project to use.
+   */
   constructor(private project: Project) {}
 
+  // Wrapper to run onTransition query.
+  private async transitionChangesQuery(cardKey: string, transition: string) {
+    if (!cardKey || !transition) return undefined;
+    return this.project.calculationEngine.runQuery('onTransition', 'localApp', {
+      cardKey,
+      transition,
+    });
+  }
+
   /**
    * Transitions a card from its current state to a new state.
    * @param cardKey card key
@@ -31,23 +43,18 @@ export class Transition {
   public async cardTransition(cardKey: string, transition: WorkflowState) {
     const card = this.project.findCard(cardKey);
 
-    // Card type
-    const cardType = this.project.resource<CardType>(
-      card.metadata?.cardType || '',
-    );
-    if (cardType === undefined) {
-      throw new Error(
-        `Card's card type '${card.metadata?.cardType}' does not exist in the project`,
-      );
+    if (!card.metadata?.cardType) {
+      throw new Error(`Card does not have card type`);
     }
+    // Card type
+    const cardType = this.project.resources
+      .byType(card.metadata?.cardType, 'cardTypes')
+      .show();
 
     // Workflow
-    const workflow = await this.project.resource<Workflow>(cardType.workflow);
-    if (workflow === undefined) {
-      throw new Error(
-        `Card's workflow '${cardType.workflow}' does not exist in the project`,
-      );
-    }
+    const workflow = this.project.resources
+      .byType(cardType.workflow, 'workflows')
+      .show();
 
     // Check that the state transition can be made "from".
     const foundFrom = workflow.transitions.find(
@@ -108,13 +115,4 @@ export class Transition {
         .catch((error) => console.error(error));
     }
   }
-
-  // Wrapper to run onTransition query.
-  private async transitionChangesQuery(cardKey: string, transition: string) {
-    if (!cardKey || !transition) return undefined;
-    return this.project.calculationEngine.runQuery('onTransition', 'localApp', {
-      cardKey,
-      transition,
-    });
-  }
 }

package/src/commands/update.ts

@@ -19,16 +19,39 @@ import type {
   RemoveOperation,
   UpdateOperations,
 } from '../resources/resource-object.js';
-import { Project } from '../containers/project.js';
-import { resourceName } from '../utils/resource-utils.js';
+import type { Project } from '../containers/project.js';
 import type { UpdateKey } from '../interfaces/resource-interfaces.js';
 
 /**
  * Class that handles 'update' commands.
  */
 export class Update {
+  /**
+   * Creates an instance of Update command.
+   * @param project Project to use.
+   */
   constructor(private project: Project) {}
 
+  /**
+   * 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 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,
+    K extends string,
+  >(name: string, updateKey: UpdateKey<K>, operation: OperationFor<Type, T>) {
+    const type = this.project.resources.extractType(name);
+    const resource = this.project.resources.byType(name, type);
+    await resource?.update(updateKey, operation);
+  }
+
   /**
    * Updates single resource property.
    * @param name Name of the resource to operate on.
@@ -95,24 +118,4 @@ export class Update {
       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 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,
-    K extends string,
-  >(name: string, updateKey: UpdateKey<K>, operation: OperationFor<Type, T>) {
-    const resource = Project.resourceObject(this.project, resourceName(name));
-    await resource?.update(updateKey, operation);
-    this.project.collectLocalResources();
-  }
 }