@docstack/client 0.1.5 → 0.1.6

package/lib/core/class.js

@@ -1,774 +0,0 @@
-var _a;
-import { Class as Class_, isAttributeModel } from "@docstack/shared";
-import createLogger from "../utils/logger/index.js";
-import Attribute from "./attribute.js";
-import { Trigger } from "./trigger/index.js";
-import { z } from "zod";
-import clientLogger from "../utils/logger/index.js";
-/**
- * Represents a data class (schema definition) in the DocStack database.
- *
- * A Class defines the structure of documents, including their attributes,
- * validation rules (via Zod), and triggers that execute during document operations.
- *
- * Use the static factory methods ({@link Class.create}, {@link Class.fetch}) to
- * instantiate classes - the constructor is private.
- *
- * @example
- * ```typescript
- * // Create a new class with schema
- * const taskClass = await Class.create(stack, 'Task', 'class', 'User Tasks');
- *
- * // Add attributes to define the schema
- * await Attribute.create(taskClass, 'title', 'string', 'Task Title', { mandatory: true });
- * await Attribute.create(taskClass, 'isComplete', 'boolean', 'Done?', { defaultValue: false });
- *
- * // Create documents (cards) of this class
- * const task = await taskClass.add({ title: 'My Task', isComplete: false });
- * ```
- *
- * @extends Class_
- */
-class Class extends Class_ {
-    constructor() {
-        super();
-        /** Map of attribute names to Attribute instances defining the schema. */
-        this.attributes = {};
-        /** The raw schema definition from the ClassModel. */
-        this.schema = {};
-        /** Zod schema for runtime validation of document data. */
-        this.schemaZOD = z.object({});
-        /** Current state indicating if the class is processing an operation. */
-        this.state = "idle";
-        /** Array of triggers that execute before/after document operations. */
-        this.triggers = [];
-        // TODO: Test
-        /*
-        inheritAttributes( parentClass: Class ) {
-            let parentAttributes = parentClass.getAttributes();
-            for ( let attribute of parentAttributes ) {
-                this.addAttribute(attribute);
-            }
-        } */
-        this.build = () => {
-            return new Promise(async (resolve, reject) => {
-                let stack = this.getStack();
-                if (stack) {
-                    // if (parentClassName) this.setParentClass(parentClassName);
-                    let classModel = await stack.addClass(this);
-                    // Hydrate model
-                    if (classModel) {
-                        this.setModel(classModel);
-                        _a.logger.info("build - classModel", { classModel: classModel });
-                        this.setId(classModel._id);
-                        resolve(this);
-                    }
-                    else {
-                        reject("unable to get classModel. Check logs");
-                    }
-                }
-                else {
-                    reject("Missing stack assignment");
-                }
-            });
-        };
-        this.init = (stack, id, name, type, description, schema = {}
-        // parentClass: Class | null
-        ) => {
-            // this.parentClass = parentClass;
-            if (stack) {
-                this.stack = stack;
-            }
-            this.name = name;
-            this.id = id;
-            this.description = description;
-            this.type = type;
-            // this.attributes = [];
-            // this.stack = null;
-            // this.id = null;
-            // if (schema) {
-            //     this.schema = schema;
-            // }
-            this.setModel({
-                "~class": type, _id: id, active: true,
-                name, description,
-                schema, triggers: [],
-            });
-            this.logger = clientLogger(stack).child({ module: "class", className: this.name });
-            // TODO: Waiting for test of method
-            // if (parentClass) this.inheritAttributes(parentClass);
-        };
-        this.uniqueCheck = async (doc) => {
-            const fnLogger = this.logger.child({ method: "uniqueCheck", args: { doc } });
-            const duplicate = await this.getByPrimaryKeys(doc);
-            if (duplicate == null || duplicate._id == doc._id) {
-                fnLogger.info("No duplicate found for doc");
-                return true;
-            }
-            else {
-                fnLogger.info("Duplicate found for doc", { duplicate });
-                return false;
-            }
-        };
-        this.bulkUniqueCheck = async (pKs) => {
-            var _b;
-            const fnLogger = this.logger.child({ method: "bulkUniqueCheck", args: { pKs } });
-            const ddocId = await ((_b = this.stack) === null || _b === void 0 ? void 0 : _b.addDesignDocumentPKs(this.name, pKs, true));
-            fnLogger.info(`Created temporary design document '${ddocId}'`);
-            if (this.stack && ddocId) {
-                try {
-                    const result = await this.stack.db.query(`${ddocId}/by_pKeys`, {
-                        group: true,
-                        reduce: '_count'
-                    });
-                    const hasDuplicates = result.rows.some(row => row.value > 1);
-                    if (hasDuplicates) {
-                        // 3a. Rollback: new schema is invalid
-                        fnLogger.error('Schema change invalid: new duplicates found.');
-                        const finalTempDoc = await this.stack.db.get(ddocId);
-                        await this.stack.db.remove(finalTempDoc);
-                        return false; // Indicate failure
-                    }
-                    else {
-                        // 3b. Execute: new schema is valid. Replace the live document.
-                        fnLogger.info('Bulk unique check completed: no new duplicates found');
-                        const finalTempDoc = await this.stack.db.get(ddocId);
-                        // Clean up the temporary document
-                        await this.stack.db.remove(finalTempDoc);
-                        return true; // Indicate success
-                    }
-                }
-                catch (err) {
-                    console.error('Error during schema validation:', err);
-                    // Ensure the temporary document is removed on error
-                    try {
-                        const finalTempDoc = await this.stack.db.get(ddocId);
-                        await this.stack.db.remove(finalTempDoc);
-                    }
-                    catch (e) { /* ignore */ }
-                    return false;
-                }
-            }
-            else {
-                fnLogger.error(`Was unable to create temporary design document to group by`);
-                return false;
-            }
-        };
-        /**
-         * Validates document data against the class schema using Zod.
-         *
-         * @param data - The document data to validate
-         * @returns `true` if validation passes, `false` otherwise
-         */
-        this.validate = async (data) => {
-            const fnLogger = this.logger.child({ method: "validate" });
-            const result = await this.schemaZOD.safeParseAsync(data);
-            fnLogger.debug("Got result", { result });
-            if (result.success) {
-                return true;
-            }
-            else {
-                return false;
-            }
-        };
-        // TODO Turn into method (after factory method instantiation refactory is done)
-        this.setId = (id) => {
-            this.id = id;
-        };
-        this.getName = () => {
-            return this.name;
-        };
-        this.getStack = () => {
-            return this.stack;
-        };
-        this.getDescription = () => {
-            return this.description;
-        };
-        this.getType = () => {
-            return this.type;
-        };
-        this.getId = () => {
-            return this.id;
-        };
-        /**
-         * Builds the schema object from the current attributes.
-         * @returns The schema definition object
-         */
-        this.buildSchema = () => {
-            let schema = {};
-            Object.entries(this.attributes).forEach(t => {
-                schema[t[0]] = t[1].model;
-            });
-            return schema;
-        };
-        /**
-         * Returns the current ClassModel representation of this class.
-         * @returns The ClassModel document
-         */
-        this.getModel = () => {
-            let triggers = [];
-            for (const trigger of this.triggers) {
-                triggers.push(trigger.model);
-            }
-            let model = {
-                _id: this.id,
-                name: this.getName(),
-                description: this.getDescription(),
-                "~class": this.getType(),
-                schema: this.buildSchema(),
-                triggers: triggers,
-                active: true,
-                _rev: this.model ? this.model._rev : "",
-                "~createTimestamp": this.model ? this.model["~createTimestamp"] : undefined,
-            };
-            return model;
-        };
-        // [TODO] Change into buildFromModel
-        /**
-         * It hydrates attributes and triggers from given model
-         * @param model
-         */
-        this.setModel = (model) => {
-            _a.logger.info("setModel - got incoming model", { model: model });
-            // Retreive current class model
-            let currentModel = this.getModel();
-            // Set model arg to the overwrite of the current model with the given one 
-            model = Object.assign(currentModel, model);
-            if (model.schema) {
-                // model.schema = {...this.model.schema, ...model.schema};
-                this.attributes = {};
-                this.schemaZOD = z.object({});
-                for (const [key, attrModel] of Object.entries(model.schema)) {
-                    let attribute = new Attribute(this, attrModel.name, attrModel.type, attrModel.description, attrModel.config);
-                    this.attributes[attrModel.name] = attribute;
-                    this.schemaZOD = this.schemaZOD.extend({
-                        [attrModel.name]: attribute.field
-                    });
-                }
-            }
-            if (model.triggers) {
-                this.triggers = [];
-                for (const trigger of model.triggers) {
-                    let trigger_ = new Trigger(trigger, this);
-                    this.triggers.push(trigger_);
-                }
-            }
-            this.name = model.name;
-            this.description = model.description;
-            this.type = model["~class"];
-            this.model = model;
-            _a.logger.info("setModel - model after processing", { model: model });
-        };
-        /**
-         * Returns the primary key attribute names for this class.
-         * @returns Array of attribute names marked as primary keys
-         */
-        this.getPrimaryKeys = () => {
-            return Object.values(this.attributes).filter(attr => attr.isPrimaryKey())
-                .map(attr => attr.getName());
-        };
-        this.getAttributes = (...names) => {
-            let attributes = {};
-            for (const attribute of Object.values(this.attributes)) {
-                if (names.length > 0) {
-                    // filter with given names
-                    for (let name of names) {
-                        // match?
-                        if (name != null && attribute.getName() == name) {
-                            attributes[attribute.name] = attribute;
-                        }
-                    }
-                }
-                else {
-                    // no filter provided add all
-                    attributes[attribute.name] = attribute;
-                }
-            }
-            return attributes;
-        };
-        this.hasAllAttributes = (...names) => {
-            let result = false;
-            let attributes = this.getAttributes(...names);
-            for (let attribute of Object.values(attributes)) {
-                result = names.includes(attribute.getName());
-                if (!result)
-                    break;
-            }
-            return result;
-        };
-        this.hasAnyAttributes = (...names) => {
-            let result = false;
-            let attributes = this.getAttributes(...names);
-            for (let attribute of Object.values(attributes)) {
-                result = names.includes(attribute.getName());
-                if (result)
-                    break;
-            }
-            return result;
-        };
-        this.getEncryptedAttributes = () => {
-            return Object.values(this.attributes).filter((attribute) => {
-                const config = attribute.model.config;
-                return (config === null || config === void 0 ? void 0 : config.encrypted) === true && (config === null || config === void 0 ? void 0 : config.primaryKey) !== true;
-            });
-        };
-        // interface of hasAnyAttributes
-        this.hasAttribute = (name) => {
-            return this.hasAnyAttributes(name);
-        };
-        /**
-         * Adds a new attribute to the class schema.
-         * Persists the change to the database.
-         *
-         * @param attribute - The Attribute instance or AttributeModel to add
-         * @returns This Class instance for chaining
-         *
-         * @example
-         * ```typescript
-         * await taskClass.addAttribute(new Attribute(taskClass, 'dueDate', 'date', 'Due Date'));
-         * // Or use Attribute.create() for a simpler API
-         * ```
-         */
-        this.addAttribute = async (attribute) => {
-            var _b;
-            const fnLogger = this.logger.child({ method: "addAttribute", args: { attribute: attribute.name } });
-            const attribute_ = isAttributeModel(attribute)
-                ? new Attribute(this, attribute.name, attribute.type, attribute.description, attribute.config) : attribute;
-            try {
-                let name = attribute_.getName();
-                // console.log("Adding attribute", {className: this.name, attribute: name})
-                if (!this.hasAttribute(name)) {
-                    fnLogger.info("Adding attribute", { name: name, type: attribute_.getModel() });
-                    this.attributes[name] = attribute_;
-                    let attributeModel = attribute_.getModel();
-                    fnLogger.info("Adding attribute to schema", { attributeModel: attributeModel });
-                    const currentSchema = (_b = this.model.schema) !== null && _b !== void 0 ? _b : {};
-                    this.model.schema = Object.assign(Object.assign({}, currentSchema), { [name]: attributeModel });
-                    this.schemaZOD = this.schemaZOD.extend({
-                        [name]: attribute_.field
-                    });
-                    // TODO:
-                    // this.schema[name] = attributeModel; // sometimes getting schema undefined
-                    // update class on db
-                    fnLogger.info("Checking for requirements before updating class on db", { stack: (this.stack != null), id: this.id });
-                    if (this.stack && this.id) {
-                        // debugger;
-                        fnLogger.info("Updating class on db");
-                        let res = await this.stack.updateClass(this);
-                        return this;
-                        // TODO: Check if this class has subclasses
-                    }
-                    else {
-                        fnLogger.error("Class not updated on db because of missing stack or id");
-                        return this;
-                    }
-                }
-                else {
-                    fnLogger.error("Attribute with name " + name + " already exists within this Class");
-                    return this;
-                }
-            }
-            catch (e) {
-                fnLogger.error("Falied adding attribute because: ", e);
-                return this;
-            }
-        };
-        /**
-         * Modifies an existing attribute in the class schema.
-         *
-         * @param name - The name of the attribute to modify
-         * @param attribute - The new Attribute or AttributeModel definition
-         * @returns This Class instance for chaining
-         */
-        this.modifyAttribute = async (name, attribute) => {
-            const fnLogger = this.logger.child({ method: "modifyAttribute", args: { name } });
-            const originSchema = Object.assign({}, this.model.schema[name]), originAttr = this.attributes[name];
-            const attribute_ = isAttributeModel(attribute)
-                ? new Attribute(this, attribute.name, attribute.type, attribute.description, attribute.config) : attribute;
-            try {
-                fnLogger.info(`Attempting to change attribute definition.`);
-                delete this.model.schema[name];
-                delete this.attributes[name];
-                this.schemaZOD = this.schemaZOD.omit({ [name]: true });
-                return this.addAttribute(attribute_);
-            }
-            catch (e) {
-                // Revert
-                this.model.schema[name] = originSchema;
-                this.attributes[name] = originAttr;
-                fnLogger.error(`Failed at removing attribute from class.'`);
-            }
-            return this;
-        };
-        /**
-         * Removes an attribute from the class schema.
-         *
-         * @param name - The name of the attribute to remove
-         * @returns This Class instance for chaining
-         */
-        this.removeAttribute = async (name) => {
-            const fnLogger = this.logger.child({ method: "removeAttribute", args: { name } });
-            const originSchema = Object.assign({}, this.model.schema[name]), originAttr = this.attributes[name];
-            try {
-                fnLogger.info(`Attempting to remove attribute from class.`);
-                delete this.model.schema[name];
-                delete this.attributes[name];
-                this.schemaZOD = this.schemaZOD.omit({ [name]: true });
-                if (this.stack) {
-                    this.stack.updateClass(this);
-                }
-                else
-                    throw new Error("Missing stack, cannot perform updates.");
-            }
-            catch (e) {
-                // Revert
-                this.model.schema[name] = originSchema;
-                this.attributes[name] = originAttr;
-                fnLogger.error(`Failed at removing attribute from class.'`);
-            }
-            return this;
-        };
-        /**
-         * Creates a new document (card) of this class type.
-         *
-         * @param params - The document data
-         * @returns The created document, or `null` if stack is not defined
-         *
-         * @example
-         * ```typescript
-         * const task = await taskClass.addCard({
-         *     title: 'My Task',
-         *     isComplete: false
-         * });
-         * ```
-         */
-        this.addCard = async (params) => {
-            const fnLogger = this.logger.child({ method: "addCard", args: { params } });
-            if (!this.stack) {
-                fnLogger.error("Stack is not defined");
-                return null;
-            }
-            return await this.stack.createDoc(null, this.getName(), this, params);
-        };
-        /**
-         * Creates multiple documents (cards) of this class type in a batch.
-         *
-         * @param paramsArray - Array of document data objects
-         * @returns Array of created documents
-         */
-        this.addCards = async (paramsArray) => {
-            const fnLogger = this.logger.child({ method: "addCards", args: { paramsArray } });
-            if (!this.stack) {
-                fnLogger.error("Stack is not defined");
-                return [];
-            }
-            let addedCards = [];
-            addedCards = await this.stack.createDocs(paramsArray.map(params => ({ docId: null, params })), this.getName(), this);
-            return addedCards;
-        };
-        this.getByPrimaryKeys = async (params) => {
-            const fnLogger = this.logger.child({ method: "getByPrimaryKeys" });
-            // attempt to retrieve card by primary key
-            let filter = {};
-            let primaryKeys = this.getPrimaryKeys();
-            fnLogger.info("Got primary keys", { primaryKeys });
-            if (primaryKeys.length) {
-                // executes a reducer function on each element of the primaryKeys array
-                // that sets each primary key prop to the corresponding param value 
-                primaryKeys.reduce((accumulator, currentValue) => accumulator[currentValue] = params[currentValue], filter);
-                fnLogger.info("Defined filter", { filter });
-                let cards = await this.getCards(filter, undefined, 0, 1);
-                if (cards.length > 0) {
-                    return cards[0];
-                }
-                else {
-                    fnLogger.info("Did not find any documents with given primary key", { filter });
-                    return null;
-                }
-            }
-            else {
-                fnLogger.info("Class has no field specified as primary key");
-                return null;
-            }
-        };
-        this.addOrUpdateCard = async (params, cardId) => {
-            const fnLogger = this.logger.child({ method: "addOrUpdateCard", args: { params, cardId } });
-            const document = await new Promise(async (resolve, reject) => {
-                if (cardId) {
-                    fnLogger.info("Provided document's id, performing an update");
-                    const res = await this.updateCard(cardId, params);
-                    resolve(res);
-                }
-                else {
-                    fnLogger.info("No document id provided, checking for PKs");
-                    const card = await this.getByPrimaryKeys(params);
-                    if (card == null) {
-                        const res = await this.addCard(params);
-                        resolve(res);
-                    }
-                    else {
-                        fnLogger.error("Duplicate card by keys");
-                        reject("Duplicate card by keys");
-                    }
-                }
-            });
-            fnLogger.warn("Updated document", { document });
-            return document;
-        };
-        /**
-         * Pushes a document to the database.
-         * This is an alias for {@alias addOrUpdateCard}.
-         *
-         * @param params - The document data
-         * @param docId - Optional document ID. If provided, performs an update.
-         * @returns The created or updated document
-         */
-        this.push = async (params, docId) => {
-            return this.addOrUpdateCard(params, docId);
-        };
-        /**
-         * Updates an existing document (card) of this class.
-         *
-         * @param cardId - The document ID to update
-         * @param params - The updated document data
-         * @returns The updated document, or `null` if stack is not defined
-         */
-        this.updateCard = async (cardId, params) => {
-            return new Promise(async (resolve, reject) => {
-                if (this.stack) {
-                    const res = await this.stack.createDoc(cardId, this.getName(), this, params);
-                    resolve(res);
-                }
-                else {
-                    _a.logger.info("no stack defined");
-                    resolve(null);
-                }
-            });
-        };
-        /**
-         * Soft-deletes a document by setting its `active` flag to `false`.
-         *
-         * @param cardId - The document ID to delete
-         * @returns `true` if successful, `false` otherwise
-         */
-        this.deleteCard = async (cardId) => {
-            const fnLogger = this.logger.child({ method: "deleteCard", args: { cardId } });
-            if (this.stack) {
-                const res = await this.stack.deleteDocument(cardId);
-                return res;
-            }
-            else {
-                fnLogger.error("Stack is not defined");
-                return false;
-            }
-        };
-        /**
-         * Retrieves documents (cards) of this class type.
-         *
-         * @param selector - Optional PouchDB/Mango selector for filtering
-         * @param fields - Optional list of fields to return
-         * @param skip - Number of documents to skip
-         * @param limit - Maximum number of documents to return
-         * @returns Array of matching documents
-         *
-         * @example
-         * ```typescript
-         * // Get all tasks
-         * const allTasks = await taskClass.getCards();
-         *
-         * // Get incomplete tasks
-         * const incomplete = await taskClass.getCards({ isComplete: { $eq: false } });
-         * ```
-         */
-        this.getCards = async (selector, fields, skip, limit) => {
-            const _selector = Object.assign(Object.assign({}, (selector || {})), { "~class": { $eq: this.name } });
-            this.logger.info("getCards - selector", { selector: _selector, fields, skip, limit });
-            let docs = (await this.stack.findDocuments(_selector, fields, skip, limit)).docs;
-            return docs;
-        };
-        /**
-         * Adds a trigger to this class.
-         * Triggers execute before or after document operations.
-         *
-         * @param name - The trigger name
-         * @param model - The trigger model containing the execution logic
-         * @returns This Class instance for chaining
-         *
-         * @example
-         * ```typescript
-         * await taskClass.addTrigger('generate-slug', {
-         *     name: 'generate-slug',
-         *     order: 'before',
-         *     run: `document.slug = document.title.toLowerCase().replace(/\\s+/g, '-'); return document;`
-         * });
-         * ```
-         */
-        this.addTrigger = async (name, model) => {
-            const fnLogger = this.logger.child({ method: "addTrigger" });
-            try {
-                const trigger = new Trigger(model, this);
-                this.triggers.push(trigger);
-                if (this.stack) {
-                    this.setModel();
-                    let res = await this.stack.updateClass(this);
-                }
-                else {
-                    throw new Error(`Stack is not defined. Can't update class`);
-                }
-            }
-            catch (e) {
-                fnLogger.error(e);
-            }
-            return this;
-        };
-        /**
-         * Removes a trigger from this class by name.
-         *
-         * @param name - The name of the trigger to remove
-         * @returns This Class instance for chaining
-         */
-        this.removeTrigger = async (name) => {
-            this.triggers = this.triggers.filter(t => t.name != name);
-            return this;
-        };
-        // Private constructor to prevent direct instantiation
-        /* Populated on async build */
-        // this.id = null; 
-    }
-    async add(...paramsArray) {
-        const fnLogger = this.logger.child({ method: "add", args: { paramsArray } });
-        const addedCards = await this.addCards(paramsArray);
-        fnLogger.info("Added cards", { addedCards });
-        if (paramsArray.length === 1)
-            return addedCards[0] || null;
-        return addedCards;
-    }
-    async get(...cardId) {
-        const fnLogger = this.logger.child({ method: "get", args: { cardId } });
-        if (typeof cardId === "string") {
-            let docs = await this.getCards({ _id: { $eq: cardId } });
-            return docs[0] || null;
-        }
-        else {
-            let docs = await this.getCards({ _id: { $in: cardId } });
-            fnLogger.info("Fetched documents", { docs });
-            return docs;
-        }
-    }
-}
-_a = Class;
-Class.logger = createLogger().child({ module: "class" });
-/**
- * Gets a Class instance without persisting it to the database.
- * Use this for working with existing class models or for testing.
- * Sets up a document change listener for real-time updates.
- *
- * @param stack - The parent stack instance
- * @param id - The class ID
- * @param name - The class name
- * @param type - The class type
- * @param description - Optional description
- * @param schema - Initial schema definition
- * @returns A new Class instance (not persisted)
- */
-Class.get = (stack, id, name, type, description, schema = {}) => {
-    const class_ = new _a();
-    _a.logger.info("Received schema", { schema });
-    class_.init(stack, id, name, type, description, schema);
-    // Add listener for new documents of this class type
-    class_.stack.onClassDoc(name)
-        .on("change", (change) => {
-        const evt = new CustomEvent("doc", {
-            detail: change
-        });
-        class_.dispatchEvent(evt);
-    });
-    return class_;
-};
-/**
- * Creates a new class and persists it to the database.
- * This is the primary factory method for creating new classes.
- *
- * @param stack - The parent stack instance
- * @param name - The name for the new class
- * @param type - The class type (typically 'class')
- * @param description - Optional description of the class
- * @param schema - Initial schema definition
- * @returns The persisted Class instance
- *
- * @example
- * ```typescript
- * const userClass = await Class.create(stack, 'User', 'class', 'Application users');
- * ```
- */
-Class.create = async (stack, name, type, description, schema = {}) => {
-    const class_ = _a.get(stack, name, name, type, description, schema);
-    await class_.build();
-    return class_;
-};
-/**
- * Builds a Class instance from an existing ClassModel document.
- * Hydrates attributes and triggers from the model.
- *
- * @param stack - The parent stack instance
- * @param classModel - The ClassModel document from the database
- * @returns The hydrated Class instance
- */
-Class.buildFromModel = async (stack, classModel) => {
-    _a.logger.info("buildFromModel - Instantiate from model", { classModel });
-    if (classModel._rev) {
-        let classObj = _a.get(stack, classModel._id, classModel.name, classModel["~class"], classModel.description, classModel.schema);
-        classObj.setModel(classModel);
-        return classObj;
-    }
-    else {
-        let classObj = await _a.create(stack, classModel.name, classModel["~class"], classModel["~class"], classModel.schema);
-        classObj.setModel(classModel);
-        return classObj;
-    }
-};
-/**
- * Fetches a class by its document ID.
- *
- * @param stack - The parent stack instance
- * @param classId - The class document ID
- * @returns The Class instance
- * @throws Error if the class is not found
- */
-Class.fetchById = async (stack, classId) => {
-    try {
-        let classModel = await stack.db.get(classId);
-        const classObj = await _a.buildFromModel(stack, classModel);
-        return classObj;
-    }
-    catch (error) {
-        throw new Error(`Class not found: ${classId}`);
-    }
-};
-/**
- * Fetches a class by its name.
- * This is the most common way to retrieve an existing class.
- *
- * @param stack - The parent stack instance
- * @param className - The class name to fetch
- * @returns The Class instance, or `null` if not found
- *
- * @example
- * ```typescript
- * const taskClass = await Class.fetch(stack, 'Task');
- * if (taskClass) {
- *     const tasks = await taskClass.getCards();
- * }
- * ```
- */
-Class.fetch = async (stack, className) => {
-    let classModel = await stack.getClassModel(className);
-    if (classModel) {
-        return _a.buildFromModel(stack, classModel);
-    }
-    else {
-        return null;
-    }
-};
-export default Class;
-//# sourceMappingURL=class.js.map