@cyberismo/data-handler 0.0.14 → 0.0.16

package/src/resources/create-defaults.ts

@@ -189,7 +189,8 @@ export abstract class DefaultContent {
   }
 
   /**
-   * Default template content
+   * Default template content.
+   * @param templateName Template name
    * @returns Default template content
    */
   public static template(templateName: string): TemplateMetadata {
@@ -201,7 +202,7 @@ export abstract class DefaultContent {
 
   /**
    * Default content for workflow JSON values.
-   * @param {string} workflowName workflow name
+   * @param workflowName workflow name
    * @returns Default content for workflow JSON values.
    */
   public static workflow(workflowName: string): Workflow {

package/src/resources/field-type-resource.ts

@@ -11,44 +11,40 @@
   License along with this program. If not, see <https://www.gnu.org/licenses/>.
 */
 
+import {
+  allowed,
+  fromDate,
+  fromNumber,
+  fromString,
+} from '../utils/value-utils.js';
+import { DefaultContent } from './create-defaults.js';
+import { FileResource } from './file-resource.js';
+import { resourceNameToString } from '../utils/resource-utils.js';
+import { sortCards } from '../utils/card-utils.js';
+
+import * as EmailValidator from 'email-validator';
+
 import type {
-  Card,
   ChangeOperation,
   Operation,
-  Project,
   RemoveOperation,
-  ResourceName,
-} from './file-resource.js';
-import {
-  DefaultContent,
-  FileResource,
-  ResourcesFrom,
-  resourceName,
-  resourceNameToString,
-  sortCards,
-} from './file-resource.js';
-
+} from './resource-object.js';
+import type { Card } from '../interfaces/project-interfaces.js';
 import type {
-  CardType,
   DataType,
   EnumDefinition,
   FieldType,
+  UpdateKey,
 } from '../interfaces/resource-interfaces.js';
-import { CardTypeResource } from './card-type-resource.js';
-import {
-  allowed,
-  fromDate,
-  fromNumber,
-  fromString,
-} from '../utils/value-utils.js';
-import * as EmailValidator from 'email-validator';
+import type { Project } from '../containers/project.js';
+import type { ResourceName } from '../utils/resource-utils.js';
 
 const SHORT_TEXT_MAX_LENGTH = 80;
 
 /**
  * Field type resource class.
  */
-export class FieldTypeResource extends FileResource {
+export class FieldTypeResource extends FileResource<FieldType> {
   // Initialize data type change helpers (fromType, toType) to some values.
   // The actual types are set, if this Field Type's dataType is changed.
   private fromType: DataType = 'integer';
@@ -59,8 +55,6 @@ export class FieldTypeResource extends FileResource {
 
     this.contentSchemaId = 'fieldTypeSchema';
     this.contentSchema = super.contentSchemaContent(this.contentSchemaId);
-
-    this.initialize();
   }
 
   // Cards from given array that include this field type.
@@ -130,21 +124,20 @@ export class FieldTypeResource extends FileResource {
     function affectedCard(card: Card): boolean {
       if (!card.metadata) return false;
       return cardTypesThatUseThisFieldType.some(
-        (item) => item === card.metadata!.cardType,
+        (item) => item === card.metadata?.cardType,
       );
     }
 
     // First collect the cardTypes that need to be updated.
-    const cardTypes = await this.relevantCardTypes(ResourcesFrom.localOnly);
+    const cardTypes = this.relevantCardTypes();
     cardTypesThatUseThisFieldType.push(...cardTypes);
 
     // Then collect cards (both project and local template) that use those card types.
-    const projectCards = (
-      await this.project.cards(this.project.paths.cardRootFolder, {
-        metadata: true,
-      })
-    ).filter((card) => affectedCard(card));
-    const templateCards = (await this.project.allTemplateCards())
+    const projectCards = this.project
+      .cards(this.project.paths.cardRootFolder)
+      .filter((card) => affectedCard(card));
+    const templateCards = this.project
+      .allTemplateCards()
       .filter((card) => !card.path.includes('modules'))
       .filter((card) => affectedCard(card));
     const allCards = [...projectCards, ...templateCards];
@@ -211,11 +204,9 @@ export class FieldTypeResource extends FileResource {
     if (!newValue) return;
 
     const removedValue = (op.target as EnumDefinition).enumValue;
-    const cardTypes = await this.relevantCardTypes(ResourcesFrom.localOnly);
+    const cardTypes = this.relevantCardTypes();
     const allCards = await Promise.all(
-      cardTypes.map((cardType) =>
-        this.collectCards({ metadata: true }, cardType),
-      ),
+      cardTypes.map((cardType) => this.collectCards(cardType)),
     );
     const cardsToUpdate = allCards
       .flat()
@@ -259,44 +250,35 @@ export class FieldTypeResource extends FileResource {
   }
 
   // Card types that use field type.
-  private async relevantCardTypes(from: ResourcesFrom): Promise<string[]> {
+  private relevantCardTypes(): string[] {
     const resourceName = resourceNameToString(this.resourceName);
-    const cardTypes = await this.project.cardTypes(from);
-
-    const references = await Promise.all(
-      cardTypes.map(async (cardType) => {
-        const metadata = await this.project.resource<CardType>(cardType.name);
-        return metadata?.customFields.some(
-          (field) => field.name === resourceName,
-        )
-          ? cardType.name
-          : '';
-      }),
-    );
-    // Remove empty values.
-    return references.filter(Boolean);
+    const cardTypes = this.project.resources.cardTypes();
+    const references = [];
+    for (const cardType of cardTypes) {
+      const found = cardType.data?.customFields.filter(
+        (field) => field.name === resourceName,
+      );
+      if (found && found.length > 0 && cardType.data)
+        references.push(cardType.data?.name);
+    }
+    return references;
   }
 
   // Update dependant card types
   private async updateCardTypes(oldName: string) {
-    const cardTypes = await this.project.cardTypes(ResourcesFrom.localOnly);
+    const cardTypes = this.project.resources.cardTypes();
     const op = {
       name: 'change',
       target: oldName,
       to: this.content.name,
     } as ChangeOperation<string>;
     for (const cardType of cardTypes) {
-      const object = new CardTypeResource(
-        this.project,
-        resourceName(cardType.name),
-      );
-      const data = object.data as CardType;
-      if (data) {
-        const found = data.customFields
-          ? data.customFields.find((item) => item.name === oldName)
+      if (cardType.data?.customFields) {
+        const found = cardType.data.customFields
+          ? cardType.data.customFields.find((item) => item.name === oldName)
           : undefined;
         if (found) {
-          await object.update('customFields', op);
+          await cardType.update({ key: 'customFields' }, op);
         }
       }
     }
@@ -322,20 +304,6 @@ export class FieldTypeResource extends FileResource {
     return super.create(content);
   }
 
-  /**
-   * Returns content data.
-   */
-  public get data(): FieldType {
-    return super.data as FieldType;
-  }
-
-  /**
-   * Deletes file(s) from disk and clears out the memory resident object.
-   */
-  public async delete() {
-    return super.delete();
-  }
-
   /**
    * Returns all possible field types.
    * @returns all possible field types.
@@ -407,33 +375,29 @@ export class FieldTypeResource extends FileResource {
     return this.handleNameChange(existingName);
   }
 
-  /**
-   * Shows metadata of the resource.
-   * @returns field type metadata.
-   */
-  public async show(): Promise<FieldType> {
-    return super.show() as Promise<FieldType>;
-  }
-
   /**
    * Updates field type resource.
-   * @param key Key to modify
+   * @param updateKey Key to modify
    * @param op Operation to perform on 'key'
    * @throws
    *  - when called with unknown data type
    *  - when called with data type conversion that cannot be done
    *  - when called with unknown property to update
    */
-  public async update<Type>(key: string, op: Operation<Type>) {
+  public async update<Type, K extends string>(
+    updateKey: UpdateKey<K>,
+    op: Operation<Type>,
+  ) {
+    const { key } = updateKey;
     const nameChange = key === 'name';
     const typeChange = key === 'dataType';
     const enumChange = key === 'enumValues';
     const existingName = this.content.name;
-    const existingType = (this.content as FieldType).dataType;
+    const existingType = this.content.dataType;
 
-    await super.update(key, op);
+    await super.update(updateKey, op);
 
-    const content = structuredClone(this.content) as FieldType;
+    const content = structuredClone(this.content);
     if (key === 'name') {
       content.name = super.handleScalar(op) as string;
     } else if (key === 'dataType') {
@@ -473,7 +437,7 @@ export class FieldTypeResource extends FileResource {
       throw new Error(`Unknown property '${key}' for FieldType`);
     }
 
-    await super.postUpdate(content, key, op);
+    await super.postUpdate(content, updateKey, op);
 
     if (nameChange) {
       // Renaming this field type causes that references to its name must be updated.
@@ -494,14 +458,14 @@ export class FieldTypeResource extends FileResource {
    * @returns array of card keys, resource names and calculation filenames that refer this resource.
    */
   public async usage(cards?: Card[]): Promise<string[]> {
-    const allCards = cards ?? (await super.cards());
+    const allCards = cards ?? super.cards();
 
-    const [cardContentReferences, relevantLinkTypes, calculations] =
-      await Promise.all([
-        super.usage(allCards),
-        this.relevantCardTypes(ResourcesFrom.all),
-        super.calculations(),
-      ]);
+    const relevantLinkTypes = this.relevantCardTypes();
+
+    const [cardContentReferences, calculations] = await Promise.all([
+      super.usage(allCards),
+      super.calculations(),
+    ]);
 
     const cardReferences = [
       ...this.cardsWithFieldType(allCards),
@@ -513,11 +477,4 @@ export class FieldTypeResource extends FileResource {
       ...new Set([...cardReferences, ...relevantLinkTypes, ...calculations]),
     ];
   }
-
-  /**
-   * Validates the resource. If object is invalid, throws.
-   */
-  public async validate(content?: object) {
-    return super.validate(content);
-  }
 }