sedentary 0.1.0 → 0.1.2

package/dist/es/index.js

@@ -0,0 +1,585 @@
+import { actions, Attribute, base, EntryBase, loaded, size, Table, Transaction, transaction, Type } from "./db";
+export { Attribute, base, DB, deepCopy, deepDiff, EntryBase, loaded, size, Table, Transaction, transaction, Type } from "./db";
+const attributes = Symbol("attributes");
+const methods = Symbol("methods");
+const operators = ["=", ">", "<", ">=", "<=", "<>", "IN", "IS NULL", "LIKE", "NOT"];
+const allowedOption = ["indexes", "int8id", "parent", "primaryKey", "sync", "tableName"];
+const reservedNames = [
+    "attr2field",
+    "attributeName",
+    "cancel",
+    "class",
+    "construct",
+    "constructor",
+    "defaultValue",
+    "fieldName",
+    "foreignKeys",
+    "load",
+    "modelName",
+    "name",
+    "postCommit",
+    "postLoad",
+    "postRemove",
+    "postSave",
+    "preCommit",
+    "preLoad",
+    "preRemove",
+    "preSave",
+    "primaryKey",
+    "prototype",
+    "remove",
+    "save",
+    "tableName",
+    "type",
+    "unique"
+];
+/** Model and attribute names: ASCII letters, digits, underscore; cannot start with digit. */
+const reModelAttributeName = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+/** tableName and fieldName: ASCII lowercase letters, digits, underscore; cannot start with digit. */
+const reSqlName = /^[a-z_][a-z0-9_]*$/;
+/**
+ * Converts a JavaScript name to the default SQL name (snake_case).
+ * Uppercase letters become lowercase preceded by underscore, except the first character
+ * which is only lowercased without underscore.
+ */
+export function toSqlName(name) {
+    if (typeof name !== "string" || name.length === 0)
+        throw new Error("toSqlName: 'name' must be a non-empty string");
+    let result = name[0].toLowerCase();
+    for (let i = 1; i < name.length; i++) {
+        const c = name[i];
+        result += c >= "A" && c <= "Z" ? `_${c.toLowerCase()}` : c;
+    }
+    return result;
+}
+export class Sedentary {
+    autoSync;
+    db;
+    doSync = true;
+    log;
+    models = {};
+    constructor(options) {
+        if (!options)
+            options = {};
+        if (!(options instanceof Object))
+            throw new Error("new Sedentary: 'options' argument: Wrong type, expected 'Object'");
+        for (const k in options)
+            if (!["autoSync", "log", "sync"].includes(k))
+                throw new Error(`new Sedentary: 'options' argument: Unknown '${k}' option`);
+        const { autoSync, log, sync } = { autoSync: true, sync: true, ...options };
+        if (typeof autoSync !== "boolean")
+            throw new Error("new Sedentary: 'autoSync' option: Wrong type, expected 'boolean'");
+        if (log !== null && log !== undefined && !(log instanceof Function))
+            throw new Error("new Sedentary: 'log' option: Wrong type, expected 'null' or 'Function'");
+        if (typeof sync !== "boolean")
+            throw new Error("new Sedentary: 'sync' option: Wrong type, expected 'boolean'");
+        this.autoSync = autoSync;
+        this.db = null;
+        // eslint-disable-next-line no-console
+        this.log = log ? log : log === null ? () => { } : console.log;
+        this.doSync = sync;
+    }
+    Boolean(options) {
+        return new Type({ ...options, [base]: Boolean, type: "BOOLEAN" });
+    }
+    DateTime(options) {
+        return new Type({ ...options, [base]: Date, type: "DATETIME" });
+    }
+    FKey(attribute, options) {
+        const { attributeName, fieldName, modelName, tableName, type, unique, [base]: _base, [size]: _size } = attribute;
+        if (!unique)
+            throw new Error(`Sedentary.FKey: '${modelName}' model: '${attributeName}' attribute: is not unique: can't be used as FKey target`);
+        return new Type({ [base]: _base, foreignKey: { attributeName, fieldName, options, tableName }, [size]: _size, type });
+    }
+    Float(options) {
+        const sizeFloat = "Sedentary.Float: 'size' argument: Wrong value, expected 4 or 8";
+        let storageSize;
+        let rest;
+        [storageSize, rest] = this.checkSize(sizeFloat, options);
+        if (storageSize === undefined)
+            storageSize = 8;
+        if (storageSize !== 4 && storageSize !== 8)
+            throw new Error(sizeFloat);
+        return new Type({ ...rest, [base]: Number, [size]: storageSize, type: "FLOAT" });
+    }
+    Int(options) {
+        const sizeInt = "Sedentary.Int: 'size' argument: Wrong value, expected 2 or 4";
+        let storageSize;
+        let rest;
+        [storageSize, rest] = this.checkSize(sizeInt, options);
+        if (storageSize === undefined)
+            storageSize = 4;
+        if (storageSize !== 2 && storageSize !== 4)
+            throw new Error(sizeInt);
+        return new Type({ ...rest, [base]: Number, [size]: storageSize, type: "INT" });
+    }
+    Int8(options) {
+        return new Type({ ...options, [base]: BigInt, [size]: 8, type: "INT8" });
+    }
+    JSON(options) {
+        return new Type({ ...options, [base]: Object, type: "JSON" });
+    }
+    Number(options) {
+        return new Type({ ...options, [base]: Number, type: "NUMBER" });
+    }
+    None(options) {
+        return new Type({ ...options, [base]: undefined, type: "NONE" });
+    }
+    VarChar(options) {
+        const message = "Sedentary.VarChar: 'size' argument: Wrong value, expected positive integer";
+        const [maxSize, rest] = this.checkSize(message, options);
+        return new Type({ ...rest, [base]: String, [size]: maxSize, type: "VARCHAR" });
+    }
+    checkDB() {
+        if (!this.db)
+            throw new Error("Package sedentary can't be used directly. Please check: https://www.npmjs.com/package/sedentary#disclaimer");
+    }
+    checkOrderBy(order, attributes, modelName) {
+        let array = [];
+        if (!order)
+            return true;
+        if (typeof order === "string")
+            array = [order];
+        else if (order instanceof Array)
+            array = order;
+        else
+            return false;
+        const provided = {};
+        for (const attribute of array) {
+            if (typeof attribute !== "string")
+                return false;
+            const attributeName = attribute.startsWith("-") ? attribute.substring(1) : attribute;
+            if (!(attributeName in attributes))
+                throw new Error(`${modelName}.load: 'order' argument: '${attributeName}' is not an attribute name`);
+            if (provided[attributeName])
+                throw new Error(`${modelName}.load: 'order' argument: Reused '${attributeName}' attribute`);
+            provided[attributeName] = true;
+        }
+        return true;
+    }
+    checkSize(message, options) {
+        if (!options)
+            return [undefined, {}];
+        const { size, ...rest } = options;
+        if (size === undefined)
+            return [undefined, rest];
+        if (typeof size !== "number")
+            throw new Error(message);
+        if (size !== parseInt(size.toString(), 10))
+            throw new Error(message);
+        if (size <= 0)
+            throw new Error(message);
+        return [size, rest];
+    }
+    createWhere(modelName, attributes, where) {
+        if (typeof where === "string")
+            return [where, true, true];
+        if (typeof where !== "object")
+            throw new Error(`${modelName}.load: 'where' argument: Wrong type, expected 'Array', 'Object' or 'string'`);
+        if (!where)
+            return ["", false, false];
+        if (where instanceof Array) {
+            const length = where.length;
+            if (!length)
+                throw new Error(`${modelName}.load: 'where' argument: Empty Array`);
+            if (!["AND", "NOT", "OR"].includes(where[0]))
+                throw new Error(`${modelName}.load: 'where' argument: Wrong logical operator, expected 'AND', 'OR' or 'NOT'`);
+            if (length === 1)
+                return ["", false, false];
+            if (where[0] === "NOT") {
+                if (length > 2)
+                    throw new Error(`${modelName}.load: 'where' argument: 'NOT' operator is unary`);
+                const [res] = this.createWhere(modelName, attributes, where[1]);
+                return [res === "" ? "" : `NOT (${res})`, false, false];
+            }
+            const conditions = where
+                .filter((_, i) => i)
+                .map(_ => this.createWhere(modelName, attributes, _))
+                .filter(([_]) => _);
+            if (conditions.length === 1)
+                return conditions[0];
+            const isOr = where[0] === "OR";
+            return [isOr ? conditions.map(([_, , a]) => (a ? `(${_})` : _)).join(" OR ") : conditions.map(([_, o]) => (o ? `(${_})` : _)).join(" AND "), isOr, false];
+        }
+        const conditions = [];
+        for (const key in where) {
+            const field = attributes[key];
+            if (!field)
+                throw new Error(`${modelName}.load: 'where' argument: Unknown '${key}' attribute`);
+            const value = where[key];
+            if (value instanceof Array) {
+                const operator = value[0];
+                const length = value.length;
+                if (!length)
+                    throw new Error(`${modelName}.load: 'where' argument: Missing arithmetic operator, expected one of: ${operators.map(_ => `'${_}'`).join(", ")}`);
+                if (!operators.includes(operator))
+                    throw new Error(`${modelName}.load: 'where' argument: Wrong arithmetic operator, expected one of: ${operators.map(_ => `'${_}'`).join(", ")}`);
+                if (operator === "IS NULL") {
+                    if (length !== 1)
+                        throw new Error(`${modelName}.load: 'where' argument: 'IS NULL' operator is unary`);
+                    conditions.push(`${field} IS NULL`);
+                }
+                else if (operator === "NOT") {
+                    if (length !== 1)
+                        throw new Error(`${modelName}.load: 'where' argument: 'NOT' operator is unary`);
+                    conditions.push(`NOT ${field}`);
+                }
+                else {
+                    if (length !== 2)
+                        throw new Error(`${modelName}.load: 'where' argument: '${operator}' operator is binary`);
+                    if (operator === "IN") {
+                        if (!(value[1] instanceof Array))
+                            throw new Error(`${modelName}.load: 'where' argument: 'IN' right operand: Wrong type, expected Array`);
+                        conditions.push(`${field} IN (${value[1].map(_ => this.escape(_)).join(", ")})`);
+                    }
+                    else
+                        conditions.push(`${field} ${operator} ${this.escape(value[1])}`);
+                }
+            }
+            else
+                conditions.push(`${field} = ${this.escape(value)}`);
+        }
+        return [conditions.length ? conditions.join(" AND ") : "", false, false];
+    }
+    async connect(sync) {
+        try {
+            this.checkDB();
+            this.log("Connecting...");
+            await this.db.connect();
+            this.log("Connected");
+            if (this.autoSync || sync)
+                await this.sync();
+        }
+        catch (error) {
+            this.log(`Connecting: ${error instanceof Error ? error.message : JSON.stringify(error)}`);
+            throw error;
+        }
+    }
+    async sync() {
+        this.log("Syncing...");
+        await this.db.syncDataBase();
+        this.log("Synced");
+    }
+    async end() {
+        this.log("Closing connection...");
+        await this.db.end();
+        this.log("Connection closed");
+    }
+    begin() {
+        return this.db.begin();
+    }
+    escape(value) {
+        return this.db.escape(value);
+    }
+    /* eslint-enable @typescript-eslint/no-explicit-any */
+    model(modelName, _attributes, options, _methods) {
+        this.checkDB();
+        if (typeof modelName !== "string")
+            throw new Error("Sedentary.model: 'name' argument: Wrong type, expected 'string'");
+        if (!reModelAttributeName.test(modelName))
+            throw new Error(`Sedentary.model: '${modelName}' model: Invalid model name, expected ASCII letters, digits or underscore, cannot start with digit`);
+        if (this.models[modelName])
+            throw new Error(`Sedentary.model: '${modelName}' model: Model already defined`);
+        if (!_attributes)
+            _attributes = {};
+        if (!(_attributes instanceof Object))
+            throw new Error(`Sedentary.model: '${modelName}' model: 'attributes' argument: Wrong type, expected 'Object'`);
+        if (!options)
+            options = {};
+        if (!(options instanceof Object))
+            throw new Error(`Sedentary.model: '${modelName}' model: 'options' argument: Wrong type, expected 'Object'`);
+        for (const k in options)
+            if (!allowedOption.includes(k))
+                throw new Error(`Sedentary.model: '${modelName}' model: 'options' argument: Unknown '${k}' option`);
+        if (options.int8id && options.parent)
+            throw new Error(`Sedentary.model: '${modelName}' model: 'int8id' and 'parent' options conflict each other`);
+        if (options.int8id && options.primaryKey)
+            throw new Error(`Sedentary.model: '${modelName}' model: 'int8id' and 'primaryKey' options conflict each other`);
+        if (options.parent && options.primaryKey)
+            throw new Error(`Sedentary.model: '${modelName}' model: 'parent' and 'primaryKey' options conflict each other`);
+        let autoIncrement = true;
+        const { indexes, int8id, parent, primaryKey, sync, tableName } = { sync: this.doSync, tableName: toSqlName(modelName), ...options };
+        if (!reSqlName.test(tableName))
+            throw new Error(`Sedentary.model: '${modelName}' model: Invalid tableName '${tableName}', expected lowercase ASCII letters, digits or underscore, cannot start with digit`);
+        let aArray = int8id
+            ? [new Attribute({ ...this.Int8(), attributeName: "id", fieldName: toSqlName("id"), modelName, notNull: true, tableName, unique: true })]
+            : [new Attribute({ ...this.Int({ size: 4 }), attributeName: "id", fieldName: toSqlName("id"), modelName, notNull: true, tableName, unique: true })];
+        let constraints = [{ attribute: aArray[0], constraintName: `${tableName}_id_unique`, type: "u" }];
+        const iArray = [];
+        let pk = aArray[0];
+        let attr2field = { id: "id" };
+        if (!_methods)
+            _methods = {};
+        if (!(_methods instanceof Object))
+            throw new Error(`Sedentary.model: '${modelName}' model: 'methods' option: Wrong type, expected 'Object'`);
+        if (parent)
+            if (!parent[attributes])
+                throw new Error(`Sedentary.model: '${modelName}' model: 'parent' option: Wrong type, expected 'Model'`);
+        if (primaryKey && typeof primaryKey !== "string")
+            throw new Error(`Sedentary.model: '${modelName}' model: 'primaryKey' option: Wrong type, expected 'string'`);
+        if (primaryKey && !Object.keys(_attributes).includes(primaryKey))
+            throw new Error(`Sedentary.model: '${modelName}' model: 'primaryKey' option: Attribute '${primaryKey}' does not exists`);
+        if (parent || primaryKey) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            attr2field = parent ? { ...parent.attr2field } : {};
+            autoIncrement = false;
+            aArray = [];
+            constraints = [];
+        }
+        for (const attributeName of Object.keys(_attributes).sort()) {
+            if (!reModelAttributeName.test(attributeName))
+                throw new Error(`Sedentary.model: '${modelName}' model: '${attributeName}' attribute: Invalid attribute name, expected ASCII letters, digits or underscore, cannot start with digit`);
+            if (reservedNames.includes(attributeName))
+                throw new Error(`Sedentary.model: '${modelName}' model: '${attributeName}' attribute: Reserved name`);
+            const attributeDefinition = _attributes[attributeName];
+            let { [base]: _base, defaultValue, fieldName, foreignKey, notNull, [size]: _size, type, unique } = (() => {
+                if (!(attributeDefinition instanceof Type))
+                    throw new Error(`Sedentary.model: '${modelName}' model: '${attributeName}' attribute: '${attributeName}': Wrong type, expected 'Type'`);
+                const ret = new Attribute({ attributeName, fieldName: toSqlName(attributeName), modelName, notNull: false, tableName, unique: false, ...attributeDefinition });
+                const { defaultValue, fieldName, notNull, unique } = ret;
+                if (defaultValue === null)
+                    throw new Error(`Sedentary.model: '${modelName}' model: '${attributeName}' attribute: 'defaultValue' option: Does 'null' default value really make sense?`);
+                if (typeof fieldName !== "string")
+                    throw new Error(`Sedentary.model: '${modelName}' model: '${attributeName}' attribute: 'fieldName' option: Wrong type, expected 'string'`);
+                if (!reSqlName.test(fieldName)) {
+                    throw new Error(`Sedentary.model: '${modelName}' model: '${attributeName}' attribute: Invalid fieldName '${fieldName}', ` +
+                        "expected lowercase ASCII letters, digits or underscore, cannot start with digit");
+                }
+                if (typeof notNull !== "boolean")
+                    throw new Error(`Sedentary.model: '${modelName}' model: '${attributeName}' attribute: 'notNull' option: Wrong type, expected 'boolean'`);
+                if (typeof unique !== "boolean")
+                    throw new Error(`Sedentary.model: '${modelName}' model: '${attributeName}' attribute: 'unique' option: Wrong type, expected 'boolean'`);
+                const { [base]: _base, defaultValue: _defaultValue } = ret;
+                if (_defaultValue !== undefined) {
+                    if (_base === BigInt && typeof _defaultValue !== "bigint")
+                        throw new Error(`Sedentary.model: '${modelName}' model: '${attributeName}' attribute: 'defaultValue' option: Wrong type, expected 'BigInt'`);
+                    if (_base === Date && !(_defaultValue instanceof Date))
+                        throw new Error(`Sedentary.model: '${modelName}' model: '${attributeName}' attribute: 'defaultValue' option: Wrong type, expected 'Date'`);
+                    if (_base === Number && typeof _defaultValue !== "number")
+                        throw new Error(`Sedentary.model: '${modelName}' model: '${attributeName}' attribute: 'defaultValue' option: Wrong type, expected 'number'`);
+                    if (_base === String && typeof _defaultValue !== "string")
+                        throw new Error(`Sedentary.model: '${modelName}' model: '${attributeName}' attribute: 'defaultValue' option: Wrong type, expected 'string'`);
+                }
+                return ret;
+            })();
+            if (foreignKey) {
+                const options = foreignKey.options || {};
+                if (foreignKey.options !== undefined && !(foreignKey.options instanceof Object))
+                    throw new Error(`Sedentary.FKey: '${modelName}' model: '${attributeName}' attribute: Wrong options type, expected 'Object'`);
+                for (const k in options)
+                    if (!["onDelete", "onUpdate"].includes(k))
+                        throw new Error(`Sedentary.FKey: '${modelName}' model: '${attributeName}' attribute: Unknown option '${k}'`);
+                for (const onChange of ["onDelete", "onUpdate"]) {
+                    const actions = ["cascade", "no action", "restrict", "set default", "set null"];
+                    let action = options[onChange];
+                    if (!action)
+                        action = options[onChange] = "no action";
+                    if (action && !actions.includes(action))
+                        throw new Error(`Sedentary.FKey: '${modelName}' model: '${attributeName}' attribute: '${onChange}' option: Wrong value, expected ${actions.map(_ => `'${_}'`).join(" | ")}`);
+                }
+                foreignKey.options = options;
+            }
+            if (primaryKey === attributeName) {
+                notNull = true;
+                unique = true;
+            }
+            if (defaultValue)
+                notNull = true;
+            const attribute = new Attribute({ attributeName, [base]: _base, defaultValue, fieldName, foreignKey, modelName, notNull, [size]: _size, tableName, type, unique });
+            if (primaryKey === attributeName)
+                pk = attribute;
+            aArray.push(attribute);
+            if (type !== "NONE")
+                attr2field[attributeName] = fieldName;
+            if (foreignKey)
+                constraints.push({ attribute, constraintName: `fkey_${fieldName}_${foreignKey.tableName}_${foreignKey.fieldName}`, type: "f" });
+            if (unique)
+                constraints.push({ attribute, constraintName: `${tableName}_${fieldName}_unique`, type: "u" });
+        }
+        if (indexes) {
+            const originalAttributes = _attributes;
+            if (!(indexes instanceof Object))
+                throw new Error(`Sedentary.model: '${modelName}' model: 'indexes' option: Wrong type, expected 'Object'`);
+            for (const indexName in indexes) {
+                if (aArray.some(({ fieldName, unique }) => unique && `${tableName}_${fieldName}_unique` === indexName))
+                    throw new Error(`Sedentary.model: '${modelName}' model: '${indexName}' index: index name already inferred by the unique constraint on an attribute`);
+                const idx = indexes[indexName];
+                const checkAttribute = (attribute, l) => {
+                    if (typeof attribute !== "string")
+                        throw new Error(`Sedentary.model: '${modelName}' model: '${indexName}' index: #${l + 1} attribute: Wrong type, expected 'string'`);
+                    if (!(attribute in originalAttributes))
+                        throw new Error(`Sedentary.model: '${modelName}' model: '${indexName}' index: #${l + 1} attribute: Unknown attribute '${attribute}'`);
+                };
+                let attributes;
+                let type = "btree";
+                let unique = false;
+                if (idx instanceof Array) {
+                    idx.forEach(checkAttribute);
+                    attributes = idx;
+                }
+                else if (typeof idx === "string") {
+                    checkAttribute(idx, 0);
+                    attributes = [idx];
+                }
+                else if (idx instanceof Object) {
+                    for (const k in idx)
+                        if (!["attributes", "type", "unique"].includes(k))
+                            throw new Error(`Sedentary.model: '${modelName}' model: '${indexName}' index: Unknown index option '${k}'`);
+                    ({ attributes, type, unique } = { type: "btree", unique: false, ...idx });
+                    if (!attributes)
+                        throw new Error(`Sedentary.model: '${modelName}' model: '${indexName}' index: Missing 'attributes' option`);
+                    if (attributes instanceof Array)
+                        attributes.forEach(checkAttribute);
+                    else if (typeof attributes === "string") {
+                        checkAttribute(attributes, 0);
+                        attributes = [attributes];
+                    }
+                    else
+                        throw new Error(`Sedentary.model: '${modelName}' model: '${indexName}' index: 'attributes' option: Wrong type, expected 'FieldNames'`);
+                    if (typeof type !== "string")
+                        throw new Error(`Sedentary.model: '${modelName}' model: '${indexName}' index: 'type' option: Wrong type, expected 'string'`);
+                    if (!["btree", "hash"].includes(type))
+                        throw new Error(`Sedentary.model: '${modelName}' model: '${indexName}' index: 'type' option: Wrong value, expected 'btree' or 'hash'`);
+                    if (typeof unique !== "boolean")
+                        throw new Error(`Sedentary.model: '${modelName}' model: '${indexName}' index: 'unique' option: Wrong type, expected 'boolean'`);
+                }
+                else
+                    throw new Error(`Sedentary.model: '${modelName}' model: '${indexName}' index: Wrong type, expected 'Object'`);
+                iArray.push({ fields: attributes, indexName, type, unique });
+            }
+        }
+        this.models[modelName] = true;
+        const foreignKeys = aArray
+            .filter(_ => _.foreignKey)
+            .reduce((ret, curr) => {
+            ret[curr.attributeName] = true;
+            return ret;
+        }, {});
+        for (const foreignKey in foreignKeys) {
+            if (`${foreignKey}Load` in _attributes)
+                throw new Error(`Sedentary.model: '${modelName}' model: '${foreignKey}' attribute: '${foreignKey}Load' inferred methods conflicts with an attribute`);
+            if (`${foreignKey}Load` in _methods)
+                throw new Error(`Sedentary.model: '${modelName}' model: '${foreignKey}' attribute: '${foreignKey}Load' inferred methods conflicts with a method`);
+        }
+        for (const method in _methods)
+            if (method in _attributes)
+                throw new Error(`Sedentary.model: '${modelName}' model: '${method}' method: conflicts with an attribute`);
+        const checkParent = (parent) => {
+            if (!parent)
+                return;
+            for (const attribute in _attributes) {
+                if (attribute in parent[attributes])
+                    throw new Error(`Sedentary.model: '${modelName}' model: '${attribute}' attribute: conflicts with an attribute of '${parent.modelName}' model`);
+                if (attribute in parent[methods])
+                    throw new Error(`Sedentary.model: '${modelName}' model: '${attribute}' attribute: conflicts with a method of '${parent.modelName}' model`);
+                for (const foreignKey in parent.foreignKeys)
+                    if (attribute === `${foreignKey}Load`)
+                        throw new Error(`Sedentary.model: '${modelName}' model: '${attribute}' attribute: conflicts with an inferred methods of '${parent.modelName}' model`);
+            }
+            for (const foreignKey in foreignKeys) {
+                if (`${foreignKey}Load` in parent[attributes])
+                    throw new Error(`Sedentary.model: '${modelName}' model: '${foreignKey}' attribute: '${foreignKey}Load' inferred methods conflicts with an attribute of '${parent.modelName}' model`);
+                if (`${foreignKey}Load` in parent[methods])
+                    throw new Error(`Sedentary.model: '${modelName}' model: '${foreignKey}' attribute: '${foreignKey}Load' inferred methods conflicts with a method of '${parent.modelName}' model`);
+            }
+            for (const method in _methods) {
+                if (method in parent[attributes])
+                    throw new Error(`Sedentary.model: '${modelName}' model: '${method}' method: conflicts with an attribute of '${parent.modelName}' model`);
+                for (const foreignKey in parent.foreignKeys)
+                    if (`${foreignKey}Load` === method)
+                        throw new Error(`Sedentary.model: '${modelName}' model: '${method}' method: conflicts with an inferred methods of '${parent.modelName}' model`);
+            }
+            checkParent(parent.parent);
+        };
+        checkParent(parent);
+        const ret = class extends (parent || EntryBase) {
+            constructor(from, tx) {
+                super(from);
+                if (tx)
+                    tx.addEntry(this);
+            }
+        };
+        const table = new Table({ attributes: aArray, autoIncrement, constraints, indexes: iArray, model: ret, parent, pk, sync, tableName });
+        this.db.tables.push(table);
+        const cancel_ = this.db.cancel(tableName);
+        const cancel = (where, tx) => cancel_(this.createWhere(modelName, attr2field, where)[0], tx);
+        Object.defineProperty(cancel, "name", { value: `${modelName}.cancel` });
+        const load_ = this.db.load(tableName, attr2field, pk, ret, table);
+        const load = (where, ...args) => {
+            let order = undefined;
+            let limit = undefined;
+            let tx = undefined;
+            let lock = undefined;
+            const checkArgs = (first) => {
+                if (!args.length)
+                    return;
+                if (args[0] instanceof Transaction) {
+                    if (first)
+                        order = undefined;
+                    limit = undefined;
+                    [tx, lock] = args;
+                }
+                else if (typeof args[0] === "number") {
+                    if (first)
+                        order = undefined;
+                    [limit, tx, lock] = args;
+                }
+                else {
+                    if (first) {
+                        order = args.shift();
+                        checkArgs(false);
+                    }
+                    else
+                        throw new Error(`${modelName}.load: 'limit' argument: Wrong type, expected 'number'`);
+                }
+            };
+            checkArgs(true);
+            if (!this.checkOrderBy(order, attr2field, modelName))
+                throw new Error(`${modelName}.load: 'order' argument: Wrong type, expected 'string | string[]'`);
+            if (tx && !(tx instanceof Transaction))
+                throw new Error(`${modelName}.load: 'tx' argument: Wrong type, expected 'Transaction'`);
+            return load_(this.createWhere(modelName, attr2field, where)[0], order, limit, tx, lock);
+        };
+        Object.defineProperty(load, "name", { value: `${modelName}.load` });
+        Object.defineProperty(ret, "cancel", { value: cancel });
+        Object.defineProperty(ret, "name", { value: modelName });
+        Object.defineProperty(ret, "load", { value: load });
+        Object.defineProperty(ret, "attr2field", { value: attr2field });
+        Object.defineProperty(ret, attributes, { value: _attributes });
+        Object.defineProperty(ret, "foreignKeys", { value: foreignKeys });
+        Object.defineProperty(ret, methods, { value: _methods });
+        Object.assign(ret.prototype, _methods);
+        const ensureActions = (entry) => {
+            if (!entry[actions])
+                Object.defineProperty(entry, actions, { configurable: true, value: [] });
+            return entry[actions];
+        };
+        const remove = this.db.remove(tableName, pk);
+        ret.prototype.remove = async function () {
+            if (!this[loaded])
+                throw new Error(`${modelName}.remove: Can't remove a never saved Entry`);
+            this.preRemove();
+            const records = await remove.call(this);
+            this.postRemove(records);
+            if (this[transaction])
+                ensureActions(this).push({ action: "remove", records });
+            return records;
+        };
+        Object.defineProperty(ret.prototype.remove, "name", { value: `${modelName}.remove` });
+        const save = this.db.save(tableName, attr2field, pk);
+        ret.prototype.save = async function () {
+            this.preSave();
+            const records = await save.call(this);
+            this.postSave(records);
+            if (this[transaction])
+                ensureActions(this).push({ action: "save", records });
+            return records;
+        };
+        Object.defineProperty(ret.prototype.save, "name", { value: `${modelName}.save` });
+        for (const attribute of aArray)
+            Object.defineProperty(ret, attribute.attributeName, { value: attribute });
+        for (const key of ["attributeName", base, "fieldName", "modelName", size, "tableName", "type", "unique"])
+            Object.defineProperty(ret, key, { value: pk[key] });
+        return ret;
+    }
+}