@ja-platform/db 0.0.0-dev-20261028223022

package/dist/database/DatabaseObject.js

@@ -0,0 +1,646 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAccessor = exports.DatabaseObject = void 0;
+exports.setCreateAccessor = setCreateAccessor;
+const TypeOperations_1 = require("../types/TypeOperations");
+const parser_expressions_1 = require("@ja-platform/parser-expressions");
+const ObjectDisplayScope_1 = require("./ObjectDisplayScope");
+const uuid = __importStar(require("uuid"));
+const Query_1 = require("../query/Query");
+const queryOperations_1 = require("../query/queryOperations");
+const Batch_1 = require("./Batch");
+// type is the type object, not the name
+class DatabaseObject {
+    // id is optional. If not specified, a new one will be assigned automatically.
+    /** @internal */
+    static build(adapter, type, id, data) {
+        var obj = new DatabaseObject(adapter, type, id);
+        if (data != null) {
+            obj.resolve(data);
+        }
+        return obj;
+    }
+    constructor(adapter, type, id) {
+        var _a;
+        var _b;
+        if (adapter == null || typeof adapter.get != 'function') {
+            throw new Error('adapter is required');
+        }
+        if (type == null || typeof type.attributes != 'object') {
+            throw new Error('type is required');
+        }
+        const objself = this;
+        const operationsFor = (_b = (_a = adapter.operationsFor) === null || _a === void 0 ? void 0 : _a.bind(adapter)) !== null && _b !== void 0 ? _b : TypeOperations_1.operationsFor;
+        // This is where all the attributes are stored
+        const attributes = {};
+        // Attributes that have been set by the user.
+        let attributesDirty = {};
+        // belongsToIds is only used when there is no corresponding object in belongsToCache.
+        const belongsToIds = {};
+        // belongsToCache serves as a cache for relationships. The id in belongsToIds should always correspond to
+        // the id here, if the object is present.
+        // `null` means that we looked for the object but it doesn't exist (on the client), while `undefined` / not present
+        // means that we haven't queried yet.
+        let belongsToCache = {};
+        // Relationships that have been set by the user.
+        // true means set by user, false or not present means not set
+        let belongsToDirty = {};
+        // We keep track of what we are currently loading, so that we don't execute the same query many times
+        // in succession.
+        const belongsToLoading = {};
+        // Caching the queries prevents them from being re-executed all the time.
+        let hasManyCache = {};
+        let persisted;
+        let destroyed = false;
+        if (id == null) {
+            // New object
+            id = uuid.v4();
+            persisted = false;
+        }
+        else {
+            // Existing object that is already loaded
+            persisted = true;
+        }
+        // id is read-only in public, but may change internally
+        Object.defineProperty(this, 'id', {
+            enumerable: false,
+            configurable: false,
+            get: function () {
+                return id;
+            }
+        });
+        // persisted is read-only in public, but may change internally
+        Object.defineProperty(this, 'persisted', {
+            enumerable: false,
+            configurable: false,
+            get: function () {
+                return persisted;
+            }
+        });
+        defineHiddenConstant(this, 'type', type);
+        // Reload an object.
+        // Returns a promise that is resolved with the same object when it is loaded.
+        // If the object does not exist anymore, the promise is resolved with `null`.
+        // If the object is not loaded yet, this returns its original promise.
+        function _reload() {
+            if (id == null) {
+                throw new Error('Object is not saved yet - cannot reload');
+            }
+            return adapter.get(type.name, id).then(function (data) {
+                resolve(data);
+            });
+        }
+        function resolve(data) {
+            if (data != null) {
+                const resolveAttributes = data.attributes || {};
+                Object.keys(type.attributes).forEach(function (key) {
+                    const attribute = type.attributes[key];
+                    const value = resolveAttributes[key];
+                    // We don't override any attributes that have already been set.
+                    if (!attributesDirty[key]) {
+                        const realValue = value == null ? null : operationsFor(attribute.type).valueFromJSON(value);
+                        // We use the setter so that type checking occurs...
+                        try {
+                            setAttribute(key, realValue);
+                        }
+                        catch (err) {
+                            // ... but we ignore invalid attributes
+                        }
+                        // ... and we don't want the attribute to be marked as dirty.
+                        attributesDirty[key] = false;
+                    }
+                });
+                const loadedBelongsToIds = data.belongs_to || {};
+                // Loop through all relationships, not just the ones in the data.
+                // This is to ensure that cleared relationships are handled
+                // correctly.
+                Object.keys(type.belongsTo).forEach(function (key) {
+                    const belongsToId = loadedBelongsToIds[key];
+                    // We don't override any relationships that have already been set.
+                    if (!belongsToDirty[key]) {
+                        // Save the id
+                        belongsToIds[key] = belongsToId;
+                        // Clear any cached object
+                        delete belongsToCache[key];
+                        // Cancel the loading of any previous relationships
+                        delete belongsToLoading[key];
+                    }
+                });
+                id = data.id;
+                if (id != null) {
+                    persisted = true;
+                }
+                hasManyCache = {};
+            }
+        }
+        function setAll(values) {
+            if (values != null) {
+                for (let key in values) {
+                    if (values.hasOwnProperty(key)) {
+                        _set(key, values[key]);
+                    }
+                }
+            }
+        }
+        let saving = false;
+        // Returns a promise that is resolved when this object is saved.
+        async function _save() {
+            if (destroyed) {
+                // Don't save an object that has been destroyed.
+                return;
+            }
+            // Create a batch with this object.
+            // Note that other objects may implicitly be added to the batch via
+            // belongs-to relationships.
+            let batch = new Batch_1.Batch(adapter);
+            batch.save(this);
+            return batch._execute().catch(function (error) {
+                if (error instanceof Batch_1.CrudError) {
+                    return Promise.reject(error.firstError());
+                }
+                else {
+                    return Promise.reject(error);
+                }
+            });
+        }
+        /**
+         * Mark the object as persisted.
+         */
+        function _persisted() {
+            persisted = true;
+            // Clear the "dirty" state
+            attributesDirty = {};
+            belongsToDirty = {};
+        }
+        /**
+         * Mark the object as destroyed.
+         */
+        function _destroyed() {
+            persisted = false;
+            destroyed = true;
+        }
+        /**
+         * Returns an array of this object and any related objects that should be saved.
+         *
+         * @param [into] - array to populate
+         */
+        function _getDirtyList(into) {
+            if (into == null) {
+                into = [];
+            }
+            if (destroyed) {
+                // Don't save a destroyed object
+                return into;
+            }
+            if (saving) {
+                // Prevent recursion into self
+                return into;
+            }
+            saving = true;
+            into.push(objself);
+            try {
+                Object.keys(belongsToCache).forEach(function (key) {
+                    const related = belongsToCache[key];
+                    if (related != null) {
+                        if (related._adapter === adapter) {
+                            related._getDirtyList(into);
+                        }
+                        else {
+                            // Different adapter - can't add to the same batch.
+                            // Don't save the related object in this case.
+                        }
+                    }
+                });
+                return into;
+            }
+            finally {
+                saving = false;
+            }
+        }
+        // Delete this object.
+        // Returns a promise that is resolved when this object is deleted.
+        async function _destroy() {
+            if (id != null) {
+                const batch = new Batch_1.Batch(adapter);
+                batch.destroy(this);
+                try {
+                    await batch._execute();
+                }
+                catch (error) {
+                    if (error instanceof Batch_1.CrudError) {
+                        throw error.firstError();
+                    }
+                    else {
+                        throw error;
+                    }
+                }
+            }
+            else {
+                destroyed = true;
+            }
+        }
+        // Return a string representation of this object, according to the display format.
+        // Only returns the correct value if the object is already loaded.
+        function toString() {
+            var displayFormat = type.displayFormat;
+            return new ObjectDisplayScope_1.ObjectDisplayScope(objself, operationsFor).evaluate(displayFormat);
+        }
+        function toData(patch) {
+            // We don't modify belongToIds here - this must be a read-only method.
+            let jsonBelongsTo = {};
+            Object.keys(type.belongsTo).forEach(function (name) {
+                let belongsToId = belongsToIds[name];
+                if (patch) {
+                    if (belongsToDirty[name]) {
+                        jsonBelongsTo[name] = belongsToId;
+                    }
+                }
+                else {
+                    if (belongsToId != null) {
+                        jsonBelongsTo[name] = belongsToId;
+                    }
+                }
+            });
+            let jsonAttributes = {};
+            Object.keys(type.attributes).forEach(function (name) {
+                const attribute = type.attributes[name];
+                const value = attributes[name];
+                if (patch) {
+                    if (attributesDirty[name]) {
+                        if (value == null) {
+                            jsonAttributes[name] = null;
+                        }
+                        else {
+                            jsonAttributes[name] = operationsFor(attribute.type).valueToJSON(value, adapter.serializeOptions);
+                        }
+                    }
+                }
+                else {
+                    if (value != null) {
+                        jsonAttributes[name] = operationsFor(attribute.type).valueToJSON(value, adapter.serializeOptions);
+                    }
+                }
+            });
+            return {
+                id: objself.id,
+                type: type.name,
+                attributes: jsonAttributes,
+                belongs_to: jsonBelongsTo
+            };
+        }
+        // Getters and setters for attributes
+        const blacklist = ['save', 'id', '_database', 'reload'];
+        function setAttribute(name, value) {
+            const attribute = type.attributes[name];
+            if (attribute == null) {
+                return;
+            }
+            // Convert it to the correct type, or throw an exception if it is of invalid type.
+            if (value == null) {
+                // Includes undefined.
+                value = null;
+            }
+            else {
+                value = operationsFor(attribute.type).parse(value);
+            }
+            // We specifically don't want to set the value to null if the object is not loaded yet.
+            // This causes the value to be cleared by the view before the object is loaded.
+            if (attributes[name] != value) {
+                attributes[name] = value;
+                attributesDirty[name] = true;
+            }
+        }
+        Object.keys(type.attributes).forEach((name) => {
+            if (blacklist.indexOf(name) != -1) {
+                return;
+            }
+            Object.defineProperty(objself, name, {
+                get() {
+                    return attributes[name];
+                },
+                set(value) {
+                    setAttribute(name, value);
+                },
+                enumerable: true,
+                configurable: true
+            });
+            attributes[name] = null;
+        });
+        function setBelongsTo(name, value) {
+            // setter
+            if (value == null) {
+                belongsToCache[name] = null;
+                belongsToIds[name] = null;
+                belongsToDirty[name] = true;
+            }
+            else if (value instanceof DatabaseObject) {
+                belongsToCache[name] = value;
+                belongsToIds[name] = value.id;
+                belongsToDirty[name] = true;
+            }
+            else {
+                if (typeof value == 'function') {
+                    // This seems to be the return value of a relationship lookup without parenthesis.
+                    throw new Error('Use `.relationship()` instead of `.relationship` when looking up a relationship.');
+                }
+                else {
+                    throw new Error(value + ' is not a valid object');
+                }
+            }
+        }
+        function triggerLoad(name) {
+            const rel = type.belongsTo[name];
+            if (rel == null) {
+                return 'nothing to load';
+            }
+            // undefined means not looked up yet.
+            // null means we looked it up, but didn't find anything.
+            if (belongsToCache[name] === undefined) {
+                if (belongsToLoading[name]) {
+                    // An query have already been made for this relationship - return the same promise.
+                    return 'already loading';
+                }
+                else {
+                    const _ignorePromise = getBelongsTo(name);
+                    return 'loading';
+                }
+            }
+            else {
+                return 'already loaded';
+            }
+        }
+        async function getBelongsTo(name) {
+            const rel = type.belongsTo[name];
+            if (rel == null) {
+                return undefined;
+            }
+            // undefined means not looked up yet.
+            // null means we looked it up, but didn't find anything.
+            if (belongsToCache[name] === undefined) {
+                if (belongsToLoading[name]) {
+                    // An query have already been made for this relationship - return the same promise.
+                    return belongsToLoading[name];
+                }
+                else {
+                    const foreignType = rel.foreignType;
+                    const relatedId = belongsToIds[name];
+                    const promise = adapter.get(foreignType.name, relatedId);
+                    const promise2 = promise.then(function (data) {
+                        let obj = null;
+                        if (data) {
+                            obj = DatabaseObject.build(adapter, foreignType, relatedId, data);
+                        }
+                        if (belongsToLoading[name] == promise2) {
+                            delete belongsToLoading[name];
+                            belongsToCache[name] = obj;
+                        }
+                        else {
+                            // This promise has been canceled.
+                            // We still return the same result, but don't update the cache.
+                        }
+                        return obj;
+                    });
+                    belongsToLoading[name] = promise2;
+                    return promise2;
+                }
+            }
+            else {
+                return belongsToCache[name];
+            }
+        }
+        Object.keys(type.belongsTo).forEach(function (name) {
+            if (blacklist.indexOf(name) != -1) {
+                return;
+            }
+            var accessor = (0, exports.createAccessor)(name, setBelongsTo, getBelongsTo);
+            if (accessor != null) {
+                Object.defineProperty(objself, name, {
+                    get: function () {
+                        // There's no robust way to test that the accessor is being used as a function.
+                        return accessor;
+                    },
+                    set: function () {
+                        // Technically we can set the value here. However, it will be inconsistent with the getter.
+                        throw new Error('Use `.' + name + '(value)` instead of `.' + name + ' = value` to set a relationship.');
+                    },
+                    enumerable: false,
+                    configurable: false
+                });
+            }
+            // Getter and setter for belongs-to ids.
+            Object.defineProperty(objself, name + '_id', {
+                get: function () {
+                    return belongsToIds[name] || null; // `|| null` so we return null instead of undefined
+                },
+                set: function (relatedId) {
+                    // Save the id
+                    belongsToIds[name] = relatedId;
+                    belongsToDirty[name] = true;
+                    // Clear any cached object
+                    delete belongsToCache[name];
+                    // Cancel the loading of any previous relationships
+                    delete belongsToLoading[name];
+                },
+                enumerable: false,
+                configurable: false
+            });
+        });
+        Object.keys(type.hasMany).forEach(function (name) {
+            const rel = type.hasMany[name];
+            if (blacklist.indexOf(name) != -1) {
+                return;
+            }
+            // We return a query
+            Object.defineProperty(objself, name, {
+                get: function () {
+                    if (hasManyCache[name] == null) {
+                        // We cache the Query object, along with its _freshness value.
+                        // This does not cache the results - widgets are responsible for that.
+                        const expr = new queryOperations_1.RelationMatch(rel.name, objself.id);
+                        hasManyCache[name] = new Query_1.Query(adapter, rel.objectType, expr);
+                    }
+                    return hasManyCache[name];
+                },
+                enumerable: false,
+                configurable: false
+            });
+        });
+        // Return an attribute or relationship as a promise.
+        async function _get(name) {
+            // TODO: belongs_to ids
+            if (name === 'id') {
+                return id;
+            }
+            if (type.attributes[name]) {
+                return objself[name];
+            }
+            if (type.belongsTo[name]) {
+                return getBelongsTo(name);
+            }
+            if (type.hasMany[name]) {
+                return objself[name];
+            }
+            return null;
+        }
+        // Return an attribute or cached relationship immediately.
+        // If `name` is not a valid attribute or relationship, null is returned.
+        // If `name` is a relationship or attribute that is not set, null is returned.
+        // If `name` is a relationship that we're still loading, undefined is returned.
+        // TODO: perhaps we should use a constant other than `undefined`?
+        function _cached(name) {
+            if (type.attributes[name]) {
+                return objself[name];
+            }
+            else if (type.belongsTo[name]) {
+                // Trigger a lookup (only has an effect if we haven't cached the relationship yet).
+                triggerLoad(name);
+                return belongsToCache[name];
+            }
+            else if (type.hasMany[name]) {
+                return objself[name];
+            }
+            else {
+                return null;
+            }
+        }
+        function _cache(name, value) {
+            // Cache a relationship
+            // It is assumed that the id matches value.id
+            belongsToCache[name] = value;
+        }
+        // Set an attribute or relationship.
+        function _set(name, value) {
+            if (type.attributes[name]) {
+                objself[name] = value;
+            }
+            else if (type.belongsTo[name]) {
+                setBelongsTo(name, value);
+            }
+            else {
+                // Ignore
+                // This behaviour is intentionally different from normal attribute assignment.
+                // This makes it simpler to assign data from an external JSON source.
+            }
+        }
+        function _clone(newType) {
+            if (newType == null) {
+                newType = type;
+            }
+            const data = toData(false); // TODO: should we convert to JSON and back?
+            // If the object is not persisted, we generate a create an object
+            // without an id. Otherwise the clone thinks it is persisted.
+            const newId = persisted ? id : null;
+            let clone = new DatabaseObject(adapter, newType, newId);
+            clone.resolve(data);
+            return clone;
+        }
+        async function _display() {
+            const expression = type.displayFormat;
+            const scope = new ObjectDisplayScope_1.ObjectDisplayScope(objself, operationsFor);
+            const values = await Promise.all(expression.parameters.map(async (parameter) => {
+                const value = await scope.getValuePromise(parameter.path);
+                const formatter = scope.getExpressionFormatter(parameter.path);
+                return (0, parser_expressions_1.formatValueAsync)(value, formatter, parameter.format);
+            }));
+            return expression.render(values);
+        }
+        // public functions, but not enumerable
+        defineHiddenConstant(this, '_reload', _reload);
+        defineHiddenConstant(this, 'set_all', setAll);
+        defineHiddenConstant(this, 'setAll', setAll);
+        defineHiddenConstant(this, '_save', _save);
+        defineHiddenConstant(this, '_destroy', _destroy);
+        defineHiddenConstant(this, 'toString', toString);
+        defineHiddenConstant(this, 'resolve', resolve);
+        defineHiddenConstant(this, '_get', _get);
+        defineHiddenConstant(this, '_cached', _cached);
+        defineHiddenConstant(this, '_cache', _cache);
+        defineHiddenConstant(this, '_set', _set);
+        defineHiddenConstant(this, '_adapter', adapter);
+        defineHiddenConstant(this, '_clone', _clone);
+        defineHiddenConstant(this, '_display', _display);
+        defineHiddenConstant(this, '_getDirtyList', _getDirtyList);
+        defineHiddenConstant(this, '_persisted', _persisted);
+        defineHiddenConstant(this, '_destroyed', _destroyed);
+        defineHiddenConstant(this, 'toData', toData);
+        // Sealing the object prevents new properties from being added.
+        Object.seal(this);
+    }
+    // Aliases
+    /**
+     * Reload this object from the database.
+     */
+    reload() {
+        return this._reload();
+    }
+    /**
+     * Save this object to the database.
+     */
+    save() {
+        return this._save();
+    }
+    /**
+     * Delete this object from the database.
+     */
+    destroy() {
+        return this._destroy();
+    }
+}
+exports.DatabaseObject = DatabaseObject;
+function defineHiddenConstant(object, name, value) {
+    Object.defineProperty(object, name, {
+        enumerable: false,
+        configurable: false,
+        writable: false,
+        value: value
+    });
+}
+var createAccessor = (name, set, get) => {
+    return (value) => {
+        if (typeof value != 'undefined') {
+            return set(name, value);
+        }
+        else {
+            return get(name);
+        }
+    };
+};
+exports.createAccessor = createAccessor;
+// For internal use only
+function setCreateAccessor(fn) {
+    exports.createAccessor = fn;
+}
+//# sourceMappingURL=DatabaseObject.js.map