@cyberismo/data-handler 0.0.14 → 0.0.16

package/src/commands/create.ts

@@ -12,41 +12,21 @@
 */
 
 // node
-import { basename, join, resolve, sep } from 'node:path';
-import {
-  constants as fsConstants,
-  copyFile,
-  mkdir,
-  writeFile,
-} from 'node:fs/promises';
+import { join, resolve } from 'node:path';
+import { mkdir, writeFile } from 'node:fs/promises';
 
+import { SCHEMA_VERSION } from '@cyberismo/assets';
 import { errorFunction } from '../utils/error-utils.js';
 import { Project } from '../containers/project.js';
-import { Validate } from './index.js';
+import { Validate } from './validate.js';
 
 import { EMPTY_RANK, sortItems } from '../utils/lexorank.js';
-import type {
-  DataType,
-  Link,
-  LinkType,
-} from '../interfaces/resource-interfaces.js';
-import { pathExists } from '../utils/file-utils.js';
+import { isModulePath } from '../utils/card-utils.js';
+import type { DataType } from '../interfaces/resource-interfaces.js';
 import type { Card, ProjectFile } from '../interfaces/project-interfaces.js';
 import { resourceName, resourceNameToString } from '../utils/resource-utils.js';
 import { writeJsonFile } from '../utils/json.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 MODULES_PATH = `${sep}modules${sep}`;
-
 // todo: Is there a easy to way to make JSON schema into a TypeScript interface/type?
 //       Check this out: https://www.npmjs.com/package/json-schema-to-ts
 
@@ -65,6 +45,7 @@ export class Create {
     {
       path: '.cards/local',
       content: {
+        schemaVersion: SCHEMA_VERSION,
         cardKeyPrefix: '$PROJECT-PREFIX',
         name: '$PROJECT-NAME',
         modules: [],
@@ -114,24 +95,14 @@ export class Create {
     if (cardTypeName === undefined) {
       throw new Error(`Input validation error: card type cannot be empty`);
     }
-    // Use slice to get a copy of a string.
-    const origTemplateName = templateName.slice(0);
-    const templateResource = new TemplateResource(
-      this.project,
-      resourceName(templateName),
+    const templateResource = this.project.resources.byType(
+      templateName,
+      'templates',
     );
     const templateObject = templateResource.templateObject();
+    const specificCard = card ? templateObject.findCard(card) : undefined;
 
-    const specificCard = card
-      ? await templateObject.findSpecificCard(card)
-      : undefined;
-    if (card && !specificCard) {
-      throw new Error(
-        `Card '${card}' was not found from template '${origTemplateName}'`,
-      );
-    }
-
-    if (templateObject.templateFolder().includes(`${sep}modules${sep}`)) {
+    if (isModulePath(templateObject.templateFolder())) {
       throw new Error(`Cannot add cards to imported module templates`);
     }
 
@@ -182,32 +153,12 @@ export class Create {
     attachment: string,
     buffer?: Buffer,
   ) {
-    if (!buffer && !pathExists(attachment)) {
-      throw new Error(
-        `Input validation error: cannot find attachment '${attachment}'`,
-      );
-    }
-    const attachmentFolder = await this.project.cardAttachmentFolder(cardKey);
-
-    // Imported templates cannot be modified.
-    // @todo: make MODULES_PATH project level constant
-    if (attachmentFolder.includes(MODULES_PATH)) {
-      throw new Error(`Cannot modify imported module`);
-    }
-
     try {
-      await mkdir(attachmentFolder, { recursive: true }).then(async () => {
-        if (!buffer) {
-          return copyFile(
-            attachment,
-            join(attachmentFolder, basename(attachment)),
-            fsConstants.COPYFILE_EXCL,
-          );
-        }
-        return writeFile(join(attachmentFolder, basename(attachment)), buffer, {
-          flag: 'wx',
-        });
-      });
+      await this.project.createCardAttachment(
+        cardKey,
+        attachment,
+        buffer || attachment,
+      );
     } catch (error) {
       throw new Error(errorFunction(error));
     }
@@ -218,11 +169,9 @@ export class Create {
    * @param calculationName name for the calculation resource
    */
   public async createCalculation(calculationName: string) {
-    const calculation = new CalculationResource(
-      this.project,
-      resourceName(calculationName),
-    );
-    await calculation.create();
+    return this.project.resources
+      .byType(calculationName, 'calculations')
+      .create();
   }
 
   /**
@@ -235,29 +184,22 @@ export class Create {
     templateName: string,
     parentCardKey?: string,
   ): Promise<Card[]> {
-    const templateResource = new TemplateResource(
-      this.project,
-      resourceName(templateName),
+    const templateResource = this.project.resources.byType(
+      templateName,
+      'templates',
     );
 
-    await Validate.getInstance().validResourceName(
+    Validate.getInstance().validResourceName(
       'templates',
       resourceNameToString(resourceName(templateName)),
-      await this.project.projectPrefixes(),
+      this.project.projectPrefixes(),
     );
 
     await templateResource.validate();
 
     const specificCard = parentCardKey
-      ? await this.project.findSpecificCard(parentCardKey, {
-          metadata: true,
-          children: true,
-        })
+      ? this.project.findCard(parentCardKey)
       : undefined;
-    if (parentCardKey && !specificCard) {
-      throw new Error(`Card '${parentCardKey}' not found from project`);
-    }
-
     const templateObject = templateResource.templateObject();
     if (!templateObject || !templateObject.isCreated()) {
       throw new Error(`Template '${templateName}' not found from project`);
@@ -265,7 +207,6 @@ export class Create {
 
     const createdCards = await templateObject.createCards(specificCard);
     if (createdCards.length > 0) {
-      await this.project.handleNewCards(createdCards);
       // Note: This assumes that parent keys will be ahead of 'a' in the sort order.
       const sorted = sortItems(createdCards, (item) => {
         return `${item.parent === 'root' ? 'a' : item.parent}${item.metadata?.rank || EMPTY_RANK}`;
@@ -281,12 +222,9 @@ export class Create {
    * @param workflowName workflow name to use in the card type.
    */
   public async createCardType(cardTypeName: string, workflowName: string) {
-    const cardType = new CardTypeResource(
-      this.project,
-      resourceName(cardTypeName),
-    );
-
-    await cardType.createCardType(workflowName);
+    return this.project.resources
+      .byType(cardTypeName, 'cardTypes')
+      .createCardType(workflowName);
   }
 
   /**
@@ -295,11 +233,9 @@ export class Create {
    * @param dataType data type for the field type
    */
   public async createFieldType(fieldTypeName: string, dataType: DataType) {
-    const fieldType = new FieldTypeResource(
-      this.project,
-      resourceName(fieldTypeName),
-    );
-    await fieldType.createFieldType(dataType);
+    return this.project.resources
+      .byType(fieldTypeName, 'fieldTypes')
+      .createFieldType(dataType);
   }
 
   /**
@@ -307,23 +243,17 @@ export class Create {
    * @param graphModelName name for the graph model.
    */
   public async createGraphModel(graphModelName: string) {
-    const graphModel = new GraphModelResource(
-      this.project,
-      resourceName(graphModelName),
-    );
-    await graphModel.create();
+    return this.project.resources
+      .byType(graphModelName, 'graphModels')
+      .create();
   }
 
   /**
    * Creates a new graph view.
-   * @param graphModelName name for the graph view.
+   * @param graphViewName name for the graph view.
    */
   public async createGraphView(graphViewName: string) {
-    const graphView = new GraphViewResource(
-      this.project,
-      resourceName(graphViewName),
-    );
-    await graphView.create();
+    return this.project.resources.byType(graphViewName, 'graphViews').create();
   }
 
   /**
@@ -336,13 +266,8 @@ export class Create {
       throw new Error(`Not a valid label name'`);
     }
 
-    const card = await this.project.findSpecificCard(cardKey, {
-      metadata: true,
-    });
-    if (!card) {
-      throw new Error(`Card '${cardKey}' does not exist in the project`);
-    }
-    const labels = card.metadata?.labels ?? [];
+    const card = this.project.findCard(cardKey);
+    const labels = structuredClone(card.metadata?.labels) ?? [];
 
     if (labels.includes(label)) {
       throw new Error('Label already exists');
@@ -357,11 +282,7 @@ export class Create {
    * @param linkTypeName name for the link type.
    */
   public async createLinkType(linkTypeName: string) {
-    const linkType = new LinkTypeResource(
-      this.project,
-      resourceName(linkTypeName),
-    );
-    await linkType.create();
+    return this.project.resources.byType(linkTypeName, 'linkTypes').create();
   }
 
   /**
@@ -382,29 +303,12 @@ export class Create {
     }
 
     // Determine the card path
-    const card = await this.project.findSpecificCard(cardKey, {
-      metadata: true,
-    });
-    if (!card) {
-      throw new Error(`Card '${cardKey}' does not exist in the project`);
-    }
-
-    const destinationCard = await this.project.findSpecificCard(
-      destinationCardKey,
-      {
-        metadata: true,
-      },
-    );
-    if (!destinationCard) {
-      throw new Error(
-        `Card '${destinationCardKey}' does not exist in the project`,
-      );
-    }
+    const card = this.project.findCard(cardKey);
+    const destinationCard = this.project.findCard(destinationCardKey);
     // make sure the link type exists
-    const linkTypeObject = await this.project.resource<LinkType>(linkType);
-    if (!linkTypeObject) {
-      throw new Error(`Link type '${linkType}' does not exist in the project`);
-    }
+    const linkTypeObject = this.project.resources
+      .byType(linkType, 'linkTypes')
+      .show();
 
     // make sure that if linkDescription is not enabled, linkDescription is not provided
     if (
@@ -453,7 +357,7 @@ export class Create {
       );
     }
 
-    const links: Link[] = card.metadata?.links || [];
+    const links = card.metadata?.links || [];
     links.push({
       linkType,
       cardKey: destinationCardKey,
@@ -482,6 +386,12 @@ export class Create {
 
     const projectFolders: string[] = ['.cards/local', 'cardRoot'];
 
+    if (!Validate.validateFolder(projectPath)) {
+      throw new Error(
+        `Input validation error: folder name '${projectPath}' is invalid`,
+      );
+    }
+
     if (
       projectPrefix === undefined ||
       projectPrefix.length < 3 ||
@@ -552,8 +462,7 @@ export class Create {
    * @param name name of the report
    */
   public async createReport(name: string) {
-    const report = new ReportResource(this.project, resourceName(name));
-    await report.createReport();
+    return this.project.resources.byType(name, 'reports').createReport();
   }
 
   /**
@@ -562,14 +471,9 @@ export class Create {
    * @param templateContent JSON content for the template file.
    */
   public async createTemplate(templateName: string, templateContent: string) {
-    const template = new TemplateResource(
-      this.project,
-      resourceName(templateName),
-    );
-
-    await template.create(
-      templateContent ? JSON.parse(templateContent) : undefined,
-    );
+    return this.project.resources
+      .byType(templateName, 'templates')
+      .create(templateContent ? JSON.parse(templateContent) : undefined);
   }
 
   /**
@@ -578,13 +482,8 @@ export class Create {
    * @param workflowContent workflow content JSON
    */
   public async createWorkflow(workflowName: string, workflowContent: string) {
-    const workflow = new WorkflowResource(
-      this.project,
-      resourceName(workflowName),
-    );
-
-    await workflow.create(
-      workflowContent ? JSON.parse(workflowContent) : undefined,
-    );
+    return this.project.resources
+      .byType(workflowName, 'workflows')
+      .create(workflowContent ? JSON.parse(workflowContent) : undefined);
   }
 }

package/src/commands/edit.ts

@@ -17,19 +17,10 @@ import { homedir } from 'node:os';
 import { spawnSync } from 'node:child_process';
 
 import { ActionGuard } from '../permissions/action-guard.js';
-import { CalculationResource } from '../resources/calculation-resource.js';
-import { FolderResource } from '../resources/folder-resource.js';
 import { Project } from '../containers/project.js';
-import { propertyName } from '../interfaces/folder-content-interfaces.js';
-import { resourceNameToString } from '../utils/resource-utils.js';
 import { UserPreferences } from '../utils/user-preferences.js';
 
-import type { ContentPropertyName } from '../interfaces/folder-content-interfaces.js';
-import type {
-  MetadataContent,
-  ResourceFolderType,
-} from '../interfaces/project-interfaces.js';
-import type { ResourceName } from '../utils/resource-utils.js';
+import type { MetadataContent } from '../interfaces/project-interfaces.js';
 
 export class Edit {
   private project: Project;
@@ -38,60 +29,12 @@ export class Edit {
     this.project = project;
   }
 
-  /**
-   * Updates a calculation file.
-   * @param resourceName The name of the resource to update.
-   * @param changedContent The new content for the calculation.
-   */
-  public async editCalculation(
-    resourceName: ResourceName,
-    changedContent: string,
-  ) {
-    if (resourceName.prefix !== this.project.projectPrefix) {
-      throw new Error(
-        `Resource '${resourceName.identifier}' is not a local resource`,
-      );
-    }
-    const resourceNameString = resourceNameToString(resourceName);
-    if (
-      !(await this.project.resourceExists(
-        resourceName.type as ResourceFolderType,
-        resourceNameString,
-      ))
-    ) {
-      throw new Error(
-        `Resource '${resourceNameString}' does not exist in the project`,
-      );
-    }
-    const calculationResource = new CalculationResource(
-      this.project,
-      resourceName,
-    );
-    const contentUpdateKey = {
-      key: 'content',
-      subKey: 'calculation',
-    };
-    await calculationResource.update(
-      // TODO: Let's fix this while we get rid of updating filenames directly a bit later.
-      contentUpdateKey as unknown as ContentPropertyName,
-      {
-        name: 'change',
-        target: resourceNameString,
-        to: changedContent,
-      },
-    );
-  }
-
   /**
    * Opens the content and metadata files for a card in the code editor
    * @param cardKey - The key of the card to open. Required.
    */
-  public async editCard(cardKey: string) {
-    // Determine the card path
-    const cardPath = this.project.pathToCard(cardKey);
-    if (!cardPath) {
-      throw new Error(`Card '${cardKey}' does not exist in the project`);
-    }
+  public editCard(cardKey: string) {
+    const card = this.project.findCard(cardKey);
 
     // Read the user preferences
     const prefs = new UserPreferences(
@@ -99,9 +42,8 @@ export class Edit {
     ).getPreferences();
 
     // Construct paths for the card components (json and adoc)
-    const cardDirPath = join(this.project.paths.cardRootFolder, cardPath);
-    const cardContentPath = join(cardDirPath, Project.cardContentFile);
-    const cardJsonPath = join(cardDirPath, Project.cardMetadataFile);
+    const cardContentPath = join(card.path, Project.cardContentFile);
+    const cardJsonPath = join(card.path, Project.cardMetadataFile);
 
     // Extract the editor settings from the preferences.
     const editorPrefs = prefs.editCommand[process.platform];
@@ -112,7 +54,7 @@ export class Edit {
     const editorArgs = editorArgPrefs.map((arg) => {
       arg = arg.replace(/\{\{\s*cardContentPath\s*\}\}/, cardContentPath);
       arg = arg.replace(/\{\{\s*cardJsonPath\s*\}\}/, cardJsonPath);
-      arg = arg.replace(/\{\{\s*cardDirPath\s*\}\}/, cardDirPath);
+      arg = arg.replace(/\{\{\s*cardDirPath\s*\}\}/, card.path);
 
       return arg;
     });
@@ -135,19 +77,14 @@ export class Edit {
    * @param changedContent New content for the card.
    */
   public async editCardContent(cardKey: string, changedContent: string) {
-    const isTemplateCard = await this.project.isTemplateCard(cardKey);
-    if (isTemplateCard) {
+    if (this.project.hasTemplateCard(cardKey)) {
       return this.project.updateCardContent(cardKey, changedContent);
     }
-    const cardPath = this.project.pathToCard(cardKey);
-    if (!cardPath) {
-      throw new Error(`Card '${cardKey}' does not exist in the project`);
+    if (this.project.findCard(cardKey)) {
+      const actionGuard = new ActionGuard(this.project.calculationEngine);
+      await actionGuard.checkPermission('editContent', cardKey);
+      await this.project.updateCardContent(cardKey, changedContent);
     }
-
-    const actionGuard = new ActionGuard(this.project.calculationEngine);
-    await actionGuard.checkPermission('editContent', cardKey);
-
-    await this.project.updateCardContent(cardKey, changedContent);
   }
 
   /**
@@ -164,68 +101,15 @@ export class Edit {
     if (!changedKey) {
       throw new Error(`Changed key cannot be empty`);
     }
-    const isTemplateCard = await this.project.isTemplateCard(cardKey);
-    if (isTemplateCard) {
+    if (this.project.hasTemplateCard(cardKey)) {
       return this.project.updateCardMetadataKey(cardKey, changedKey, newValue);
     }
 
-    // Determine the card path
-    const cardPath = this.project.pathToCard(cardKey);
-    if (!cardPath) {
-      throw new Error(`Card '${cardKey}' does not exist in the project`);
-    }
-
     // check for editing rights
-    const actionGuard = new ActionGuard(this.project.calculationEngine);
-    await actionGuard.checkPermission('editField', cardKey, changedKey);
-    await this.project.updateCardMetadataKey(cardKey, changedKey, newValue);
-  }
-
-  /**
-   * Update a file of a folder resource. Cannot be used to create a new file.
-   * @param resourceName The name of the resource to update.
-   * @param fileName The name of the file to update.
-   * @param changedContent The new content for the file.
-   */
-  public async editResourceContent(
-    resourceName: ResourceName,
-    fileName: string,
-    changedContent: string,
-  ) {
-    const resourceNameString = resourceNameToString(resourceName);
-    if (
-      !(await this.project.resourceExists(
-        resourceName.type as ResourceFolderType,
-        resourceNameString,
-      ))
-    ) {
-      throw new Error(
-        `Resource '${resourceNameString}' does not exist in the project`,
-      );
+    if (this.project.findCard(cardKey)) {
+      const actionGuard = new ActionGuard(this.project.calculationEngine);
+      await actionGuard.checkPermission('editField', cardKey, changedKey);
+      await this.project.updateCardMetadataKey(cardKey, changedKey, newValue);
     }
-    const resource = Project.resourceObject(this.project, resourceName);
-    if (!(resource instanceof FolderResource)) {
-      throw new Error(
-        `Resource '${resourceNameString}' is not a folder resource`,
-      );
-    }
-
-    // TODO: The caller should not pass filename, but content type
-    // Once that is in place, this check can be removed
-    const propName: ContentPropertyName | undefined = propertyName(fileName);
-    if (!propName) {
-      throw new Error(`File '${fileName}' is not allowed`);
-    }
-
-    const contentUpdateKey = {
-      key: 'content',
-      subKey: propName,
-    };
-    // TODO: Let's fix this while we get rid of updating filenames directly a bit later.
-    return resource.update(contentUpdateKey as unknown as ContentPropertyName, {
-      name: 'change',
-      target: '',
-      to: changedContent,
-    });
   }
 }