@cyberismo/data-handler 0.0.14 → 0.0.16

package/dist/containers/project.js

@@ -12,261 +12,322 @@
   License along with this program. If not, see <https://www.gnu.org/licenses/>.
 */
 // node
-import { dirname, join, resolve, sep } from 'node:path';
-import { readdir } from 'node:fs/promises';
-import { CardContainer } from './card-container.js'; // base class
+import { basename, join, resolve } from 'node:path';
+import { constants as fsConstants, copyFile, mkdir, unlink, writeFile, } from 'node:fs/promises';
+// base class
+import { CardContainer } from './card-container.js';
 import { CalculationEngine } from './project/calculation-engine.js';
 import { CardLocation, } from '../interfaces/project-interfaces.js';
-import { getFilesSync, pathExists } from '../utils/file-utils.js';
+import { pathExists } from '../utils/file-utils.js';
 import { generateRandomString } from '../utils/random.js';
-import { isTemplateCard } from '../utils/card-utils.js';
+import { cardPathParts, isModulePath, isTemplateCard, } from '../utils/card-utils.js';
 import { ProjectConfiguration } from '../project-settings.js';
 import { ProjectPaths } from './project/project-paths.js';
 import { readJsonFile } from '../utils/json.js';
-import { resourceName, resourceNameToString, } from '../utils/resource-utils.js';
-import { ResourcesFrom, ResourceCollector, } from './project/resource-collector.js';
+import { ResourcesFrom } from './project/resource-cache.js';
+import { ResourceHandler } from './project/resource-handler.js';
 import { Validate } from '../commands/validate.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';
 import { ContentWatcher } from './project/project-content-watcher.js';
-import { pathToResourceName } from '../utils/resource-utils.js';
+import { getChildLogger } from '../utils/log-utils.js';
+import { ROOT } from '../utils/constants.js';
 // Re-export this, so that classes that use Project do not need to have separate import.
 export { ResourcesFrom };
 /**
  * Represents project folder.
  */
 export class Project extends CardContainer {
-    watchResourceChanges;
+    options;
     calculationEngine;
-    resources;
+    logger = getChildLogger({ module: 'Project' });
     projectPaths;
+    resourceHandler;
+    resourceWatcher;
     settings;
     validator;
-    resourceWatcher;
-    // Created resources are held in a cache.
-    // In the cache, key is resource name, and data is resource metadata (as JSON).
-    createdResources = new Map();
-    constructor(path, watchResourceChanges) {
-        super(path, '');
-        this.watchResourceChanges = watchResourceChanges;
+    constructor(path, options = {
+        autoSave: true,
+        watchResourceChanges: false,
+    }) {
+        const settings = new ProjectConfiguration(join(path, '.cards', 'local', Project.projectConfigFileName), options.autoSave ?? true);
+        super(path, settings.cardKeyPrefix, '');
+        this.options = options;
+        this.settings = settings;
+        this.logger.info({ path }, 'Initializing project');
         this.calculationEngine = new CalculationEngine(this);
-        this.settings = new ProjectConfiguration(join(path, '.cards', 'local', Project.projectConfigFileName));
         this.projectPaths = new ProjectPaths(path);
-        this.resources = new ResourceCollector(this);
+        this.resourceHandler = new ResourceHandler(this);
         this.containerName = this.settings.name;
         // todo: implement project validation
         this.validator = Validate.getInstance();
-        this.resources.collectLocalResources();
+        this.logger.info({ name: this.containerName }, 'Project initialization complete');
         const ignoreRenameFileChanges = true;
         // Watch changes in .cards if there are multiple instances of Project being
         // run concurrently.
-        if (this.watchResourceChanges) {
+        if (this.options.watchResourceChanges) {
             this.resourceWatcher = new ContentWatcher(ignoreRenameFileChanges, this.paths.resourcesFolder, (fileName) => {
                 void (async () => {
-                    let resource;
-                    try {
-                        resource = pathToResourceName(this, join(this.paths.resourcesFolder, fileName));
-                        if (!resource) {
-                            return;
-                        }
-                    }
-                    catch {
-                        // it wasn't a resource that changed, so ignore the change
-                        return;
-                    }
-                    const resourceName = `${resource.prefix}/${resource.type}/${resource.identifier}`;
-                    await this.replaceCacheValue(resourceName);
-                    this.resources.collectLocalResources();
+                    this.resources.handleFileSystemChange(join(this.paths.resourcesFolder, fileName));
+                    this.resources.changed();
                 })();
             });
         }
     }
-    // Removes current version of resource from cache.
-    // Then re-creates the resource with current data and caches the value again.
-    // If the value wasn't in the cache before, it will be added.
-    async replaceCacheValue(resourceName) {
-        if (this.createdResources.has(resourceName)) {
-            // First, remove the old version from cache
-            this.createdResources.delete(resourceName);
+    // Changes a card's parent in the cache and updates all relationships.
+    changeParent(updatedCard, previousParent) {
+        if (previousParent && previousParent !== ROOT) {
+            this.removeCachedChildren(previousParent, updatedCard.key);
         }
-        const resourceData = await this.resource(resourceName);
-        if (!resourceData)
-            return;
-        this.createdResources.set(resourceName, resourceData);
+        if (updatedCard.parent && updatedCard.parent !== ROOT) {
+            this.updateCachedChildren(updatedCard.parent, updatedCard);
+        }
+        this.cardCache.updateCard(updatedCard.key, updatedCard);
     }
     // Finds specific module.
     async findModule(moduleName) {
-        return (await this.resources.resources('modules')).find((item) => item.name === moduleName && item.path);
+        const moduleExists = this.resources.moduleNames().includes(moduleName);
+        if (!moduleExists) {
+            return undefined;
+        }
+        // For modules, we need to construct the local path where the module is stored
+        const moduleConfig = this.configuration.modules?.find((module) => module.name === moduleName);
+        if (!moduleConfig) {
+            return undefined;
+        }
+        return {
+            name: moduleName,
+            path: join(this.paths.modulesFolder, moduleConfig.name),
+        };
+    }
+    // Handles attachment changes after filesystem operations.
+    async handleAttachmentChange(cardKey, operation, fileName) {
+        if (operation === 'added') {
+            this.cardCache.addAttachment(cardKey, fileName);
+        }
+        else if (operation === 'removed') {
+            this.cardCache.deleteAttachment(cardKey, fileName);
+        }
+        else if (operation === 'refresh') {
+            const newAttachments = this.cardCache.getCardAttachments(cardKey);
+            if (newAttachments) {
+                this.cardCache.updateCardAttachments(cardKey, newAttachments);
+            }
+        }
+    }
+    // Determines the parent card key from a card's filesystem path.
+    // todo: could be moved to card-utils
+    parentFromPath(cardPath) {
+        return cardPathParts(this.projectPrefix, cardPath).parents.at(-1) || 'root';
+    }
+    // Remove children from a card in the card cache
+    removeCachedChildren(parentKey, childKey) {
+        const parentCard = this.cardCache.getCard(parentKey);
+        if (parentCard && parentCard.children) {
+            parentCard.children = parentCard.children.filter((child) => child !== childKey);
+            this.cardCache.updateCard(parentCard.key, parentCard);
+        }
+    }
+    // Updates children in the card cache
+    updateCachedChildren(parentKey, newChild) {
+        const parentCard = this.cardCache.getCard(parentKey);
+        if (parentCard) {
+            // Add or update the child in the parent's children array
+            const existingChildIndex = parentCard.children?.findIndex((child) => child === newChild.key);
+            if (existingChildIndex === -1) {
+                parentCard.children.push(newChild.key);
+            }
+            this.cardCache.updateCard(parentCard.key, parentCard);
+        }
+    }
+    // Validates that card's data is valid.
+    async validateCard(card) {
+        const invalidCustomData = await this.validator.validateCustomFields(this, card, this.projectPrefixes());
+        const invalidWorkFlow = await this.validator.validateWorkflowState(this, card);
+        const invalidLabels = this.validator.validateCardLabels(card);
+        if (invalidCustomData.length === 0 &&
+            invalidWorkFlow.length === 0 &&
+            invalidLabels.length === 0) {
+            return '';
+        }
+        const errors = [];
+        if (invalidCustomData.length > 0) {
+            errors.push(invalidCustomData);
+        }
+        if (invalidWorkFlow.length > 0) {
+            errors.push(invalidWorkFlow);
+        }
+        if (invalidLabels.length > 0) {
+            errors.push(invalidLabels);
+        }
+        return errors.join('\n');
     }
-    // Returns (local or all) resources of a given type.
-    // @todo: if this would be public, we could remove cardTypes(), fieldTypes(), ... and similar APIs
-    async resourcesOfType(type, from = ResourcesFrom.localOnly) {
-        return this.resources.resources(type, from);
+    /**
+     * Populate template cards into the card cache.
+     */
+    async populateTemplateCards() {
+        try {
+            const templateResources = this.resources.templates();
+            const prefixes = this.projectPrefixes();
+            const loadPromises = templateResources.map(async (template) => {
+                try {
+                    this.validator.validResourceName('templates', template.data?.name || '', prefixes);
+                }
+                catch (error) {
+                    this.logger.warn({ templateName: template, error }, `Template name '${template}' does not follow required format, skipping`);
+                    return;
+                }
+                const templateObject = template.templateObject();
+                const isCreated = templateObject && templateObject.isCreated();
+                if (!templateObject || !isCreated) {
+                    return;
+                }
+                await this.cardCache.populateFromPath(templateObject.templateCardsFolder(), false);
+            });
+            await Promise.all(loadPromises);
+            // Once all templates have been fetched, build child-parent relationships.
+            this.cardCache.populateChildrenRelationships();
+        }
+        catch (error) {
+            this.logger.error({ error }, 'Failed to populate template cards into the card cache');
+        }
+    }
+    /**
+     * Populate both the project cards, and all template cards into card cache.
+     */
+    async populateCardsCache() {
+        await this.cardCache.populateFromPath(this.paths.cardRootFolder);
+        await this.populateTemplateCards();
     }
     /**
-     * Add a given 'resource' to the local resource arrays.
-     * @param resource Resource to add.
-     * @param data JSON data for the resource.
+     * Returns all template cards from the project. This includes all module templates' cards.
+     * @returns all the template cards from the project
      */
-    addResource(resource, data) {
-        this.resources.add(resource);
-        this.createdResources.set(resource.name, data);
+    allTemplateCards() {
+        return this.cardCache.getAllTemplateCards();
     }
     /**
      * Returns an array of all the attachments in the project card's (excluding ones in templates).
      * @returns all attachments in the project.
      */
-    async attachments() {
+    attachments() {
         return super.attachments(this.paths.cardRootFolder);
     }
     /**
-     * Returns an array of all the calculation files (*.lp) in the project.
-     * @param from Defines where resources are collected from.
-     * @returns array of all calculation files in the project.
+     * Returns attachments from cards at a specific path using the card cache.
+     * This method allows templates to access attachments from the shared cache.
+     * @param path The path to get attachments from
+     * @returns Array of attachments from cards at the specified path
      */
-    async calculations(from = ResourcesFrom.all) {
-        return this.resources.resources('calculations', from);
+    attachmentsByPath(path) {
+        return super.attachments(path);
     }
     /**
-     * Returns path to card's attachment folder.
+     * Returns path to a card's attachment folder.
      * @param cardKey card key
-     * @returns path to card's attachment folder.
-     * @throws if card path cannot be found
+     * @returns path to a card's attachment folder.
      */
-    async cardAttachmentFolder(cardKey) {
-        // Check if it is a template card.
-        if (await this.isTemplateCard(cardKey)) {
-            const cardPath = await this.cardFolder(cardKey);
-            return join(cardPath, 'a');
-        }
-        const pathToProjectCard = this.pathToCard(cardKey);
-        if (!pathToProjectCard) {
-            throw new Error(`Card '${cardKey}' not found`);
-        }
-        return join(this.paths.cardRootFolder, pathToProjectCard, 'a');
+    cardAttachmentFolder(cardKey) {
+        const pathToCard = this.findCard(cardKey).path;
+        return join(pathToCard, 'a');
     }
     /**
-     * Returns details (as defined by cardDetails) of a card.
-     * @param cardKey card key (project prefix and a number, e.g. test_1)
-     * @param cardDetails which card details are returned.
-     * @returns Card details, or undefined if the card cannot be found.
+     * Creates an attachment for a card.
+     * @param cardKey The card to add attachment to
+     * @param attachmentName The name for the attachment file
+     * @param attachmentData The attachment data (file path or buffer)
+     * @throws If trying to add attachment to module card, or if attachment is not found
      */
-    async cardDetailsById(cardKey, cardDetails) {
-        return this.findSpecificCard(cardKey, cardDetails);
+    async createCardAttachment(cardKey, attachmentName, attachmentData) {
+        const attachmentFolder = this.cardAttachmentFolder(cardKey);
+        // Check if this is a module template
+        if (isModulePath(attachmentFolder)) {
+            throw new Error(`Cannot modify imported module`);
+        }
+        // Create the attachment folder if it doesn't exist
+        await mkdir(attachmentFolder, { recursive: true });
+        const attachmentPath = join(attachmentFolder, basename(attachmentName));
+        if (Buffer.isBuffer(attachmentData)) {
+            await writeFile(attachmentPath, attachmentData, { flag: 'wx' });
+        }
+        else {
+            try {
+                await copyFile(attachmentData, attachmentPath, fsConstants.COPYFILE_EXCL);
+            }
+            catch {
+                throw new Error(`Attachment file not found: ${attachmentData}`);
+            }
+        }
+        // Update cache
+        await this.handleAttachmentChange(cardKey, 'added', basename(attachmentName));
     }
     /**
-     * Returns path to card's folder.
+     * Returns path to a card's folder.
      * @param cardKey card key
-     * @returns path to card's folder.
+     * @returns path to a card's folder.
      */
     async cardFolder(cardKey) {
-        const found = await super.findCard(this.paths.cardRootFolder, cardKey);
+        const found = super.findCard(cardKey);
         if (found) {
             return found.path;
         }
-        const templates = await this.templates();
-        const templatePromises = templates.map(async (template) => {
-            const templateObject = new TemplateResource(this, resourceName(template.name)).templateObject();
+        const templates = this.resources.templates();
+        const templatePromises = templates.map((template) => {
+            const templateObject = template.templateObject();
             const templateCard = templateObject
-                ? await templateObject.findSpecificCard(cardKey)
+                ? templateObject.findCard(cardKey)
                 : undefined;
-            return templateCard ? templateCard.path : '';
+            const path = templateCard ? templateCard.path : '';
+            return path;
         });
         const templatePaths = await Promise.all(templatePromises);
         return templatePaths.find((path) => path !== '') || '';
     }
     /**
-     * Splits card path to parts. Returns the parts.
-     * Returned parts are: prefix, card key, array of parents and template name. Template name is returned only for template cards.
-     * @param cardPath path to a card
-     * @returns card path logical parts
-     * @throws when called with wrong path, or wrong card owner
-     * todo: if prefix would be parameter; this could be static, or util method
-     */
-    cardPathParts(cardPath) {
-        const pathParts = cardPath.split(sep);
-        const cardKey = pathParts.at(pathParts.length - 1);
-        const parents = [];
-        let prefix = this.projectPrefix;
-        let template = '';
-        let startIndex = -1;
-        let templatesNameIndex = -1;
-        const cardRootIndex = pathParts.indexOf('cardRoot');
-        const projectInternalsIndex = pathParts.indexOf('.cards');
-        if (projectInternalsIndex === -1 && cardRootIndex >= 0) {
-            startIndex = projectInternalsIndex;
-        }
-        else if (projectInternalsIndex >= 0 && cardRootIndex === -1) {
-            const templatesIndex = pathParts.indexOf('templates');
-            startIndex = templatesIndex;
-            if (templatesIndex === -1) {
-                throw new Error(`Invalid card path. Template card must have 'templates' in path`);
-            }
-            const modulesIndex = pathParts.indexOf('modules');
-            if (modulesIndex !== -1) {
-                prefix = pathParts.at(modulesIndex + 1) || '';
-            }
-            templatesNameIndex = templatesIndex + 1;
-            template = `${prefix}/templates/${pathParts.at(templatesNameIndex)}`;
-        }
-        else {
-            throw new Error(`Card must be either project card, or template card`);
-        }
-        // Look for parents in the path.
-        let previousWasParent = false;
-        for (let index = startIndex; index <= pathParts.length; index++) {
-            if (previousWasParent) {
-                previousWasParent = false;
-                parents.push(pathParts.at(index - 2));
-            }
-            const cardsSubFolder = pathParts.at(index) === 'c';
-            const ignoreOrNotTemplatesParent = index - 1 !== templatesNameIndex || templatesNameIndex === -1;
-            if (cardsSubFolder && ignoreOrNotTemplatesParent) {
-                previousWasParent = true;
+     * Fetches full Card data for given card keys
+     * @param cardIds array of card keys to fetch
+     * @returns Card data to the given card keys
+     */
+    cardKeysToCards(cardIds) {
+        const cards = [];
+        for (const cardId of cardIds) {
+            const card = this.cardCache.getCard(cardId);
+            if (card) {
+                cards.push(card);
             }
         }
-        return {
-            cardKey: cardKey,
-            parents: parents,
-            prefix: prefix,
-            template: template,
-        };
+        return cards;
     }
     /**
-     * Returns an array of all the cards in the project. Cards have content and metadata
-     * @param path Optional path from which to fetch the cards. Generally it is best to fetch from Project root, e.g. Project.cardRootFolder
-     * @param details Which details to include in the cards; by default only "content" and "metadata" are included.
+     * Returns an array of all the cards in the project.
+     * @note These are project cards only, by default (unless path dictates otherwise).
+     * @param path Path from which to fetch the cards. Generally it is best to fetch from Project root, e.g. Project.cardRootFolder
+     * @param details Which details to include in the cards; by default all details are included.
      * @returns all cards from the given path in the project.
      */
-    async cards(path = this.paths.cardRootFolder, details = { content: true, metadata: true }) {
+    cards(path = this.paths.cardRootFolder, details) {
         return super.cards(path, details);
     }
     /**
-     * Returns an array of all the card types in the project.
-     * @param from Defines where resources are collected from.
-     * @returns array of all card types in the project.
+     * Accessor for cards cache.
+     * Used by template container (it needs to access project's cache, not their own instance).
+     * @note Should not be used directly (other than Template).
      */
-    async cardTypes(from = ResourcesFrom.all) {
-        return this.resources.resources('cardTypes', from);
+    get cardsCache() {
+        return this.cardCache;
     }
     /**
-     * Updates all local resources.
+     * Returns children of a given card; as Card array
+     * @param card Parent card to fetch children from
+     * @returns children of a given card; as Card array
      */
-    collectLocalResources() {
-        this.resources.changed();
-    }
-    /**
-     * Updates all imported module resources.
-     */
-    async collectModuleResources() {
-        await this.resources.moduleImported();
+    childrenCards(card) {
+        const cards = [];
+        for (const child of card.children) {
+            const card = this.cardCache.getCard(child);
+            if (card) {
+                cards.push(card);
+            }
+        }
+        return cards;
     }
     /**
      * Returns project configuration.
@@ -284,8 +345,9 @@ export class Project extends CardContainer {
         if (!card || !card.path || !isTemplateCard(card)) {
             return undefined;
         }
-        const { template } = this.cardPathParts(card.path);
-        return new TemplateResource(this, resourceName(template)).templateObject();
+        const { template } = cardPathParts(this.projectPrefix, card.path);
+        const templateResource = this.resources.byType(template, 'templates');
+        return templateResource.templateObject();
     }
     /**
      * Cleanups project when it is being closed.
@@ -297,12 +359,13 @@ export class Project extends CardContainer {
         }
     }
     /**
-     * Returns an array of all the field types in the project.
-     * @param from Defines where resources are collected from.
-     * @returns array of all field types in the project.
+     * Returns specific card.
+     * @param cardToFind Card key to find
+     * @param details Defines which card details are included in the return values.
+     * @returns specific card details, or undefined if card is not part of the project.
      */
-    async fieldTypes(from = ResourcesFrom.all) {
-        return this.resources.resources('fieldTypes', from);
+    findCard(cardToFind, details) {
+        return super.findCard(cardToFind, details);
     }
     /**
      * Finds root of a project
@@ -320,128 +383,105 @@ export class Project extends CardContainer {
         }
         return Project.findProjectRoot(parentPath);
     }
-    /**
-     * Returns specific card.
-     * @param cardToFind Card key to find
-     * @param details Defines which card details are included in the return values.
-     * @returns specific card details, or undefined if card is not part of the project.
-     */
-    async findSpecificCard(cardToFind, details = {}) {
-        let card;
-        if (details.location === CardLocation.projectOnly ||
-            details.location === CardLocation.all ||
-            !details.location) {
-            card = await super.findCard(this.paths.cardRootFolder, cardToFind, details);
-        }
-        if (!card &&
-            (details.location === CardLocation.templatesOnly ||
-                details.location === CardLocation.all ||
-                !details.location)) {
-            const templates = await this.templates();
-            for (const template of templates) {
-                const templateObject = new TemplateResource(this, resourceName(template.name)).templateObject();
-                if (!templateObject)
-                    continue;
-                // optimize: execute each find in template parallel
-                card = await templateObject.findSpecificCard(cardToFind, details);
-                if (card) {
-                    break;
-                }
-            }
-        }
-        return card;
-    }
-    /**
-     * Returns an array of all the graph models in the project.
-     * @param from Defines where resources are collected from.
-     * @returns array of all the graph models in the project.
-     */
-    async graphModels(from = ResourcesFrom.all) {
-        return this.resources.resources('graphModels', from);
-    }
-    /**
-     * Returns an array of all the graph views in the project.
-     * @param from Defines where resources are collected from.
-     * @returns array of all the graph views in the project.
-     */
-    async graphViews(from = ResourcesFrom.all) {
-        return this.resources.resources('graphViews', from);
-    }
     /**
      * When card changes.
      * @param changedCard Card that was changed.
      */
     async handleCardChanged(changedCard) {
+        // Notify the calculation engine about the change
         return this.calculationEngine.handleCardChanged(changedCard);
     }
     /**
      * When cards are removed.
      * @param deletedCard Card that is to be removed.
      */
-    async handleDeleteCard(deletedCard) {
+    async handleCardDeleted(deletedCard) {
+        // Delete children from the cache first
+        if (deletedCard.children && deletedCard.children.length > 0) {
+            for (const child of deletedCard.children) {
+                try {
+                    const childCard = this.findCard(child);
+                    await this.handleCardDeleted(childCard);
+                }
+                catch {
+                    this.logger.warn(`Accessing child '${child}' of '${deletedCard.key}' when deleting cards caused an exception`);
+                    continue;
+                }
+            }
+        }
+        await super.removeCard(deletedCard.key);
         return this.calculationEngine.handleDeleteCard(deletedCard);
     }
+    /**
+     * When card is moved.
+     * @param movedCard Card that moved
+     * @param newParentCard New parent for the 'movedCard'
+     * @param oldParentCard Previous parent of the 'movedCard'
+     */
+    async handleCardMoved(movedCard, newParentCard, oldParentCard) {
+        if (newParentCard) {
+            this.cardCache.updateCard(newParentCard.key, newParentCard);
+        }
+        if (oldParentCard) {
+            this.cardCache.updateCard(oldParentCard.key, oldParentCard);
+        }
+        this.cardCache.updateCard(movedCard.key, movedCard);
+        // todo: it would be enough to just update parent, previous parent and changed card
+        this.cardCache.populateChildrenRelationships();
+        await this.handleCardChanged(movedCard);
+        await this.calculationEngine.handleCardMoved();
+    }
     /**
      * When new cards are added.
      * @param cards Added cards.
      */
     async handleNewCards(cards) {
+        // Add new cards to the card cache
+        cards.forEach((card) => {
+            const cardWithParent = {
+                ...card,
+                parent: card.parent || this.parentFromPath(card.path),
+            };
+            this.cardCache.updateCard(cardWithParent.key, cardWithParent);
+            // Update the parent's children list in the cache
+            if (cardWithParent.parent && cardWithParent.parent !== ROOT) {
+                this.updateCachedChildren(cardWithParent.parent, cardWithParent);
+            }
+        });
         return this.calculationEngine.handleNewCards(cards);
     }
-    /**
-     * Checks if a given card is part of this project.
-     * @param cardKey card to check.
-     * @returns true if a given card is found from project, false otherwise.
-     */
-    hasCard(cardKey) {
-        return super.hasCard(cardKey, this.paths.cardRootFolder);
-    }
     /**
      * Adds a module from project.
-     * @param module Name of the module
+     * @param module Module to add
      */
     async importModule(module) {
         // Add module as a dependency.
         await this.configuration.addModule(module);
-        await this.collectModuleResources();
+        this.resources.changedModules();
+        await this.populateTemplateCards();
+        this.logger.info(`Imported module '${module.name}'`);
     }
     /**
-     * Checks if given path is a project.
+     * Checks if a given path is a project.
      * @param path Path to a project
      * @returns true, if in the given path there is a project; false otherwise
      */
     static isCreated(path) {
         return pathExists(join(path, 'cardRoot'));
     }
-    /**
-     * Returns whether card is a template card or not
-     * @param cardKey card to check.
-     * @todo: This is only used from 'remove'. Could it use the static checker?
-     * @returns true, if card is template card; false otherwise
-     */
-    async isTemplateCard(cardKey) {
-        const templateCards = await this.allTemplateCards();
-        return templateCards.find((card) => card.key === cardKey) != null;
-    }
-    /**
-     * Returns an array of all the link types in the project.
-     * @param from Defines where resources are collected from.
-     * @returns array of all link types in the project.
-     */
-    async linkTypes(from = ResourcesFrom.all) {
-        return this.resources.resources('linkTypes', from);
-    }
     /**
      * Returns an array of cards in the project, in the templates or both.
      * Cards don't have content and nor metadata.
      * @param cardsFrom Where to return cards from (project, templates, or both)
-     * @returns all cards in the project.
+     * @returns all cards in the project per container.
      */
     async listCards(cardsFrom = CardLocation.all) {
         const cardListContainer = [];
         if (cardsFrom === CardLocation.all ||
             cardsFrom === CardLocation.projectOnly) {
-            const projectCards = (await super.cards(this.paths.cardRootFolder)).map((item) => item.key);
+            const projectCards = super
+                .cards(this.paths.cardRootFolder)
+                .map((item) => item.key);
             cardListContainer.push({
                 name: this.projectName,
                 type: 'project',
@@ -450,15 +490,15 @@ export class Project extends CardContainer {
         }
         if (cardsFrom === CardLocation.all ||
             cardsFrom === CardLocation.templatesOnly) {
-            const templates = await this.templates();
+            const templates = this.resources.templates();
             for (const template of templates) {
-                const templateObject = new TemplateResource(this, resourceName(template.name)).templateObject();
+                const templateObject = template.templateObject();
                 if (templateObject) {
                     // todo: optimization - do all this in parallel
-                    const templateCards = await templateObject.listCards();
-                    if (templateCards) {
+                    const templateCards = templateObject.listCards();
+                    if (templateCards.length) {
                         cardListContainer.push({
-                            name: template.name,
+                            name: template.data?.name || '',
                             type: 'template',
                             cards: templateCards.map((item) => item.key),
                         });
@@ -475,89 +515,43 @@ export class Project extends CardContainer {
      * @note that cardIDs are not sorted.
      */
     async listCardIds(cardsFrom = CardLocation.all) {
-        const promises = [];
-        if (cardsFrom === CardLocation.all ||
-            cardsFrom === CardLocation.projectOnly) {
-            promises.push(super
-                .cards(this.paths.cardRootFolder)
-                .then((cards) => new Set(cards.map((card) => card.key))));
+        const cardContainers = await this.listCards(cardsFrom);
+        const allCardIDs = new Set();
+        for (const container of cardContainers) {
+            const cards = container.cards;
+            cards.forEach((card) => allCardIDs.add(card));
         }
-        if (cardsFrom === CardLocation.all ||
-            cardsFrom === CardLocation.templatesOnly) {
-            promises.push((async () => {
-                const templates = await this.templates();
-                const templateResources = templates.map((template) => new TemplateResource(this, resourceName(template.name)));
-                const templateObjectsResults = await Promise.allSettled(templateResources);
-                const templateObjects = templateObjectsResults
-                    .filter((result) => result.status === 'fulfilled' && result.value !== null)
-                    .map((result) => result.value);
-                const listCardsResults = await Promise.allSettled(templateObjects.map((obj) => obj.templateObject().listCards()));
-                const templateCardIds = new Set();
-                listCardsResults
-                    .filter((result) => result.status === 'fulfilled')
-                    .forEach((result) => {
-                    result.value.forEach((card) => templateCardIds.add(card.key));
-                });
-                return templateCardIds;
-            })());
-        }
-        const allCardIdSets = await Promise.all(promises);
-        return new Set(allCardIdSets.flatMap((set) => [...set]));
+        return allCardIDs;
     }
     /**
      * Returns details of a certain module.
      * @param moduleName Name of the module.
-     * @returns module details, or undefined if workflow cannot be found.
+     * @returns module details, or undefined if module cannot be found.
      */
     async module(moduleName) {
         const module = await this.findModule(moduleName);
         if (module && module.path) {
-            const modulePath = join(module.path, module.name);
-            const moduleConfig = (await readJsonFile(join(modulePath, Project.projectConfigFileName)));
+            const modulePath = module.path;
+            const moduleConfig = await readJsonFile(join(modulePath, Project.projectConfigFileName));
             return {
                 name: moduleConfig.name,
                 modules: moduleConfig.modules,
                 hubs: moduleConfig.hubs,
                 path: modulePath,
                 cardKeyPrefix: moduleConfig.cardKeyPrefix,
-                calculations: [
-                    ...(await this.resources.collectResourcesFromModules('calculations', moduleName)),
-                ],
-                cardTypes: [
-                    ...(await this.resources.collectResourcesFromModules('cardTypes', moduleName)),
-                ],
-                fieldTypes: [
-                    ...(await this.resources.collectResourcesFromModules('fieldTypes', moduleName)),
-                ],
-                graphModels: [
-                    ...(await this.resources.collectResourcesFromModules('graphModels', moduleName)),
-                ],
-                graphViews: [
-                    ...(await this.resources.collectResourcesFromModules('graphViews', moduleName)),
-                ],
-                linkTypes: [
-                    ...(await this.resources.collectResourcesFromModules('linkTypes', moduleName)),
-                ],
-                reports: [
-                    ...(await this.resources.collectResourcesFromModules('reports', moduleName)),
-                ],
-                templates: [
-                    ...(await this.resources.collectResourcesFromModules('templates', moduleName)),
-                ],
-                workflows: [
-                    ...(await this.resources.collectResourcesFromModules('workflows', moduleName)),
-                ],
+                calculations: this.resources.moduleResourceNames('calculations', moduleName),
+                cardTypes: this.resources.moduleResourceNames('cardTypes', moduleName),
+                fieldTypes: this.resources.moduleResourceNames('fieldTypes', moduleName),
+                graphModels: this.resources.moduleResourceNames('graphModels', moduleName),
+                graphViews: this.resources.moduleResourceNames('graphViews', moduleName),
+                linkTypes: this.resources.moduleResourceNames('linkTypes', moduleName),
+                reports: this.resources.moduleResourceNames('reports', moduleName),
+                templates: this.resources.moduleResourceNames('templates', moduleName),
+                workflows: this.resources.moduleResourceNames('workflows', moduleName),
             };
         }
         return undefined;
     }
-    /**
-     * Returns list of modules in the project.
-     * @returns list of modules in the project.
-     */
-    async modules() {
-        return this.resources.resources('modules');
-    }
     /**
      * Returns a new unique card key with project prefix (e.g. test_x649it4x).
      * Random part of string will be always 8 characters in base-36 (0-9a-z)
@@ -624,15 +618,16 @@ export class Project extends CardContainer {
         return this.projectPaths;
     }
     /**
-     * Returns full path to a given card.
-     * @param cardKey card to check path for.
-     * @returns path to a given card.
+     * Populates the card cache, if it has not been populated.
      */
-    pathToCard(cardKey) {
-        const allFiles = getFilesSync(this.paths.cardRootFolder);
-        const cardIndexJsonFile = join(cardKey, Project.cardMetadataFile);
-        const foundFile = allFiles.find((file) => file.includes(cardIndexJsonFile));
-        return foundFile ? dirname(foundFile) : '';
+    async populateCaches() {
+        if (!this.cardCache.isPopulated) {
+            // Only collect modules that are registered in the project configuration
+            if (this.configuration.modules && this.configuration.modules.length > 0) {
+                this.resources.changedModules();
+            }
+            await this.populateCardsCache();
+        }
     }
     /**
      * Returns project name.
@@ -647,144 +642,60 @@ export class Project extends CardContainer {
         return this.settings.cardKeyPrefix;
     }
     /**
-     * Collects all prefixes used in the project (project's own plus all from modules).
+     * Returns all prefixes used in the project (project's own plus all from imported modules).
      * @returns all prefixes used in the project.
-     * @todo - move the module prefix fetch to resource-collector.
-     *        Make it use cached value that is only changed when  module is removed/imported.
      */
-    async projectPrefixes() {
+    projectPrefixes() {
         const prefixes = [this.projectPrefix];
-        let files;
-        try {
-            files = await readdir(this.paths.modulesFolder, {
-                withFileTypes: true,
-                recursive: true,
-            });
-            const configurationFiles = files
-                .filter((dirent) => dirent.isFile())
-                .filter((dirent) => dirent.name === Project.projectConfigFileName);
-            const configurationPromises = configurationFiles.map(async (file) => {
-                const configuration = (await readJsonFile(join(file.parentPath, file.name)));
-                return configuration.cardKeyPrefix;
-            });
-            const configurationPrefixes = await Promise.all(configurationPromises);
-            prefixes.push(...configurationPrefixes);
-        }
-        catch {
-            // do nothing if readdir throws // TODO: Log it
-        }
+        const moduleNames = this.configuration.modules.map((item) => item.name);
+        prefixes.push(...moduleNames);
         return prefixes;
     }
     /**
-     * Array of reports in the project.
-     * @param from Defines where resources are collected from.
-     * @returns array of all reports in the project.
+     * Removes an attachment from a card.
+     * @param cardKey The card to remove attachment from
+     * @param fileName The name of the attachment file to remove
+     * @throws if trying to remove module card attachment, or the attachment was not found.
      */
-    async reports(from = ResourcesFrom.all) {
-        return this.resources.resources('reports', from);
-    }
-    /**
-     * Returns handlebar files from reports.
-     * @param from Defines where report handlebar files are collected from.
-     * @returns handlebar files from reports.
-     */
-    async reportHandlerBarFiles(from = ResourcesFrom.all) {
-        const reports = await this.reports(from);
-        const handleBarFiles = [];
-        for (const reportResourceName of reports) {
-            const name = resourceName(reportResourceName.name);
-            const report = new ReportResource(this, name);
-            handleBarFiles.push(...(await report.handleBarFiles()));
+    async removeCardAttachment(cardKey, fileName) {
+        const attachmentFolder = this.cardAttachmentFolder(cardKey);
+        // Modules cannot be modified.
+        if (isModulePath(attachmentFolder)) {
+            throw new Error(`Cannot modify imported module`);
         }
-        return handleBarFiles;
-    }
-    /**
-     * Removes a resource from Project.
-     * @param resource Resource to remove.
-     */
-    removeResource(resource) {
-        this.resources.remove(resource);
-        this.createdResources.delete(resource.name);
-    }
-    /**
-     * Returns metadata from a given resource
-     * @param name Name of a resource
-     * @returns Metadata from the resource.
-     */
-    async resource(name) {
-        const resName = resourceName(name);
-        if (this.createdResources.has(resourceNameToString(resName))) {
-            const value = this.createdResources.get(resourceNameToString(resName));
-            return value;
-        }
-        let resource = undefined;
+        const attachmentPath = join(attachmentFolder, fileName);
         try {
-            resource = Project.resourceObject(this, resName);
+            await unlink(attachmentPath);
         }
-        catch {
-            return undefined;
+        catch (error) {
+            this.logger.error({ error }, 'Removing card attachment');
+            throw new Error(`Attachment not found: ${fileName}`);
         }
-        const data = resource?.data;
-        if (!data) {
-            return undefined;
-        }
-        return data;
+        await this.handleAttachmentChange(cardKey, 'removed', fileName);
     }
     /**
-     * Returns resource cache.
+     * Removes a module from the project cache and configuration.
+     * @note that ModuleManager removes the actual files.
+     * @param moduleName Module name to remove.
      */
-    get resourceCache() {
-        return this.createdResources;
+    async removeModule(moduleName) {
+        const toBeRemovedTemplates = this.resources.moduleResourceNames('templates', moduleName);
+        // First, remove template cards from the cache that are part of removed templates.
+        for (const templateName of toBeRemovedTemplates) {
+            this.cardCache.deleteCardsFromTemplate(templateName);
+        }
+        // Then, remove all module resources from cache
+        this.resources.removeModule(moduleName);
+        // Finally, remove module from project configuration
+        await this.configuration.removeModule(moduleName);
+        this.logger.info(`Removed module '${moduleName}'`);
     }
     /**
-     * Checks if a given resource exists in the project already.
-     * @param resourceType Type of resource as a string.
-     * @param name Valid name of resource.
-     * @returns boolean, true if resource exists; false otherwise.
+     * Accessor for resource handler.
+     * @returns Resource handler instance.
      */
-    async resourceExists(resourceType, name) {
-        const resources = await this.resourcesOfType(resourceType, ResourcesFrom.all);
-        const resource = resources.find((item) => item.name === name);
-        return resource !== undefined;
-    }
-    /**
-     * Instantiates resource object from project with a resource name.
-     * @note that this is memory based object only.
-     *       To manipulate the resource (create files, delete files etc), use the resource object's API.
-     * @param project Project from which resources are created from.
-     * @param name Resource name
-     * @throws if called with unsupported resource type.
-     * @returns Created resource.
-     */
-    static resourceObject(project, name) {
-        if (name.type === 'calculations') {
-            return new CalculationResource(project, name);
-        }
-        else if (name.type === 'cardTypes') {
-            return new CardTypeResource(project, name);
-        }
-        else if (name.type === 'fieldTypes') {
-            return new FieldTypeResource(project, name);
-        }
-        else if (name.type === 'graphModels') {
-            return new GraphModelResource(project, name);
-        }
-        else if (name.type === 'graphViews') {
-            return new GraphViewResource(project, name);
-        }
-        else if (name.type === 'linkTypes') {
-            return new LinkTypeResource(project, name);
-        }
-        else if (name.type === 'reports') {
-            return new ReportResource(project, name);
-        }
-        else if (name.type === 'templates') {
-            return new TemplateResource(project, name);
-        }
-        else if (name.type === 'workflows') {
-            return new WorkflowResource(project, name);
-        }
-        throw new Error(`Unsupported resource type '${resourceNameToString(name)}'`);
+    get resources() {
+        return this.resourceHandler;
     }
     /**
      * Shows details of a project.
@@ -796,7 +707,7 @@ export class Project extends CardContainer {
             path: this.basePath,
             prefix: this.projectPrefix,
             hubs: this.configuration.hubs,
-            modules: (await this.modules()).map((item) => item.name),
+            modules: this.resources.moduleNames(),
             numberOfCards: (await this.listCards(CardLocation.projectOnly))[0].cards
                 .length,
         };
@@ -805,57 +716,37 @@ export class Project extends CardContainer {
      * Show cards of a project.
      * @returns an array of all project cards in the project.
      */
-    async showProjectCards() {
+    showProjectCards() {
         return this.showCards(this.paths.cardRootFolder);
     }
-    /**
-     * Returns all template cards from the project. This includes all module templates' cards.
-     * @param cardDetails which details to fetch. Optional.
-     * @returns all the template cards from the project
-     */
-    async allTemplateCards(cardDetails) {
-        const templates = await this.templates();
-        const cards = [];
-        for (const template of templates) {
-            const templateCards = await this.templateCards(template.name, cardDetails);
-            if (templateCards)
-                cards.push(...templateCards);
-        }
-        return cards;
-    }
     /**
      * Returns cards from single template.
-     * @param templateName Name of the template
-     * @param cardDetails Card information
+     * @param templateName Name of the template (supports both full names like 'decision/templates/decision' and short names like 'decision')
      * @returns List of cards from template.
      */
-    async templateCards(templateName, cardDetails) {
-        const templateObject = new TemplateResource(this, resourceName(templateName)).templateObject();
-        return await templateObject?.cards('', cardDetails);
-    }
-    /**
-     * Array of templates in the project.
-     * @param from Defines where resources are collected from.
-     * @returns array of all templates in the project.
-     */
-    async templates(from = ResourcesFrom.all) {
-        return this.resources.resources('templates', from);
+    templateCards(templateName) {
+        const templateCards = this.cardCache.getAllTemplateCards();
+        return templateCards.filter((cachedCard) => {
+            if (cachedCard.location === 'project') {
+                return false;
+            }
+            return cachedCard.location === templateName;
+        });
     }
     /**
-     * Update card content.
-     * @param cardKey card's ID that is updated.
+     * Update a card's content.
+     * @param cardKey card key to update.
      * @param content changed content
      */
     async updateCardContent(cardKey, content) {
-        const card = await this.findCard(this.basePath, cardKey, {
-            metadata: true,
-            content: true,
-        });
-        if (!card) {
-            throw new Error(`Card '${cardKey}' does not exist in the project`);
-        }
+        const card = this.findCard(cardKey);
         card.content = content;
+        // Update lastUpdated timestamp in metadata
+        if (card.metadata) {
+            card.metadata.lastUpdated = new Date().toISOString();
+        }
         await this.saveCard(card);
+        await this.handleCardChanged(card);
     }
     /**
      * Updates card metadata's single key.
@@ -864,16 +755,13 @@ export class Project extends CardContainer {
      * @param newValue changed value for the key
      */
     async updateCardMetadataKey(cardKey, changedKey, newValue) {
-        const templateCard = await this.isTemplateCard(cardKey);
-        const card = await this.findCard(templateCard ? this.paths.templatesFolder : this.paths.cardRootFolder, cardKey, {
-            metadata: true,
-        });
-        if (!card) {
-            throw new Error(`Card '${cardKey}' does not exist in the project`);
-        }
+        const card = this.findCard(cardKey);
         if (!card.metadata || card.metadata[changedKey] === newValue) {
             return;
         }
+        const isRankChange = changedKey === 'rank';
+        const previousPath = isRankChange ? card.path : undefined;
+        const previousParent = isRankChange ? card.parent : undefined;
         const cardAsRecord = card.metadata;
         cardAsRecord[changedKey] = newValue;
         const invalidCard = isTemplateCard(card)
@@ -882,50 +770,52 @@ export class Project extends CardContainer {
         if (invalidCard.length !== 0) {
             throw new Error(invalidCard);
         }
-        await this.saveCardMetadata(card);
-    }
-    /**
-     * Updates card metadata.
-     * @param card affected card
-     * @param changedMetadata changed content for the card
-     */
-    async updateCardMetadata(card, changedMetadata) {
-        card.metadata = changedMetadata;
-        return this.saveCardMetadata(card);
+        const updated = await this.saveCardMetadata(card);
+        if (!updated)
+            return;
+        // For rank changes, check if path changed (indicating a move)
+        if (isRankChange) {
+            const updatedCard = this.findCard(cardKey);
+            if (updatedCard.path !== previousPath) {
+                this.changeParent(updatedCard, previousParent);
+            }
+        }
     }
     /**
-     * Validates that card's data is valid.
-     * @param card Card to validate.
-     * @returns validation errors, if any
+     * Updates the entire card in the card cache and handles any path/parent changes.
+     * Also persists changes to content and metadata files.
+     * @param card The card with updated information (path, parent, metadata, etc.)
      */
-    async validateCard(card) {
-        const invalidCustomData = await this.validator.validateCustomFields(this, card);
-        const invalidWorkFlow = await this.validator.validateWorkflowState(this, card);
-        const invalidLabels = await this.validator.validateCardLabels(card);
-        if (invalidCustomData.length === 0 &&
-            invalidWorkFlow.length === 0 &&
-            invalidLabels.length === 0) {
-            return '';
+    async updateCard(card) {
+        const cachedCard = this.cardCache.getCard(card.key);
+        const pathChange = cachedCard && cachedCard.path !== card.path;
+        if (pathChange) {
+            this.changeParent(card, cachedCard.parent);
         }
-        const errors = [];
-        if (invalidCustomData.length > 0) {
-            errors.push(invalidCustomData);
+        const metadataChanged = cachedCard &&
+            JSON.stringify(cachedCard.metadata) !== JSON.stringify(card.metadata);
+        if (metadataChanged) {
+            await this.saveCardMetadata(card);
         }
-        if (invalidWorkFlow.length > 0) {
-            errors.push(invalidWorkFlow);
+        const contentChanged = cachedCard && cachedCard.content !== card.content;
+        if (contentChanged) {
+            await this.saveCardContent(card);
         }
-        if (invalidLabels.length > 0) {
-            errors.push(invalidLabels);
+        this.cardCache.updateCard(card.key, card);
+        if (metadataChanged || contentChanged || pathChange) {
+            await this.handleCardChanged(card);
         }
-        return errors.join('\n');
     }
     /**
-     * Array of workflows in the project.
-     * @param from Defines where resources are collected from.
-     * @returns array of all workflows in the project.
+     * Updates a card's metadata.
+     * @param card affected card
+     * @param changedMetadata changed content for the card
      */
-    async workflows(from = ResourcesFrom.all) {
-        return this.resources.resources('workflows', from);
+    async updateCardMetadata(card, changedMetadata) {
+        card.metadata = changedMetadata;
+        if (await this.saveCardMetadata(card)) {
+            await this.handleCardChanged(card);
+        }
     }
 }
 //# sourceMappingURL=project.js.map