sedentary 0.0.42 → 0.0.43

package/README.md

@@ -52,7 +52,7 @@ const db = new Sedentary("file.db");
 
 class Items extends db.model("Item", {
   num: db.INT,
-  str: db.VARCHAR(30)
+  str: db.VarChar(30)
 });
 
 (async function () {

package/package.json

@@ -33,16 +33,17 @@
   "repository": "https://github.com/iccicci/sedentary",
   "scripts": {
     "build": "make build",
-    "coverage": "jest --coverage --runInBand",
+    "coverage": "jest --coverage --no-cache --runInBand",
     "deploy": "npm_config_registry=\"registry.npmjs.org\" npm publish",
     "precoverage": "make pretest",
     "preinstall": "if [ -f Makefile ] ; then make ; fi",
     "pretest": "make pretest",
-    "test": "jest --runInBand"
+    "test": "jest --no-cache --runInBand"
   },
   "tsd": {
     "compilerOptions": {
       "alwaysStrict": true,
+      "composite": false,
       "esModuleInterop": true,
       "moduleResolution": "Node",
       "noImplicitAny": true,
@@ -57,5 +58,5 @@
     }
   },
   "types": "./dist/types/index.d.ts",
-  "version": "0.0.42"
+  "version": "0.0.43"
 }

package/dist/cjs/db.js

@@ -1,115 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Transaction = exports.DB = exports.Table = exports.Attribute = exports.Type = exports.EntryBase = void 0;
-class EntryBase {
-    constructor(from) {
-        if (from === "load")
-            this.preLoad();
-        else {
-            if (from)
-                Object.assign(this, from);
-            this.construct();
-        }
-    }
-    construct() { }
-    postLoad() { }
-    postRemove() { }
-    postSave() { }
-    preLoad() { }
-    preRemove() { }
-    preSave() { }
-    async remove() {
-        return false;
-    }
-    async save() {
-        return false;
-    }
-}
-exports.EntryBase = EntryBase;
-class Type {
-    constructor(from) {
-        Object.assign(this, from);
-    }
-}
-exports.Type = Type;
-class Attribute extends Type {
-    constructor(from) {
-        super(from);
-    }
-}
-exports.Attribute = Attribute;
-function autoImplement() {
-    return class {
-        constructor(defaults) {
-            Object.assign(this, defaults);
-        }
-    };
-}
-class Table extends autoImplement() {
-    findField(name) {
-        return this.attributes.filter(_ => _.fieldName === name)[0];
-    }
-}
-exports.Table = Table;
-class DB {
-    constructor(log) {
-        this.tables = [];
-        this.sync = true;
-        this.log = log;
-    }
-    findTable(name) {
-        return this.tables.filter(_ => _.tableName === name)[0];
-    }
-    indexesEq(a, b) {
-        if (a.fields.length !== b.fields.length)
-            return false;
-        for (const i in a.fields)
-            if (a.fields[i] !== b.fields[i])
-                return false;
-        if (a.type !== b.type)
-            return false;
-        if (a.unique !== b.unique)
-            return false;
-        return true;
-    }
-    async syncDataBase() {
-        for (const table of this.tables) {
-            this.sync = table.sync;
-            await this.syncTable(table);
-            const indexes = await this.dropConstraints(table);
-            await this.dropIndexes(table, indexes);
-            await this.dropFields(table);
-            await this.syncFields(table);
-            await this.syncSequence(table);
-            await this.syncConstraints(table);
-            await this.syncIndexes(table);
-        }
-    }
-    syncLog(message) {
-        this.log(this.sync ? message : "NOT SYNCING: " + message);
-    }
-}
-exports.DB = DB;
-class Transaction {
-    constructor(log) {
-        this.entries = [];
-        this.log = log;
-    }
-    addEntry(entry) {
-        Object.defineProperty(entry, "tx", { configurable: true, value: this });
-        this.entries.push(entry);
-    }
-    clean() {
-        const { entries } = this;
-        for (const entry of entries)
-            Object.defineProperty(entry, "tx", { configurable: true, value: null });
-        this.entries = [];
-    }
-    async commit() {
-        this.clean();
-    }
-    async rollback() {
-        this.clean();
-    }
-}
-exports.Transaction = Transaction;

package/dist/cjs/index.js

@@ -1,516 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Sedentary = exports.Type = exports.Transaction = exports.Table = exports.EntryBase = exports.DB = exports.Attribute = void 0;
-const db_1 = require("./db");
-var db_2 = require("./db");
-Object.defineProperty(exports, "Attribute", { enumerable: true, get: function () { return db_2.Attribute; } });
-Object.defineProperty(exports, "DB", { enumerable: true, get: function () { return db_2.DB; } });
-Object.defineProperty(exports, "EntryBase", { enumerable: true, get: function () { return db_2.EntryBase; } });
-Object.defineProperty(exports, "Table", { enumerable: true, get: function () { return db_2.Table; } });
-Object.defineProperty(exports, "Transaction", { enumerable: true, get: function () { return db_2.Transaction; } });
-Object.defineProperty(exports, "Type", { enumerable: true, get: function () { return db_2.Type; } });
-const operators = ["=", ">", "<", ">=", "<=", "<>", "IN", "IS NULL", "LIKE", "NOT"];
-const allowedOption = ["indexes", "int8id", "parent", "primaryKey", "sync", "tableName"];
-const reservedNames = [
-    ...["attr2field", "attributeName", "attributes", "base", "class", "construct", "constructor", "defaultValue", "entry", "fieldName", "foreignKeys", "load"],
-    ...["loaded", "methods", "name", "postLoad", "postSave", "preLoad", "preSave", "primaryKey", "prototype", "save", "size", "tableName", "tx", "type"]
-];
-class Sedentary {
-    constructor(options) {
-        this.doSync = true;
-        this.models = {};
-        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() {
-        return new db_1.Type({ base: Boolean, type: "BOOLEAN" });
-    }
-    DATETIME() {
-        return new db_1.Type({ base: Date, type: "DATETIME" });
-    }
-    FKEY(attribute, options) {
-        const { attributeName, base, fieldName, size, tableName, type } = attribute;
-        return new db_1.Type({ base, foreignKey: { attributeName, fieldName, options, tableName }, size, type });
-    }
-    INT(size) {
-        const message = "Sedentary.INT: 'size' argument: Wrong value, expected 2 or 4";
-        size = size ? this.checkSize(size, message) : 4;
-        if (size !== 2 && size !== 4)
-            throw new Error(message);
-        return new db_1.Type({ base: Number, size, type: "INT" });
-    }
-    INT8() {
-        return new db_1.Type({ base: BigInt, size: 8, type: "INT8" });
-    }
-    NUMBER() {
-        return new db_1.Type({ base: Number, type: "NUMBER" });
-    }
-    VARCHAR(size) {
-        const message = "Sedentary.VARCHAR: 'size' argument: Wrong value, expected positive integer";
-        size = size ? this.checkSize(size, message) : undefined;
-        return new db_1.Type({ base: String, size, 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(size, message) {
-        const str = size.toString();
-        const parsed = parseInt(str, 10);
-        if (str !== parsed.toString())
-            throw new Error(message);
-        return parsed;
-    }
-    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 (e) {
-            this.log("Connecting: " + (e instanceof Error ? e.message : JSON.stringify(e)));
-            throw e;
-        }
-    }
-    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");
-    }
-    async 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 (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: modelName, ...options };
-        let aarray = int8id
-            ? [new db_1.Attribute({ ...this.INT8(), attributeName: "id", fieldName: "id", modelName, notNull: true, tableName, unique: true })]
-            : [new db_1.Attribute({ ...this.INT(4), attributeName: "id", fieldName: "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 (reservedNames.includes(attributeName))
-                throw new Error(`Sedentary.model: '${modelName}' model: '${attributeName}' attribute: Reserved name`);
-            const call = (defaultValue, fieldName, notNull, unique, func, message1, message2) => {
-                if (func === this.FKEY)
-                    throw new Error(`${message1} 'this.FKEY' can't be used directly`);
-                if (![this.BOOLEAN, this.DATETIME, this.NUMBER, this.INT, this.INT8, this.VARCHAR].includes(func))
-                    throw new Error(`${message1} ${message2}`);
-                return new db_1.Attribute({ attributeName, defaultValue, fieldName, modelName, notNull, tableName, unique, ...func() });
-            };
-            const attributeDefinition = attributes[attributeName];
-            let { base, defaultValue, fieldName, foreignKey, notNull, size, type, unique } = (() => {
-                const ret = (() => {
-                    if (attributeDefinition instanceof db_1.Type)
-                        return new db_1.Attribute({ attributeName, fieldName: attributeName, modelName, notNull: false, tableName, ...attributeDefinition });
-                    if (attributeDefinition instanceof Function)
-                        return call(undefined, attributeName, false, false, attributeDefinition, `Sedentary.model: '${modelName}' model: '${attributeName}' attribute:`, "Wrong type, expected 'Attribute'");
-                    if (!(attributeDefinition instanceof Object))
-                        throw new Error(`Sedentary.model: '${modelName}' model: '${attributeName}' attribute: Wrong attribute type, expected 'Attribute'`);
-                    const attributeDefaults = { defaultValue: undefined, fieldName: attributeName, notNull: false, unique: false, ...attributeDefinition };
-                    const { defaultValue, fieldName, notNull, unique, type } = attributeDefaults;
-                    if (defaultValue === null)
-                        throw new Error(`Sedentary.model: '${modelName}' model: '${attributeName}' attribute: 'defaultValue' option: Does 'null' default value really makes sense?`);
-                    if (typeof fieldName !== "string")
-                        throw new Error(`Sedentary.model: '${modelName}' model: '${attributeName}' attribute: 'fieldName' option: Wrong type, expected 'string'`);
-                    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'`);
-                    if (type === undefined)
-                        throw new Error(`Sedentary.model: '${modelName}' model: '${attributeName}' attribute: Missing 'type' option`);
-                    if (type instanceof db_1.Type)
-                        return new db_1.Attribute({ attributeName, defaultValue, fieldName, modelName, notNull, tableName, unique, ...type });
-                    if (type instanceof Function)
-                        return call(defaultValue, fieldName, notNull, unique, type, `Sedentary.model: '${modelName}' model: '${attributeName}' attribute: 'type' option:`, "Wrong type, expected 'Type'");
-                    throw new Error(`Sedentary.model: '${modelName}' model: '${attributeName}' attribute: 'type' option: Wrong type, expected 'Type'`);
-                })();
-                const { base, 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 db_1.Attribute({ attributeName, base, defaultValue, fieldName, foreignKey, modelName, notNull, size, tableName, type, unique });
-            if (primaryKey === attributeName)
-                pk = attribute;
-            aarray.push(attribute);
-            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 flds = 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.filter(({ fieldName, unique }) => unique && `${tableName}_${fieldName}_unique` === indexName).length !== 0)
-                    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 flds))
-                        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 || db_1.EntryBase) {
-            constructor(from, tx) {
-                super(from);
-                if (tx)
-                    tx.addEntry(this);
-            }
-        };
-        const table = new db_1.Table({ autoIncrement, constraints, attributes: aarray, indexes: iarray, model: ret, parent, pk, sync, tableName });
-        this.db.tables.push(table);
-        const load_ = this.db.load(tableName, attr2field, pk, ret, table);
-        const load = async (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 db_1.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 db_1.Transaction))
-                throw new Error(`${modelName}.load: 'tx' argument: Wrong type, expected 'Transaction'`);
-            const [str] = this.createWhere(modelName, attr2field, where);
-            const ret = await load_(str, order, limit, tx, lock);
-            return ret;
-        };
-        Object.defineProperty(load, "name", { value: modelName + ".load" });
-        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 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 ret = await remove.call(this);
-            if (ret)
-                this.postRemove();
-            return ret;
-        };
-        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 ret = await save.call(this);
-            if (ret)
-                this.postSave();
-            return ret;
-        };
-        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;
-    }
-}
-exports.Sedentary = Sedentary;