@cyberismo/data-handler 0.0.20 → 0.0.22

package/dist/commands/create.js

@@ -10,6 +10,40 @@
   details. You should have received a copy of the GNU Affero General Public
   License along with this program. If not, see <https://www.gnu.org/licenses/>.
 */
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
 // node
 import { join, resolve } from 'node:path';
 import { mkdir, writeFile } from 'node:fs/promises';
@@ -18,352 +52,418 @@ import { errorFunction } from '../utils/error-utils.js';
 import { Project } from '../containers/project.js';
 import { Validate } from './validate.js';
 import { EMPTY_RANK, sortItems } from '../utils/lexorank.js';
+import { ROOT } from '../utils/constants.js';
 import { isModulePath } from '../utils/card-utils.js';
 import { resourceName, resourceNameToString } from '../utils/resource-utils.js';
+import { write } from '../utils/rw-lock.js';
 import { writeJsonFile } from '../utils/json.js';
 // todo: Is there a easy to way to make JSON schema into a TypeScript interface/type?
 //       Check this out: https://www.npmjs.com/package/json-schema-to-ts
 /**
  * Handles all create commands.
  */
-export class Create {
-    project;
-    constructor(project) {
-        this.project = project;
-    }
-    static JSONFileContent = [
-        {
-            path: '.cards/local',
-            content: [{ id: 'cardsConfigSchema', version: 1 }],
-            name: Project.schemaContentFile,
-        },
-        {
-            path: '.cards/local',
-            content: {
-                schemaVersion: SCHEMA_VERSION,
-                cardKeyPrefix: '$PROJECT-PREFIX',
-                name: '$PROJECT-NAME',
-                description: '',
-                modules: [],
-                hubs: [],
-            },
-            name: Project.projectConfigFileName,
-        },
-    ];
-    static gitIgnoreContent = [
-        '.calc',
-        '.asciidoctor',
-        '.vscode',
-        '*.html',
-        '*.pdf',
-        '*.puml',
-        '**/.DS_Store',
-        '*-debug.log',
-        '*-error.log',
-        '.temp',
-        '.logs',
-        '.cache',
-    ];
-    /**
-     * Adds new cards to a template.
-     * @param cardTypeName Card type for new cards.
-     * @param templateName Template name to add cards into.
-     * @param card Optional, if defined adds a new child-card under the card.
-     * @param count How many cards to add. By default one.
-     * @returns non-empty string array with ids of added cards
-     */
-    async addCards(cardTypeName, templateName, card, count = 1) {
-        if (!templateName ||
-            !Validate.validateFolder(join(this.project.basePath, templateName))) {
-            throw new Error(`Input validation error: template name is invalid '${templateName}'`);
-        }
-        if (cardTypeName === undefined) {
-            throw new Error(`Input validation error: card type cannot be empty`);
+let Create = (() => {
+    let _instanceExtraInitializers = [];
+    let _addCards_decorators;
+    let _addHubLocation_decorators;
+    let _createAttachment_decorators;
+    let _createCalculation_decorators;
+    let _createCard_decorators;
+    let _createCardType_decorators;
+    let _createFieldType_decorators;
+    let _createGraphModel_decorators;
+    let _createGraphView_decorators;
+    let _createLabel_decorators;
+    let _createLinkType_decorators;
+    let _createLink_decorators;
+    let _createReport_decorators;
+    let _createTemplate_decorators;
+    let _createWorkflow_decorators;
+    return class Create {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            _addCards_decorators = [write((cardTypeName, templateName) => `Add cards of type ${cardTypeName} to template ${templateName}`)];
+            _addHubLocation_decorators = [write((hubUrl) => `Add hub ${hubUrl}`)];
+            _createAttachment_decorators = [write((cardKey, attachment) => `Add attachment ${attachment} to ${cardKey}`)];
+            _createCalculation_decorators = [write((calculationName) => `Create calculation ${calculationName}`)];
+            _createCard_decorators = [write((templateName) => `Create card from template ${templateName}`)];
+            _createCardType_decorators = [write((cardTypeName) => `Create card type ${cardTypeName}`)];
+            _createFieldType_decorators = [write((fieldTypeName) => `Create field type ${fieldTypeName}`)];
+            _createGraphModel_decorators = [write((graphModelName) => `Create graph model ${graphModelName}`)];
+            _createGraphView_decorators = [write((graphViewName) => `Create graph view ${graphViewName}`)];
+            _createLabel_decorators = [write((cardKey, label) => `Add label ${label} to ${cardKey}`)];
+            _createLinkType_decorators = [write((linkTypeName) => `Create link type ${linkTypeName}`)];
+            _createLink_decorators = [write((cardKey, destinationCardKey, linkType) => `Create ${linkType} link from ${cardKey} to ${destinationCardKey}`)];
+            _createReport_decorators = [write((name) => `Create report ${name}`)];
+            _createTemplate_decorators = [write((templateName) => `Create template ${templateName}`)];
+            _createWorkflow_decorators = [write((workflowName) => `Create workflow ${workflowName}`)];
+            __esDecorate(this, null, _addCards_decorators, { kind: "method", name: "addCards", static: false, private: false, access: { has: obj => "addCards" in obj, get: obj => obj.addCards }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _addHubLocation_decorators, { kind: "method", name: "addHubLocation", static: false, private: false, access: { has: obj => "addHubLocation" in obj, get: obj => obj.addHubLocation }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _createAttachment_decorators, { kind: "method", name: "createAttachment", static: false, private: false, access: { has: obj => "createAttachment" in obj, get: obj => obj.createAttachment }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _createCalculation_decorators, { kind: "method", name: "createCalculation", static: false, private: false, access: { has: obj => "createCalculation" in obj, get: obj => obj.createCalculation }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _createCard_decorators, { kind: "method", name: "createCard", static: false, private: false, access: { has: obj => "createCard" in obj, get: obj => obj.createCard }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _createCardType_decorators, { kind: "method", name: "createCardType", static: false, private: false, access: { has: obj => "createCardType" in obj, get: obj => obj.createCardType }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _createFieldType_decorators, { kind: "method", name: "createFieldType", static: false, private: false, access: { has: obj => "createFieldType" in obj, get: obj => obj.createFieldType }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _createGraphModel_decorators, { kind: "method", name: "createGraphModel", static: false, private: false, access: { has: obj => "createGraphModel" in obj, get: obj => obj.createGraphModel }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _createGraphView_decorators, { kind: "method", name: "createGraphView", static: false, private: false, access: { has: obj => "createGraphView" in obj, get: obj => obj.createGraphView }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _createLabel_decorators, { kind: "method", name: "createLabel", static: false, private: false, access: { has: obj => "createLabel" in obj, get: obj => obj.createLabel }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _createLinkType_decorators, { kind: "method", name: "createLinkType", static: false, private: false, access: { has: obj => "createLinkType" in obj, get: obj => obj.createLinkType }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _createLink_decorators, { kind: "method", name: "createLink", static: false, private: false, access: { has: obj => "createLink" in obj, get: obj => obj.createLink }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _createReport_decorators, { kind: "method", name: "createReport", static: false, private: false, access: { has: obj => "createReport" in obj, get: obj => obj.createReport }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _createTemplate_decorators, { kind: "method", name: "createTemplate", static: false, private: false, access: { has: obj => "createTemplate" in obj, get: obj => obj.createTemplate }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _createWorkflow_decorators, { kind: "method", name: "createWorkflow", static: false, private: false, access: { has: obj => "createWorkflow" in obj, get: obj => obj.createWorkflow }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
         }
-        const templateResource = this.project.resources.byType(templateName, 'templates');
-        const templateObject = templateResource.templateObject();
-        const specificCard = card ? templateObject.findCard(card) : undefined;
-        if (isModulePath(templateObject.templateFolder())) {
-            throw new Error(`Cannot add cards to imported module templates`);
+        project = __runInitializers(this, _instanceExtraInitializers);
+        constructor(project) {
+            this.project = project;
         }
-        // Collect all add-card promises and settle them in parallel.
-        const promiseContainer = [];
-        const cardsContainer = [];
-        for (let cardCount = 0; cardCount < count; ++cardCount) {
-            promiseContainer.push(templateObject.addCard(cardTypeName, specificCard));
-        }
-        const promisesResult = await Promise.allSettled(promiseContainer).then((results) => {
-            for (const result of results) {
-                if (result.status !== 'fulfilled') {
-                    throw new Error(result.reason);
-                }
-                cardsContainer.push(result.value);
+        static JSONFileContent = [
+            {
+                path: '.cards/local',
+                content: [{ id: 'cardsConfigSchema', version: 1 }],
+                name: Project.schemaContentFile,
+            },
+            {
+                path: '.cards/local',
+                content: {
+                    schemaVersion: SCHEMA_VERSION,
+                    cardKeyPrefix: '$PROJECT-PREFIX',
+                    name: '$PROJECT-NAME',
+                    description: '',
+                    modules: [],
+                    hubs: [],
+                },
+                name: Project.projectConfigFileName,
+            },
+        ];
+        static gitIgnoreContent = [
+            '.calc',
+            '.asciidoctor',
+            '.vscode',
+            '*.html',
+            '*.pdf',
+            '*.puml',
+            '**/.DS_Store',
+            '*-debug.log',
+            '*-error.log',
+            '.temp',
+            '.logs',
+            '.cache',
+        ];
+        /**
+         * Adds new cards to a template.
+         * @param cardTypeName Card type for new cards.
+         * @param templateName Template name to add cards into.
+         * @param card Optional, if defined adds a new child-card under the card.
+         * @param count How many cards to add. By default one.
+         * @returns non-empty string array with ids of added cards
+         */
+        async addCards(cardTypeName, templateName, card, count = 1) {
+            if (!templateName ||
+                !Validate.validateFolder(join(this.project.basePath, templateName))) {
+                throw new Error(`Input validation error: template name is invalid '${templateName}'`);
             }
-        });
-        if (cardsContainer.length === 0) {
-            throw new Error(`Invalid value for 'repeat:' "${count}"`);
-        }
-        if (promisesResult === undefined) {
-            return cardsContainer;
-        }
-        else {
-            throw new Error('Unknown error');
-        }
-    }
-    /**
-     * Adds a new hub location.
-     * @param hubUrl URL of the hub
-     */
-    async addHubLocation(hubUrl) {
-        return this.project.configuration.addHub(hubUrl);
-    }
-    /**
-     * Adds an attachment to a card.
-     * @param cardKey card ID
-     * @param attachment path to an attachment file or attachment name if buffer is defined
-     * @param buffer (Optional) attachment buffer
-     */
-    async createAttachment(cardKey, attachment, buffer) {
-        try {
-            await this.project.createCardAttachment(cardKey, attachment, buffer || attachment);
-        }
-        catch (error) {
-            throw new Error(errorFunction(error));
-        }
-    }
-    /**
-     * Creates a calculation resource.
-     * @param calculationName name for the calculation resource
-     */
-    async createCalculation(calculationName) {
-        return this.project.resources
-            .byType(calculationName, 'calculations')
-            .create();
-    }
-    /**
-     * Creates card(s) to a project. All cards from template are instantiated to the project.
-     * @param templateName name of a template to use
-     * @param parentCardKey (Optional) card-key of a parent card. If missing, cards are added to the card root.
-     * @returns array of card keys that were created. Cards are sorted by their parent key and rank. Template root cards are first but the order between other card groups is not guaranteed. However, the order of cards within a group is guaranteed to be ordered by rank.
-     */
-    async createCard(templateName, parentCardKey) {
-        const templateResource = this.project.resources.byType(templateName, 'templates');
-        Validate.getInstance().validResourceName('templates', resourceNameToString(resourceName(templateName)), this.project.allModulePrefixes());
-        await templateResource.validate();
-        const specificCard = parentCardKey
-            ? this.project.findCard(parentCardKey)
-            : undefined;
-        const templateObject = templateResource.templateObject();
-        if (!templateObject || !templateObject.isCreated()) {
-            throw new Error(`Template '${templateName}' not found from project`);
-        }
-        const createdCards = await templateObject.createCards(specificCard);
-        if (createdCards.length > 0) {
-            // Note: This assumes that parent keys will be ahead of 'a' in the sort order.
-            const sorted = sortItems(createdCards, (item) => {
-                return `${item.parent === 'root' ? 'a' : item.parent}${item.metadata?.rank || EMPTY_RANK}`;
+            if (cardTypeName === undefined) {
+                throw new Error(`Input validation error: card type cannot be empty`);
+            }
+            const templateResource = this.project.resources.byType(templateName, 'templates');
+            const templateObject = templateResource.templateObject();
+            const specificCard = card ? templateObject.findCard(card) : undefined;
+            if (isModulePath(templateObject.templateFolder())) {
+                throw new Error(`Cannot add cards to imported module templates`);
+            }
+            // Collect all add-card promises and settle them in parallel.
+            const promiseContainer = [];
+            const cardsContainer = [];
+            for (let cardCount = 0; cardCount < count; ++cardCount) {
+                promiseContainer.push(templateObject.addCard(cardTypeName, specificCard));
+            }
+            const promisesResult = await Promise.allSettled(promiseContainer).then((results) => {
+                for (const result of results) {
+                    if (result.status !== 'fulfilled') {
+                        throw new Error(result.reason);
+                    }
+                    cardsContainer.push(result.value);
+                }
             });
-            return sorted;
-        }
-        return [];
-    }
-    /**
-     * Creates a card type.
-     * @param cardTypeName name for the card type.
-     * @param workflowName workflow name to use in the card type.
-     */
-    async createCardType(cardTypeName, workflowName) {
-        return this.project.resources
-            .byType(cardTypeName, 'cardTypes')
-            .createCardType(workflowName);
-    }
-    /**
-     * Creates a new field type.
-     * @param fieldTypeName name for the field type.
-     * @param dataType data type for the field type
-     */
-    async createFieldType(fieldTypeName, dataType) {
-        return this.project.resources
-            .byType(fieldTypeName, 'fieldTypes')
-            .createFieldType(dataType);
-    }
-    /**
-     * Creates a new graph model.
-     * @param graphModelName name for the graph model.
-     */
-    async createGraphModel(graphModelName) {
-        return this.project.resources
-            .byType(graphModelName, 'graphModels')
-            .create();
-    }
-    /**
-     * Creates a new graph view.
-     * @param graphViewName name for the graph view.
-     */
-    async createGraphView(graphViewName) {
-        return this.project.resources.byType(graphViewName, 'graphViews').create();
-    }
-    /**
-     * Creates  a label in the given card
-     * @param cardKey The card to which the label is added to
-     * @param label The label being added
-     */
-    async createLabel(cardKey, label) {
-        if (!Validate.isValidLabelName(label)) {
-            throw new Error(`Not a valid label name'`);
-        }
-        const card = this.project.findCard(cardKey);
-        const labels = structuredClone(card.metadata?.labels) ?? [];
-        if (labels.includes(label)) {
-            throw new Error('Label already exists');
-        }
-        labels.push(label);
-        return this.project.updateCardMetadataKey(cardKey, 'labels', labels);
-    }
-    /**
-     * Creates a new link type.
-     * @param linkTypeName name for the link type.
-     */
-    async createLinkType(linkTypeName) {
-        return this.project.resources.byType(linkTypeName, 'linkTypes').create();
-    }
-    /**
-     * Creates a link between two cards.
-     * @param cardKey The card to update
-     * @param destinationCardKey The card to link to
-     * @param linkType The type of link to add
-     * @param linkDescription Optional description of the link
-     */
-    async createLink(cardKey, destinationCardKey, linkType, linkDescription) {
-        if (cardKey === destinationCardKey) {
-            throw new Error('Cannot link card to itself');
+            if (cardsContainer.length === 0) {
+                throw new Error(`Invalid value for 'repeat:' "${count}"`);
+            }
+            if (promisesResult === undefined) {
+                return cardsContainer;
+            }
+            else {
+                throw new Error('Unknown error');
+            }
         }
-        // Determine the card path
-        const card = this.project.findCard(cardKey);
-        const destinationCard = this.project.findCard(destinationCardKey);
-        // make sure the link type exists
-        const linkTypeObject = this.project.resources
-            .byType(linkType, 'linkTypes')
-            .show();
-        // make sure that if linkDescription is not enabled, linkDescription is not provided
-        if (!linkTypeObject.enableLinkDescription &&
-            linkDescription !== undefined) {
-            throw new Error(`Link type '${linkType}' does not allow link description`);
+        /**
+         * Adds a new hub location.
+         * @param hubUrl URL of the hub
+         */
+        async addHubLocation(hubUrl) {
+            return this.project.configuration.addHub(hubUrl);
         }
-        // make sure source card key exists in the link type sourceCardTypes
-        // if sourceCardTypes is empty, any card can be linked
-        if (linkTypeObject.sourceCardTypes.length > 0 &&
-            !linkTypeObject.sourceCardTypes.includes(card.metadata.cardType)) {
-            throw new Error(`Card type '${card.metadata?.cardType}' cannot be linked with link type '${linkType}'`);
+        /**
+         * Adds an attachment to a card.
+         * @param cardKey card ID
+         * @param attachment path to an attachment file or attachment name if buffer is defined
+         * @param buffer (Optional) attachment buffer
+         */
+        async createAttachment(cardKey, attachment, buffer) {
+            try {
+                await this.project.createCardAttachment(cardKey, attachment, buffer || attachment);
+            }
+            catch (error) {
+                throw new Error(errorFunction(error), { cause: error });
+            }
         }
-        // make sure destination card key exists in the link type destinationCardTypes
-        // if destinationCardTypes is empty, any card can be linked
-        if (linkTypeObject.destinationCardTypes.length > 0 &&
-            !linkTypeObject.destinationCardTypes.includes(destinationCard.metadata.cardType)) {
-            throw new Error(`Card type '${destinationCard.metadata.cardType}' cannot be linked with link type '${linkType}'`);
+        /**
+         * Creates a calculation resource.
+         * @param calculationName name for the calculation resource
+         */
+        async createCalculation(calculationName) {
+            return this.project.resources
+                .byType(calculationName, 'calculations')
+                .create();
         }
-        // if contains the same link, do not add it again
-        const existingLink = card.metadata?.links.find((l) => l.linkType === linkType &&
-            l.cardKey === destinationCardKey &&
-            l.linkDescription === linkDescription);
-        if (existingLink) {
-            throw new Error(`Link from card '${cardKey}' to card '${destinationCardKey}' already exists`);
+        /**
+         * Creates card(s) to a project. All cards from template are instantiated to the project.
+         * @param templateName name of a template to use
+         * @param parentCardKey (Optional) card-key of a parent card. If missing, cards are added to the card root.
+         * @returns array of card keys that were created. Cards are sorted by their parent key and rank. Template root cards are first but the order between other card groups is not guaranteed. However, the order of cards within a group is guaranteed to be ordered by rank.
+         */
+        async createCard(templateName, parentCardKey) {
+            const templateResource = this.project.resources.byType(templateName, 'templates');
+            Validate.getInstance().validResourceName('templates', resourceNameToString(resourceName(templateName)), this.project.allModulePrefixes());
+            await templateResource.validate();
+            const specificCard = parentCardKey
+                ? this.project.findCard(parentCardKey)
+                : undefined;
+            const templateObject = templateResource.templateObject();
+            if (!templateObject || !templateObject.isCreated()) {
+                throw new Error(`Template '${templateName}' not found from project`);
+            }
+            const createdCards = await templateObject.createCards(specificCard);
+            if (createdCards.length > 0) {
+                const rootParent = specificCard?.key ?? ROOT;
+                const rootCards = [];
+                const childCards = [];
+                for (const card of createdCards) {
+                    if (card.parent === rootParent) {
+                        rootCards.push(card);
+                    }
+                    else {
+                        childCards.push(card);
+                    }
+                }
+                return [
+                    ...sortItems(rootCards, (item) => item.metadata?.rank || EMPTY_RANK),
+                    ...childCards,
+                ];
+            }
+            return [];
         }
-        const links = card.metadata?.links || [];
-        links.push({
-            linkType,
-            cardKey: destinationCardKey,
-            linkDescription,
-        });
-        await this.project.updateCardMetadataKey(cardKey, 'links', links);
-    }
-    /**
-     * Creates a new project.
-     * @param projectPath where to create the project.
-     * @param projectPrefix prefix for the project.
-     * @param projectName name for the project.
-     * @param projectCategory category for the project (empty string if not provided).
-     * @param projectDescription description for the project (empty string if not provided).
-     */
-    static async createProject(projectPath, projectPrefix, projectName, projectCategory, projectDescription) {
-        projectPath = resolve(projectPath);
-        if (!projectPath) {
-            throw new Error('Cannot create project without a path');
+        /**
+         * Creates a card type.
+         * @param cardTypeName name for the card type.
+         * @param workflowName workflow name to use in the card type.
+         */
+        async createCardType(cardTypeName, workflowName) {
+            return this.project.resources
+                .byType(cardTypeName, 'cardTypes')
+                .createCardType(workflowName);
         }
-        const projectFolders = ['.cards/local', 'cardRoot'];
-        if (!Validate.validateFolder(projectPath)) {
-            throw new Error(`Input validation error: folder name '${projectPath}' is invalid`);
+        /**
+         * Creates a new field type.
+         * @param fieldTypeName name for the field type.
+         * @param dataType data type for the field type
+         */
+        async createFieldType(fieldTypeName, dataType) {
+            return this.project.resources
+                .byType(fieldTypeName, 'fieldTypes')
+                .createFieldType(dataType);
         }
-        if (projectPrefix === undefined ||
-            projectPrefix.length < 3 ||
-            projectPrefix.length > 10) {
-            throw new Error(`Input validation error: prefix must be from 3 to 10 characters long. '${projectPrefix}' does not fulfill the condition.`);
+        /**
+         * Creates a new graph model.
+         * @param graphModelName name for the graph model.
+         */
+        async createGraphModel(graphModelName) {
+            return this.project.resources
+                .byType(graphModelName, 'graphModels')
+                .create();
         }
-        if (!Validate.isValidProjectName(projectName)) {
-            throw new Error(`Input validation error: invalid project name '${projectName}'`);
+        /**
+         * Creates a new graph view.
+         * @param graphViewName name for the graph view.
+         */
+        async createGraphView(graphViewName) {
+            return this.project.resources.byType(graphViewName, 'graphViews').create();
         }
-        if (!Validate.validatePrefix(projectPrefix)) {
-            throw new Error(`Input validation error: invalid prefix '${projectPrefix}'`);
+        /**
+         * Creates  a label in the given card
+         * @param cardKey The card to which the label is added to
+         * @param label The label being added
+         */
+        async createLabel(cardKey, label) {
+            if (!Validate.isValidLabelName(label)) {
+                throw new Error(`Not a valid label name'`);
+            }
+            const card = this.project.findCard(cardKey);
+            const labels = structuredClone(card.metadata?.labels) ?? [];
+            if (labels.includes(label)) {
+                throw new Error('Label already exists');
+            }
+            labels.push(label);
+            return this.project.updateCardMetadataKey(cardKey, 'labels', labels);
         }
-        if (Project.isCreated(projectPath)) {
-            throw new Error('Project already exists');
+        /**
+         * Creates a new link type.
+         * @param linkTypeName name for the link type.
+         */
+        async createLinkType(linkTypeName) {
+            return this.project.resources.byType(linkTypeName, 'linkTypes').create();
         }
-        if (!Validate.isValidProjectName(projectName)) {
-            throw new Error(`Input validation error: invalid project name '${projectName}'`);
+        /**
+         * Creates a link between two cards.
+         * @param cardKey The card to update
+         * @param destinationCardKey The card to link to
+         * @param linkType The type of link to add
+         * @param linkDescription Optional description of the link
+         */
+        async createLink(cardKey, destinationCardKey, linkType, linkDescription) {
+            if (cardKey === destinationCardKey) {
+                throw new Error('Cannot link card to itself');
+            }
+            // Determine the card path
+            const card = this.project.findCard(cardKey);
+            const destinationCard = this.project.findCard(destinationCardKey);
+            // make sure the link type exists
+            const linkTypeObject = this.project.resources
+                .byType(linkType, 'linkTypes')
+                .show();
+            // make sure that if linkDescription is not enabled, linkDescription is not provided
+            if (!linkTypeObject.enableLinkDescription &&
+                linkDescription !== undefined) {
+                throw new Error(`Link type '${linkType}' does not allow link description`);
+            }
+            // make sure source card key exists in the link type sourceCardTypes
+            // if sourceCardTypes is empty, any card can be linked
+            if (linkTypeObject.sourceCardTypes.length > 0 &&
+                !linkTypeObject.sourceCardTypes.includes(card.metadata.cardType)) {
+                throw new Error(`Card type '${card.metadata?.cardType}' cannot be linked with link type '${linkType}'`);
+            }
+            // make sure destination card key exists in the link type destinationCardTypes
+            // if destinationCardTypes is empty, any card can be linked
+            if (linkTypeObject.destinationCardTypes.length > 0 &&
+                !linkTypeObject.destinationCardTypes.includes(destinationCard.metadata.cardType)) {
+                throw new Error(`Card type '${destinationCard.metadata.cardType}' cannot be linked with link type '${linkType}'`);
+            }
+            // if contains the same link, do not add it again
+            const existingLink = card.metadata?.links.find((l) => l.linkType === linkType &&
+                l.cardKey === destinationCardKey &&
+                l.linkDescription === linkDescription);
+            if (existingLink) {
+                throw new Error(`Link from card '${cardKey}' to card '${destinationCardKey}' already exists`);
+            }
+            const links = card.metadata?.links || [];
+            links.push({
+                linkType,
+                cardKey: destinationCardKey,
+                linkDescription,
+            });
+            await this.project.updateCardMetadataKey(cardKey, 'links', links);
         }
-        await mkdir(projectPath, { recursive: true }).then(async () => {
-            return await Promise.all(projectFolders.map((folder) => mkdir(`${projectPath}/${folder}`, { recursive: true })));
-        });
-        await Promise.all(Create.JSONFileContent.map(async (entry) => {
-            if ('cardKeyPrefix' in entry.content) {
-                if (entry.content.cardKeyPrefix.includes('$PROJECT-PREFIX')) {
-                    entry.content.cardKeyPrefix = projectPrefix.toLowerCase();
-                }
-                if (entry.content.name.includes('$PROJECT-NAME')) {
-                    entry.content.name = projectName;
-                }
-                if (projectCategory) {
-                    entry.content.category = projectCategory;
-                }
-                if (projectDescription) {
-                    entry.content.description = projectDescription;
+        /**
+         * Creates a new project.
+         * @param projectPath where to create the project.
+         * @param projectPrefix prefix for the project.
+         * @param projectName name for the project.
+         * @param projectCategory category for the project (empty string if not provided).
+         * @param projectDescription description for the project (empty string if not provided).
+         */
+        static async createProject(projectPath, projectPrefix, projectName, projectCategory, projectDescription) {
+            // No lock required, since we are creating a new project
+            projectPath = resolve(projectPath);
+            if (!projectPath) {
+                throw new Error('Cannot create project without a path');
+            }
+            const projectFolders = ['.cards/local', 'cardRoot'];
+            if (!Validate.validateFolder(projectPath)) {
+                throw new Error(`Input validation error: folder name '${projectPath}' is invalid`);
+            }
+            if (projectPrefix === undefined ||
+                projectPrefix.length < 3 ||
+                projectPrefix.length > 10) {
+                throw new Error(`Input validation error: prefix must be from 3 to 10 characters long. '${projectPrefix}' does not fulfill the condition.`);
+            }
+            if (!Validate.isValidProjectName(projectName)) {
+                throw new Error(`Input validation error: invalid project name '${projectName}'`);
+            }
+            if (!Validate.validatePrefix(projectPrefix)) {
+                throw new Error(`Input validation error: invalid prefix '${projectPrefix}'`);
+            }
+            if (Project.isCreated(projectPath)) {
+                throw new Error('Project already exists');
+            }
+            if (!Validate.isValidProjectName(projectName)) {
+                throw new Error(`Input validation error: invalid project name '${projectName}'`);
+            }
+            await mkdir(projectPath, { recursive: true }).then(async () => {
+                return await Promise.all(projectFolders.map((folder) => mkdir(`${projectPath}/${folder}`, { recursive: true })));
+            });
+            await Promise.all(Create.JSONFileContent.map(async (entry) => {
+                if ('cardKeyPrefix' in entry.content) {
+                    if (entry.content.cardKeyPrefix.includes('$PROJECT-PREFIX')) {
+                        entry.content.cardKeyPrefix = projectPrefix.toLowerCase();
+                    }
+                    if (entry.content.name.includes('$PROJECT-NAME')) {
+                        entry.content.name = projectName;
+                    }
+                    if (projectCategory) {
+                        entry.content.category = projectCategory;
+                    }
+                    if (projectDescription) {
+                        entry.content.description = projectDescription;
+                    }
                 }
+                await writeJsonFile(join(projectPath, entry.path, entry.name), entry.content);
+            }));
+            try {
+                await writeFile(join(projectPath, '.gitignore'), this.gitIgnoreContent.join('\n') + '\n');
+            }
+            catch {
+                console.error('Failed to create project');
             }
-            await writeJsonFile(join(projectPath, entry.path, entry.name), entry.content);
-        }));
-        try {
-            await writeFile(join(projectPath, '.gitignore'), this.gitIgnoreContent.join('\n') + '\n');
         }
-        catch {
-            console.error('Failed to create project');
+        /**
+         * Creates a report
+         * @param name name of the report
+         */
+        async createReport(name) {
+            return this.project.resources.byType(name, 'reports').createReport();
         }
-    }
-    /**
-     * Creates a report
-     * @param name name of the report
-     */
-    async createReport(name) {
-        return this.project.resources.byType(name, 'reports').createReport();
-    }
-    /**
-     * Creates a new template to a project.
-     * @param templateName Name of the template.
-     * @param templateContent JSON content for the template file.
-     */
-    async createTemplate(templateName, templateContent) {
-        return this.project.resources
-            .byType(templateName, 'templates')
-            .create(templateContent ? JSON.parse(templateContent) : undefined);
-    }
-    /**
-     * Creates a workflow.
-     * @param workflowName workflow name
-     * @param workflowContent workflow content JSON
-     */
-    async createWorkflow(workflowName, workflowContent) {
-        return this.project.resources
-            .byType(workflowName, 'workflows')
-            .create(workflowContent ? JSON.parse(workflowContent) : undefined);
-    }
-}
+        /**
+         * Creates a new template to a project.
+         * @param templateName Name of the template.
+         * @param templateContent JSON content for the template file.
+         */
+        async createTemplate(templateName, templateContent) {
+            return this.project.resources
+                .byType(templateName, 'templates')
+                .create(templateContent ? JSON.parse(templateContent) : undefined);
+        }
+        /**
+         * Creates a workflow.
+         * @param workflowName workflow name
+         * @param workflowContent workflow content JSON
+         */
+        async createWorkflow(workflowName, workflowContent) {
+            return this.project.resources
+                .byType(workflowName, 'workflows')
+                .create(workflowContent ? JSON.parse(workflowContent) : undefined);
+        }
+    };
+})();
+export { Create };
 //# sourceMappingURL=create.js.map