@cyberismo/data-handler 0.0.17 → 0.0.19

package/src/resources/template-resource.ts

@@ -39,6 +39,11 @@ export class TemplateResource extends FolderResource<TemplateMetadata, never> {
   private cardsFolder = '';
   private cardsSchema = super.contentSchemaContent('cardBaseSchema');
 
+  /**
+   * Creates an instance of TemplateResource
+   * @param project Project to use
+   * @param name Resource name
+   */
   constructor(project: Project, name: ResourceName) {
     super(project, name, 'templates');
 
@@ -63,6 +68,7 @@ export class TemplateResource extends FolderResource<TemplateMetadata, never> {
     await Promise.all([
       super.updateHandleBars(existingName, this.content.name),
       super.updateCalculations(existingName, this.content.name),
+      super.updateCardContentReferences(existingName, this.content.name),
     ]);
     await this.write();
   }
@@ -70,7 +76,6 @@ export class TemplateResource extends FolderResource<TemplateMetadata, never> {
   /**
    * Sets new metadata into the template object.
    * @param newContent metadata content for the template.
-   * @throws if 'newContent' is not valid.
    */
   public async create(newContent?: TemplateMetadata) {
     if (!newContent) {
@@ -140,35 +145,15 @@ export class TemplateResource extends FolderResource<TemplateMetadata, never> {
     updateKey: UpdateKey<K>,
     op: Operation<Type>,
   ) {
-    const { key } = updateKey;
-    const nameChange = key === 'name';
-    const existingName = this.content.name;
-
-    // Only call super.update for keys that base class supports
-    if (key === 'name' || key === 'displayName' || key === 'description') {
-      await super.update(updateKey, op);
-    }
-
-    const content = structuredClone(this.content);
-
-    if (key === 'name') {
-      content.name = super.handleScalar(op) as string;
-    } else if (key === 'displayName') {
-      content.displayName = super.handleScalar(op) as string;
-    } else if (key === 'description') {
-      content.description = super.handleScalar(op) as string;
-    } else if (key === 'category') {
+    if (updateKey.key === 'category') {
+      const content = structuredClone(this.content);
       content.category = super.handleScalar(op) as string;
-    } else {
-      throw new Error(`Unknown property '${key}' for Template`);
-    }
 
-    await super.postUpdate(content, updateKey, op);
-
-    // Renaming this template causes that references to its name must be updated.
-    if (nameChange) {
-      await this.onNameChange(existingName);
+      await super.postUpdate(content, updateKey, op);
+      return;
     }
+
+    await super.update(updateKey, op);
   }
 
   /**

package/src/resources/workflow-resource.ts

@@ -36,6 +36,11 @@ import type { ResourceName } from '../utils/resource-utils.js';
  * Workflow resource class.
  */
 export class WorkflowResource extends FileResource<Workflow> {
+  /**
+   * Creates an instance of WorkflowResource
+   * @param project Project to use
+   * @param name Resource name
+   */
   constructor(project: Project, name: ResourceName) {
     super(project, name, 'workflows');
 
@@ -49,17 +54,24 @@ export class WorkflowResource extends FileResource<Workflow> {
     const promises: Promise<Card[]>[] = [];
     for (const cardType of cardTypes) {
       if (cardType.data?.workflow === resourceNameToString(this.resourceName)) {
-        promises.push(this.collectCards(cardType.data.name));
+        promises.push(
+          this.collectCards(
+            cardType.data.name,
+            (card, cardTypeName) => card.metadata?.cardType === cardTypeName,
+          ),
+        );
       }
     }
     return (await Promise.all(promises)).flat();
   }
 
   // When resource name changes.
-  private async handleNameChange(existingName: string) {
+  protected async onNameChange(existingName: string) {
     await Promise.all([
       super.updateHandleBars(existingName, this.content.name),
       super.updateCalculations(existingName, this.content.name),
+      super.updateCardContentReferences(existingName, this.content.name),
+      this.updateCardTypes(existingName),
     ]);
     // Finally, write updated content.
     await this.write();
@@ -131,6 +143,11 @@ export class WorkflowResource extends FileResource<Workflow> {
     }
   }
 
+  // Check if operation is a string operation.
+  private isStringOperation(op: Operation<unknown>): op is Operation<string> {
+    return typeof op.target === 'string';
+  }
+
   // Returns target name irregardless of the type
   private targetName(op: Operation<WorkflowState | WorkflowTransition>) {
     const name = op.target.name ? op.target.name : op.target;
@@ -167,11 +184,6 @@ export class WorkflowResource extends FileResource<Workflow> {
     return op.to;
   }
 
-  // Check if operation is a string operation.
-  private isStringOperation(op: Operation<unknown>): op is Operation<string> {
-    return typeof op.target === 'string';
-  }
-
   // Update card states when state is changed
   private async updateCardStates(oldState: string, newState: string) {
     const cards = await this.collectCardsUsingWorkflow();
@@ -193,19 +205,21 @@ export class WorkflowResource extends FileResource<Workflow> {
       to: this.content.name,
     } as ChangeOperation<string>;
     for (const cardType of cardTypes) {
-      await cardType.update(
-        {
-          key: 'workflow',
-        },
-        op,
-      );
+      // Only update card types that use this workflow
+      if (cardType.data?.workflow === oldName) {
+        await cardType.update(
+          {
+            key: 'workflow',
+          },
+          op,
+        );
+      }
     }
   }
 
   /**
    * Sets new metadata into the workflow object.
    * @param newContent metadata content for the workflow.
-   * @throws if 'newContent' is not valid.
    */
   public async create(newContent?: Workflow) {
     if (!newContent) {
@@ -225,7 +239,7 @@ export class WorkflowResource extends FileResource<Workflow> {
   public async rename(newName: ResourceName) {
     const existingName = this.content.name;
     await super.rename(newName);
-    return this.handleNameChange(existingName);
+    return this.onNameChange(existingName);
   }
 
   /**
@@ -239,101 +253,106 @@ export class WorkflowResource extends FileResource<Workflow> {
     op: Operation<Type>,
   ) {
     const { key } = updateKey;
-    const nameChange = key === 'name';
-    const existingName = this.content.name;
 
-    await super.update(updateKey, op);
-
-    const content = structuredClone(this.content) as Workflow;
-
-    if (key === 'name') {
-      content.name = super.handleScalar(op) as string;
-    } else if (key === 'displayName') {
-      content.displayName = super.handleScalar(op) as string;
-    } else if (key === 'description') {
-      content.description = super.handleScalar(op) as string;
-    } else if (key === 'states') {
-      content.states = super.handleArray(
-        op,
-        key,
-        content.states as Type[],
-      ) as WorkflowState[];
-    } else if (key === 'transitions') {
-      content.transitions = super.handleArray(
-        op,
-        key,
-        content.transitions as WorkflowTransition[] as Type[],
-      ) as WorkflowTransition[];
+    if (key === 'name' || key === 'displayName' || key === 'description') {
+      await super.update(updateKey, op);
     } else {
-      throw new Error(`Unknown property '${key}' for Workflow`);
-    }
-
-    // If workflow transition is removed, then above call to 'handleArray' is all that is needed.
-
-    if (key === 'transitions' && op.name === 'change') {
-      // If workflow transition is changed, update to full object and change the content.
-      let changeOp: ChangeOperation<WorkflowTransition>;
-      if (this.isStringOperation(op)) {
-        const targetTransition = (this.content as Workflow).transitions.find(
-          (transition) => transition.name === op.target,
-        )!;
-        changeOp = {
-          name: 'change',
-          target: targetTransition as WorkflowTransition,
-          to: {
-            name: op.to,
-            toState: targetTransition.toState,
-            fromState: targetTransition.fromState,
-          },
-        };
-      } else {
-        changeOp = op as ChangeOperation<WorkflowTransition>;
+      const content = structuredClone(this.content) as Workflow;
+
+      // Validate state change operations before processing
+      if (key === 'states' && op.name === 'change') {
+        const changeOp = op as ChangeOperation<WorkflowState>;
+        if (
+          changeOp.to.name === undefined ||
+          changeOp.to.category === undefined
+        ) {
+          const stateName =
+            changeOp.target['name' as keyof typeof changeOp.target] ||
+            changeOp.target;
+          throw new Error(
+            `Cannot change state '${stateName}' for workflow '${this.content.name}'.
+         Updated state must have 'name' and 'category' properties.`,
+          );
+        }
       }
-      const newTransition = await this.transitionObject(changeOp);
-      content.transitions = content.transitions.map((item) =>
-        item.name == newTransition.name ? newTransition : item,
-      );
-    }
 
-    if (key === 'states' && op.name === 'remove') {
-      // If workflow state is removed, remove all transitions "to" and "from" this state.
-      let removeOp: RemoveOperation<WorkflowState>;
-      if (this.isStringOperation(op)) {
-        const toBeRemovedState = this.content.states.find(
-          (state) => state.name === op.target,
-        );
-        removeOp = {
-          name: 'remove',
-          target: toBeRemovedState as WorkflowState,
-        };
+      if (key === 'states') {
+        content.states = super.handleArray(
+          op,
+          key,
+          content.states as Type[],
+        ) as WorkflowState[];
+      } else if (key === 'transitions') {
+        content.transitions = super.handleArray(
+          op,
+          key,
+          content.transitions as WorkflowTransition[] as Type[],
+        ) as WorkflowTransition[];
       } else {
-        removeOp = op as RemoveOperation<WorkflowState>;
+        throw new Error(`Unknown property '${key}' for Workflow`);
       }
-      await this.handleStateRemoval(removeOp);
-    } else if (key === 'states' && op.name === 'change') {
-      // If workflow state is renamed, replace all transitions "to" and "from" the old state with new state.
-      let changeOp: ChangeOperation<WorkflowState>;
-      if (this.isStringOperation(op)) {
-        const toBeChangedState = this.content.states.find(
-          (state) => state.name === op.target,
+
+      // If workflow transition is removed, then above call to 'handleArray' is all that is needed.
+
+      if (key === 'transitions' && op.name === 'change') {
+        // If workflow transition is changed, update to full object and change the content.
+        let changeOp: ChangeOperation<WorkflowTransition>;
+        if (this.isStringOperation(op)) {
+          const targetTransition = (this.content as Workflow).transitions.find(
+            (transition) => transition.name === op.target,
+          )!;
+          changeOp = {
+            name: 'change',
+            target: targetTransition as WorkflowTransition,
+            to: {
+              name: op.to,
+              toState: targetTransition.toState,
+              fromState: targetTransition.fromState,
+            },
+          };
+        } else {
+          changeOp = op as ChangeOperation<WorkflowTransition>;
+        }
+        const newTransition = await this.transitionObject(changeOp);
+        content.transitions = content.transitions.map((item) =>
+          item.name == newTransition.name ? newTransition : item,
         );
-        changeOp = {
-          name: 'change',
-          target: toBeChangedState as WorkflowState,
-          to: { name: op.to },
-        };
-      } else {
-        changeOp = op as ChangeOperation<WorkflowState>;
       }
-      await this.handleStateChange(changeOp);
-    }
 
-    await super.postUpdate(content, updateKey, op);
+      if (key === 'states' && op.name === 'remove') {
+        // If workflow state is removed, remove all transitions "to" and "from" this state.
+        let removeOp: RemoveOperation<WorkflowState>;
+        if (this.isStringOperation(op)) {
+          const toBeRemovedState = this.content.states.find(
+            (state) => state.name === op.target,
+          );
+          removeOp = {
+            name: 'remove',
+            target: toBeRemovedState as WorkflowState,
+          };
+        } else {
+          removeOp = op as RemoveOperation<WorkflowState>;
+        }
+        await this.handleStateRemoval(removeOp);
+      } else if (key === 'states' && op.name === 'change') {
+        // If workflow state is renamed, replace all transitions "to" and "from" the old state with new state.
+        let changeOp: ChangeOperation<WorkflowState>;
+        if (this.isStringOperation(op)) {
+          const toBeChangedState = this.content.states.find(
+            (state) => state.name === op.target,
+          );
+          changeOp = {
+            name: 'change',
+            target: toBeChangedState as WorkflowState,
+            to: { name: op.to },
+          };
+        } else {
+          changeOp = op as ChangeOperation<WorkflowState>;
+        }
+        await this.handleStateChange(changeOp);
+      }
 
-    // Renaming this workflow causes that references to its name must be updated.
-    if (nameChange) {
-      await this.handleNameChange(existingName);
-      await this.updateCardTypes(existingName);
+      await super.postUpdate(content, updateKey, op);
     }
   }
 

package/src/utils/common-utils.ts

@@ -52,3 +52,18 @@ export function isBigInt(value: string): boolean {
     return false;
   }
 }
+
+/**
+ * Removes the first occurrence of a value from an array.
+ * Modifies the array in place.
+ * @param array The array to modify
+ * @param value The value to remove
+ * @returns The modified array (same reference as input)
+ */
+export function removeValue<T>(array: T[], value: T): T[] {
+  const index = array.findIndex((element) => element === value);
+  if (index !== -1) {
+    array.splice(index, 1);
+  }
+  return array;
+}

package/src/utils/file-utils.ts

@@ -17,6 +17,8 @@ import {
   mkdir,
   readdir,
   rm,
+  stat,
+  statfs,
   unlink,
   writeFile,
 } from 'node:fs/promises';
@@ -25,19 +27,17 @@ import { dirname, join, sep } from 'node:path';
 import { homedir } from 'node:os';
 
 /**
- * Works like the writeFile method, but ensures that the directory exists
- * There is only one difference: This method only supports a string as the filePath
+ * Get available disk space for a given path.
+ * @param path Path to check
+ * @returns Available space in bytes
  */
-export async function writeFileSafe(
-  filePath: string,
-  data: Parameters<typeof writeFile>[1],
-  options?: Parameters<typeof writeFile>[2],
-) {
-  const dir = dirname(filePath);
-  await mkdir(dir, {
-    recursive: true,
-  });
-  return writeFile(filePath, data, options);
+export async function availableSpace(path: string): Promise<number> {
+  try {
+    const stats = await statfs(path);
+    return stats.bavail * stats.bsize;
+  } catch (error) {
+    throw new Error(`Failed to check available disk space: ${error}`);
+  }
 }
 
 /**
@@ -87,6 +87,34 @@ export async function deleteFile(path: string): Promise<boolean> {
   return true;
 }
 
+/**
+ * Calculate the total size of a directory recursively.
+ * @param dirPath Path to directory
+ * @returns Size in bytes
+ */
+export async function folderSize(dirPath: string): Promise<number> {
+  let size = 0;
+
+  try {
+    const entries = await readdir(dirPath, { withFileTypes: true });
+
+    for (const entry of entries) {
+      const fullPath = join(dirPath, entry.name);
+
+      if (entry.isDirectory()) {
+        size += await folderSize(fullPath);
+      } else if (entry.isFile()) {
+        const stats = await stat(fullPath);
+        size += stats.size;
+      }
+    }
+  } catch {
+    // Ignore permission errors or missing directories
+  }
+
+  return size;
+}
+
 /**
  * Removes extension from filename.
  * @param filename Filename
@@ -180,3 +208,19 @@ export function resolveTilde(filePath: string): string {
  * Path separator RE.
  */
 export const sepRegex = /[/\\]/;
+
+/**
+ * Works like the writeFile method, but ensures that the directory exists
+ * There is only one difference: This method only supports a string as the filePath
+ */
+export async function writeFileSafe(
+  filePath: string,
+  data: Parameters<typeof writeFile>[1],
+  options?: Parameters<typeof writeFile>[2],
+) {
+  const dir = dirname(filePath);
+  await mkdir(dir, {
+    recursive: true,
+  });
+  return writeFile(filePath, data, options);
+}

package/src/utils/json.ts

@@ -28,9 +28,7 @@ export function readJsonFileSync(file: string) {
     return returnValue;
   } catch (error) {
     if (error instanceof Error) {
-      throw new Error(
-        `Error while handling JSON file '${file}' : ${error.message}`,
-      );
+      throw new Error(`Invalid JSON in file '${file}': ${error.message}`);
     }
   }
 }
@@ -47,9 +45,7 @@ export async function readJsonFile(file: string) {
     return JSON.parse(raw);
   } catch (error) {
     if (error instanceof Error) {
-      throw new Error(
-        `Error while handling JSON file '${file}' : ${error.message}`,
-      );
+      throw new Error(`Invalid JSON in file '${file}': ${error.message}`);
     }
   }
 }