@cyberismo/data-handler 0.0.15 → 0.0.17

package/dist/containers/project.js

@@ -13,8 +13,10 @@
 */
 // node
 import { basename, join, resolve } from 'node:path';
-import { constants as fsConstants, copyFile, mkdir, readdir, unlink, writeFile, } from 'node:fs/promises';
-import { CardContainer } from './card-container.js'; // base class
+import { constants as fsConstants, copyFile, mkdir, unlink, writeFile, } from 'node:fs/promises';
+import { readdirSync } from 'node:fs';
+// base class
+import { CardContainer } from './card-container.js';
 import { CalculationEngine } from './project/calculation-engine.js';
 import { CardLocation, } from '../interfaces/project-interfaces.js';
 import { pathExists } from '../utils/file-utils.js';
@@ -23,73 +25,52 @@ import { cardPathParts, isModulePath, isTemplateCard, } from '../utils/card-util
 import { ProjectConfiguration } from '../project-settings.js';
 import { ProjectPaths } from './project/project-paths.js';
 import { readJsonFile } from '../utils/json.js';
-import { pathToResourceName, 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 { getChildLogger } from '../utils/log-utils.js';
 import { ROOT } from '../utils/constants.js';
+import { ConfigurationLogger, ConfigurationOperation, } from '../utils/configuration-logger.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;
-    // Created resources are held in a cache.
-    // In the cache, key is resource name, and data is resource metadata (as JSON).
-    createdResources = new Map();
     logger = getChildLogger({ module: 'Project' });
     projectPaths;
-    resources;
+    resourceHandler;
     resourceWatcher;
     settings;
     validator;
-    constructor(path, watchResourceChanges) {
-        const settings = new ProjectConfiguration(join(path, '.cards', 'local', Project.projectConfigFileName));
-        super(path, settings.cardKeyPrefix, '');
-        this.watchResourceChanges = watchResourceChanges;
+    cachedAllModulePrefixes = [];
+    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.projectPaths = new ProjectPaths(path);
-        this.resources = new ResourceCollector(this);
-        this.containerName = this.settings.name;
+        this.resourceHandler = new ResourceHandler(this);
         // todo: implement project validation
         this.validator = Validate.getInstance();
-        this.logger.info({ resourcesFolder: this.paths.resourcesFolder }, 'Collecting local resources');
-        this.resources.collectLocalResources();
-        this.logger.info({ name: this.containerName }, 'Project initialization complete');
+        this.logger.info({ name: this.settings.name }, 'Project initialization complete');
+        this.refreshAllModulePrefixes();
         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();
                 })();
             });
         }
@@ -106,7 +87,19 @@ export class Project extends CardContainer {
     }
     // 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) {
@@ -124,6 +117,7 @@ export class Project extends CardContainer {
         }
     }
     // 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';
     }
@@ -135,23 +129,6 @@ export class Project extends CardContainer {
             this.cardCache.updateCard(parentCard.key, parentCard);
         }
     }
-    // Removes current version of a resource from the resource 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);
-        }
-        const resourceData = await this.resource(resourceName);
-        if (resourceData) {
-            this.createdResources.set(resourceName, resourceData);
-        }
-    }
-    // Returns (local or all) resources of a given type.
-    async resourcesOfType(type, from = ResourcesFrom.localOnly) {
-        return this.resources.resources(type, from);
-    }
     // Updates children in the card cache
     updateCachedChildren(parentKey, newChild) {
         const parentCard = this.cardCache.getCard(parentKey);
@@ -164,24 +141,63 @@ export class Project extends CardContainer {
             this.cardCache.updateCard(parentCard.key, parentCard);
         }
     }
+    // Refreshes the cached list of all module prefixes.
+    // This includes both direct and transient module dependencies.
+    refreshAllModulePrefixes() {
+        const prefixes = [this.projectPrefix];
+        try {
+            const modules = readdirSync(this.paths.modulesFolder, {
+                withFileTypes: true,
+            })
+                .filter((item) => item.isDirectory())
+                .map((item) => item.name);
+            prefixes.push(...modules);
+        }
+        catch {
+            // If modules folder doesn't exist, fall back to configuration modules only
+            const moduleNames = this.configuration.modules.map((item) => item.name);
+            prefixes.push(...moduleNames);
+        }
+        this.cachedAllModulePrefixes = prefixes;
+    }
+    // Validates that card's data is valid.
+    async validateCard(card) {
+        const invalidCustomData = await this.validator.validateCustomFields(this, card, this.allModulePrefixes());
+        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');
+    }
     /**
      * Populate template cards into the card cache.
      */
     async populateTemplateCards() {
         try {
-            // Gets local & module templates
-            const templateResources = await this.templates();
-            const prefixes = await this.projectPrefixes();
+            const templateResources = this.resources.templates();
+            const prefixes = this.allModulePrefixes();
             const loadPromises = templateResources.map(async (template) => {
                 try {
-                    this.validator.validResourceName('templates', template.name, prefixes);
+                    this.validator.validResourceName('templates', template.data?.name || '', prefixes);
                 }
                 catch (error) {
-                    this.logger.warn({ templateName: template.name, error }, `Template name '${template.name}' does not follow required format, skipping`);
+                    this.logger.warn({ templateName: template, error }, `Template name '${template}' does not follow required format, skipping`);
                     return;
                 }
-                const templateResource = new TemplateResource(this, resourceName(template.name));
-                const templateObject = templateResource.templateObject();
+                const templateObject = template.templateObject();
                 const isCreated = templateObject && templateObject.isCreated();
                 if (!templateObject || !isCreated) {
                     return;
@@ -203,15 +219,6 @@ export class Project extends CardContainer {
         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.
-     */
-    addResource(resource, data) {
-        this.resources.add(resource);
-        this.createdResources.set(resource.name, data);
-    }
     /**
      * Returns all template cards from the project. This includes all module templates' cards.
      * @returns all the template cards from the project
@@ -235,30 +242,6 @@ export class Project extends CardContainer {
     attachmentsByPath(path) {
         return super.attachments(path);
     }
-    /**
-     * Returns all the attachments in the template cards.
-     * @returns all the attachments in the template cards.
-     */
-    async attachmentsFromTemplates() {
-        const templateAttachments = [];
-        const templates = await this.templates();
-        for (const template of templates) {
-            const templateResource = new TemplateResource(this, resourceName(template.name));
-            const templateObject = templateResource.templateObject();
-            if (templateObject) {
-                templateAttachments.push(...templateObject.attachments());
-            }
-        }
-        return templateAttachments;
-    }
-    /**
-     * 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.
-     */
-    async calculations(from = ResourcesFrom.all) {
-        return this.resources.resources('calculations', from);
-    }
     /**
      * Returns path to a card's attachment folder.
      * @param cardKey card key
@@ -298,28 +281,6 @@ export class Project extends CardContainer {
         // Update cache
         await this.handleAttachmentChange(cardKey, 'added', basename(attachmentName));
     }
-    /**
-     * 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 removeCardAttachment(cardKey, fileName) {
-        const attachmentFolder = this.cardAttachmentFolder(cardKey);
-        // Modules cannot be modified.
-        if (isModulePath(attachmentFolder)) {
-            throw new Error(`Cannot modify imported module`);
-        }
-        const attachmentPath = join(attachmentFolder, fileName);
-        try {
-            await unlink(attachmentPath);
-        }
-        catch (error) {
-            this.logger.error({ error }, 'Removing card attachment');
-            throw new Error(`Attachment not found: ${fileName}`);
-        }
-        await this.handleAttachmentChange(cardKey, 'removed', fileName);
-    }
     /**
      * Returns path to a card's folder.
      * @param cardKey card key
@@ -330,9 +291,9 @@ export class Project extends CardContainer {
         if (found) {
             return found.path;
         }
-        const templates = await this.templates();
+        const templates = this.resources.templates();
         const templatePromises = templates.map((template) => {
-            const templateObject = new TemplateResource(this, resourceName(template.name)).templateObject();
+            const templateObject = template.templateObject();
             const templateCard = templateObject
                 ? templateObject.findCard(cardKey)
                 : undefined;
@@ -357,14 +318,6 @@ export class Project extends CardContainer {
         }
         return cards;
     }
-    /**
-     * 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).
-     */
-    get cardsCache() {
-        return this.cardCache;
-    }
     /**
      * Returns an array of all the cards in the project.
      * @note These are project cards only, by default (unless path dictates otherwise).
@@ -376,12 +329,12 @@ export class Project extends CardContainer {
         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;
     }
     /**
      * Returns children of a given card; as Card array
@@ -398,18 +351,6 @@ export class Project extends CardContainer {
         }
         return cards;
     }
-    /**
-     * Updates all local resources.
-     */
-    collectLocalResources() {
-        this.resources.changed();
-    }
-    /**
-     * Updates all imported module resources.
-     */
-    collectModuleResources() {
-        this.resources.moduleImported();
-    }
     /**
      * Returns project configuration.
      * @returns project configuration.
@@ -427,7 +368,8 @@ export class Project extends CardContainer {
             return undefined;
         }
         const { template } = cardPathParts(this.projectPrefix, card.path);
-        return new TemplateResource(this, resourceName(template)).templateObject();
+        const templateResource = this.resources.byType(template, 'templates');
+        return templateResource.templateObject();
     }
     /**
      * Cleanups project when it is being closed.
@@ -439,12 +381,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
@@ -462,31 +405,6 @@ 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.
-     */
-    findCard(cardToFind, details) {
-        return super.findCard(cardToFind, details);
-    }
-    /**
-     * 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.
@@ -557,12 +475,24 @@ export class Project extends CardContainer {
     /**
      * Adds a module from project.
      * @param module Module to add
+     * @param skipMigrationLog If true, skip logging to migration log. Used during project creation.
      */
-    async importModule(module) {
+    async importModule(module, skipMigrationLog = false) {
         // Add module as a dependency.
         await this.configuration.addModule(module);
-        this.collectModuleResources();
+        this.resources.changedModules();
+        this.refreshAllModulePrefixes();
         await this.populateTemplateCards();
+        // Log configuration change
+        if (!skipMigrationLog) {
+            await ConfigurationLogger.log(this.basePath, ConfigurationOperation.MODULE_ADD, module.name, {
+                parameters: {
+                    location: module.location,
+                    branch: module.branch,
+                    private: module.private,
+                },
+            });
+        }
         this.logger.info(`Imported module '${module.name}'`);
     }
     /**
@@ -573,14 +503,6 @@ export class Project extends CardContainer {
     static isCreated(path) {
         return pathExists(join(path, 'cardRoot'));
     }
-    /**
-     * 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.
@@ -602,15 +524,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 = templateObject.listCards();
                     if (templateCards.length) {
                         cardListContainer.push({
-                            name: template.name,
+                            name: template.data?.name || '',
                             type: 'template',
                             cards: templateCards.map((item) => item.key),
                         });
@@ -643,7 +565,7 @@ export class Project extends CardContainer {
     async module(moduleName) {
         const module = await this.findModule(moduleName);
         if (module && module.path) {
-            const modulePath = join(module.path, module.name);
+            const modulePath = module.path;
             const moduleConfig = await readJsonFile(join(modulePath, Project.projectConfigFileName));
             return {
                 name: moduleConfig.name,
@@ -651,44 +573,19 @@ export class Project extends CardContainer {
                 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)
@@ -759,6 +656,10 @@ export class Project extends CardContainer {
      */
     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();
         }
     }
@@ -775,165 +676,72 @@ 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.
+     * This includes both direct dependencies and transient dependencies.
      * @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() {
-        const prefixes = [this.projectPrefix];
-        let files;
-        try {
-            // TODO: Could be optimized so that prefixes are stored once fetched.
-            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 (error) {
-            this.logger.error({ error }, 'Failed to collect prefixes in use');
-        }
-        return prefixes;
+    allModulePrefixes() {
+        return this.cachedAllModulePrefixes;
     }
     /**
-     * Removes a module from the project
-     * @param module Module (name) to remove.
+     * Returns prefixes for direct module dependencies only (from cardsConfig.json).
+     * @returns prefixes for direct module dependencies.
      */
-    async removeModule(moduleName) {
-        const toBeRemovedTemplates = this.resources.moduleResources.resourceArray('templates', moduleName);
-        // First, remove cards from the cache
-        for (const template of toBeRemovedTemplates) {
-            this.cardCache.deleteCardsFromTemplate(template.name);
-        }
-        // Then, remove module from project configuration
-        await this.configuration.removeModule(moduleName);
-        this.collectModuleResources();
-        this.logger.info(`Removed module '${moduleName}'`);
-    }
-    /**
-     * Removes a resource from Project.
-     * @param resource Resource to remove.
-     */
-    removeResource(resource) {
-        // Template cards must be removed from the cache when resource is removed.
-        if (resource.path.includes('templates')) {
-            const templateName = resourceNameToString(resourceName(resource.name));
-            this.cardCache.deleteCardsFromTemplate(templateName);
-        }
-        this.resources.remove(resource);
-        this.createdResources.delete(resource.name);
-    }
-    /**
-     * Array of reports in the project.
-     * @param from Defines where resources are collected from.
-     * @returns array of all reports in the project.
-     */
-    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()));
-        }
-        return handleBarFiles;
+    projectPrefixes() {
+        const prefixes = [this.projectPrefix];
+        const moduleNames = this.configuration.modules.map((item) => item.name);
+        prefixes.push(...moduleNames);
+        return prefixes;
     }
     /**
-     * Returns metadata from a given resource
-     * @param name Name of a resource
-     * @returns Metadata from the resource.
+     * 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.
      */
-    resource(name) {
-        const resName = resourceName(name);
-        if (this.createdResources.has(resourceNameToString(resName))) {
-            const value = this.createdResources.get(resourceNameToString(resName));
-            return value;
+    async removeCardAttachment(cardKey, fileName) {
+        const attachmentFolder = this.cardAttachmentFolder(cardKey);
+        // Modules cannot be modified.
+        if (isModulePath(attachmentFolder)) {
+            throw new Error(`Cannot modify imported module`);
         }
-        let resource = undefined;
+        const attachmentPath = join(attachmentFolder, fileName);
         try {
-            resource = Project.resourceObject(this, resName);
-        }
-        catch {
-            return undefined;
+            await unlink(attachmentPath);
         }
-        const data = resource?.data;
-        if (!data) {
-            return undefined;
+        catch (error) {
+            this.logger.error({ error }, 'Removing card attachment');
+            throw new Error(`Attachment not found: ${fileName}`);
         }
-        return data;
-    }
-    /**
-     * Returns resource cache.
-     */
-    get resourceCache() {
-        return this.createdResources;
+        await this.handleAttachmentChange(cardKey, 'removed', fileName);
     }
     /**
-     * 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.
+     * Removes a module from the project cache and configuration.
+     * @note that ModuleManager removes the actual files.
+     * @param moduleName Module name to remove.
      */
-    async resourceExists(resourceType, name) {
-        const resources = await this.resourcesOfType(resourceType, ResourcesFrom.all);
-        const resource = resources.find((item) => item.name === name);
-        return resource !== undefined;
+    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);
+        // Refresh cached module prefixes after removal
+        this.refreshAllModulePrefixes();
+        // Log configuration change
+        await ConfigurationLogger.log(this.basePath, ConfigurationOperation.MODULE_REMOVE, moduleName, {});
+        this.logger.info(`Removed module '${moduleName}'`);
     }
     /**
-     * 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.
+     * Accessor for resource handler.
+     * @returns Resource handler instance.
      */
-    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.
@@ -941,11 +749,11 @@ export class Project extends CardContainer {
      */
     async show() {
         return {
-            name: this.containerName,
+            name: this.settings.name,
             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,
         };
@@ -971,14 +779,6 @@ export class Project extends CardContainer {
             return cachedCard.location === templateName;
         });
     }
-    /**
-     * 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);
-    }
     /**
      * Update a card's content.
      * @param cardKey card key to update.
@@ -1063,35 +863,5 @@ export class Project extends CardContainer {
             await this.handleCardChanged(card);
         }
     }
-    // Validates that card's data is valid.
-    async validateCard(card) {
-        const invalidCustomData = await this.validator.validateCustomFields(this, card);
-        const invalidWorkFlow = 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');
-    }
-    /**
-     * Array of workflows in the project.
-     * @param from Defines where resources are collected from.
-     * @returns array of all workflows in the project.
-     */
-    async workflows(from = ResourcesFrom.all) {
-        return this.resources.resources('workflows', from);
-    }
 }
 //# sourceMappingURL=project.js.map