@cyberismo/data-handler 0.0.15 → 0.0.17

package/src/commands/import.ts

@@ -11,23 +11,33 @@
   License along with this program. If not, see <https://www.gnu.org/licenses/>.
 */
 
-import type { CardType } from '../interfaces/resource-interfaces.js';
-import { type Create, Validate } from './index.js';
 import { ModuleManager } from '../module-manager.js';
+import { readCsvFile } from '../utils/csv.js';
+import { Validate } from './validate.js';
+
+import type { Create } from './create.js';
 import type {
   Credentials,
   ModuleSettingOptions,
 } from '../interfaces/project-interfaces.js';
+import type { Fetch } from './fetch.js';
 import type { Project } from '../containers/project.js';
-import { readCsvFile } from '../utils/csv.js';
-import { resourceName } from '../utils/resource-utils.js';
-import { TemplateResource } from '../resources/template-resource.js';
 
+/**
+ * Handles all import commands.
+ */
 export class Import {
   private moduleManager: ModuleManager;
+
+  /**
+   * Creates an instance of Import.
+   * @param project Project to use.
+   * @param createCmd Instance of Create to use.
+   */
   constructor(
     private project: Project,
     private createCmd: Create,
+    private fetchCmd: Fetch,
   ) {
     this.moduleManager = new ModuleManager(this.project);
   }
@@ -53,9 +63,9 @@ export class Import {
 
     for (const row of csv) {
       const { title, template, description, labels, ...customFields } = row;
-      const templateResource = new TemplateResource(
-        this.project,
-        resourceName(template),
+      const templateResource = this.project.resources.byType(
+        template,
+        'templates',
       );
       const templateObject = templateResource.templateObject();
       if (!templateObject) {
@@ -78,13 +88,12 @@ export class Import {
       }
       const cardKey = cards[0].key;
       const card = this.project.findCard(cardKey);
-      const cardType = this.project.resource<CardType>(
-        card.metadata?.cardType || '',
-      );
-
-      if (!cardType) {
+      if (!card.metadata?.cardType) {
         throw new Error(`Card type not found for card ${cardKey}`);
       }
+      const cardType = this.project.resources
+        .byType(card.metadata?.cardType, 'cardTypes')
+        .show();
 
       if (description) {
         await this.project.updateCardContent(cardKey, description);
@@ -126,12 +135,17 @@ export class Import {
    * @param options Additional options for module import. Optional.
    *        branch: Git branch for module from Git.
    *        private: If true, uses credentials to clone the repository
+   * @param skipMigrationLog If true, skip logging to migration log (used during project creation)
    */
   public async importModule(
     source: string,
     destination?: string,
     options?: ModuleSettingOptions,
+    skipMigrationLog = false,
   ) {
+    // Ensure module list is up to date before importing
+    await this.fetchCmd.ensureModuleListUpToDate();
+
     const beforeImportValidateErrors = await Validate.getInstance().validate(
       this.project.basePath,
       () => this.project,
@@ -155,10 +169,13 @@ export class Import {
     };
 
     // Fetch module dependencies.
-    await this.moduleManager.updateModule(moduleSettings, options?.credentials);
+    await this.moduleManager.updateDependencies(
+      moduleSettings,
+      options?.credentials,
+    );
 
     // Add module as a dependency.
-    await this.project.importModule(moduleSettings);
+    await this.project.importModule(moduleSettings, skipMigrationLog);
 
     // Validate the project after module has been imported
     const afterImportValidateErrors = await Validate.getInstance().validate(
@@ -179,6 +196,9 @@ export class Import {
    * @throws if module is not part of the project
    */
   public async updateModule(moduleName: string, credentials?: Credentials) {
+    // Ensure module list is up to date before updating
+    await this.fetchCmd.ensureModuleListUpToDate();
+
     const module = this.project.configuration.modules.find(
       (item) => item.name === moduleName,
     );
@@ -193,6 +213,8 @@ export class Import {
    * @param credentials Optional credentials for private modules.
    */
   public async updateAllModules(credentials?: Credentials) {
+    // Ensure module list is up to date before updating all modules
+    await this.fetchCmd.ensureModuleListUpToDate();
     return this.moduleManager.updateModules(credentials);
   }
 }

package/src/commands/move.ts

@@ -197,7 +197,6 @@ export class Move {
     sourceCard.parent = movingToRoot ? ROOT : destination;
     if (sourceCard.metadata) {
       sourceCard.metadata.rank = rank;
-      sourceCard.metadata.parent = movingToRoot ? ROOT : destination;
     }
 
     // Handle cache update and persistence

package/src/commands/remove.ts

@@ -14,16 +14,23 @@
 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 { Fetch } from './fetch.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;
-  constructor(private project: Project) {
+  /**
+   * Creates a new instance of Remove command.
+   * @param project Project instance to use
+   */
+  constructor(
+    private project: Project,
+    private fetchCmd: Fetch,
+  ) {
     this.moduleManager = new ModuleManager(this.project);
   }
 
@@ -152,13 +159,19 @@ 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;
+    // Ensure module list is up to date when removing modules
+    if (type === 'module') {
+      await this.fetchCmd.ensureModuleListUpToDate();
+    }
 
     if (type === 'attachment' && rest.length !== 1 && !rest[0]) {
       throw new Error(
@@ -177,9 +190,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

@@ -17,20 +17,13 @@ import { join } from 'node:path';
 import { rename, readdir, readFile, writeFile } from 'node:fs/promises';
 
 import type { Card } from '../interfaces/project-interfaces.js';
+import {
+  ConfigurationLogger,
+  ConfigurationOperation,
+} from '../utils/configuration-logger.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 +34,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 +180,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 +204,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,9 +274,20 @@ 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');
 
+    // Remove these when operations properly update card cache
+    this.project.cardsCache.clear();
+    await this.project.populateCaches();
+
+    await ConfigurationLogger.log(
+      this.project.basePath,
+      ConfigurationOperation.PROJECT_RENAME,
+      this.to,
+      {},
+    );
+
     return this.project.calculationEngine.generate();
   }
 }