sedentary 0.0.25 → 0.0.28

package/{index.js → dist/cjs/index.js}

@@ -1,9 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Sedentary = exports.Type = exports.Transaction = exports.EntryBase = void 0;
+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"];
@@ -23,7 +26,7 @@ class Sedentary {
         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 } = Object.assign({ autoSync: true, sync: true }, options);
+        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))
@@ -212,10 +215,10 @@ class Sedentary {
         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 } = Object.assign({ sync: this.doSync, tableName: modelName }, options);
+        const { indexes, int8id, parent, primaryKey, sync, tableName } = { sync: this.doSync, tableName: modelName, ...options };
         let aarray = int8id
-            ? [new db_1.Attribute(Object.assign(Object.assign({}, this.INT8()), { attributeName: "id", fieldName: "id", modelName, notNull: true, tableName, unique: true }))]
-            : [new db_1.Attribute(Object.assign(Object.assign({}, this.INT(4)), { attributeName: "id", fieldName: "id", modelName, notNull: true, tableName, unique: true }))];
+            ? [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];
@@ -233,7 +236,7 @@ class Sedentary {
             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 ? Object.assign({}, parent.attr2field) : {};
+            attr2field = parent ? { ...parent.attr2field } : {};
             autoIncrement = false;
             aarray = [];
             constraints = [];
@@ -246,18 +249,18 @@ class Sedentary {
                     throw new Error(`${message1} 'this.FKEY' can't be used directly`);
                 if (func !== this.DATETIME && func !== this.INT && func !== this.INT8 && func !== this.VARCHAR)
                     throw new Error(`${message1} ${message2}`);
-                return new db_1.Attribute(Object.assign({ attributeName, defaultValue, fieldName, modelName, notNull, tableName, unique }, func()));
+                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(Object.assign({ attributeName, fieldName: attributeName, modelName, notNull: false, tableName }, attributeDefinition));
+                        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 = Object.assign({ defaultValue: undefined, fieldName: attributeName, notNull: false, unique: false }, attributeDefinition);
+                    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?`);
@@ -270,7 +273,7 @@ class Sedentary {
                     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(Object.assign({ attributeName, defaultValue, fieldName, modelName, notNull, tableName, unique }, 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'`);
@@ -348,7 +351,7 @@ class Sedentary {
                     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 } = Object.assign({ type: "btree", unique: false }, idx));
+                    ({ 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)

package/dist/es/db.js

@@ -0,0 +1,100 @@
+export class EntryBase {
+    constructor(from) {
+        if (from === "load")
+            this.preLoad();
+        else {
+            if (from)
+                Object.assign(this, from);
+            this.construct();
+        }
+    }
+    construct() { }
+    postLoad() { }
+    postSave() { }
+    preLoad() { }
+    preSave() { }
+    async save() {
+        return false;
+    }
+}
+export class Type {
+    constructor(from) {
+        Object.assign(this, from);
+    }
+}
+export class Attribute extends Type {
+    constructor(from) {
+        super(from);
+    }
+}
+function autoImplement() {
+    return class {
+        constructor(defaults) {
+            Object.assign(this, defaults);
+        }
+    };
+}
+export class Table extends autoImplement() {
+    autoIncrementOwn;
+    oid;
+    findField(name) {
+        return this.attributes.filter(_ => _.fieldName === name)[0];
+    }
+}
+export class DB {
+    tables = [];
+    log;
+    sync = true;
+    constructor(log) {
+        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);
+    }
+}
+export class Transaction {
+    entries = [];
+    addEntry(entry) {
+        this.entries.push(entry);
+    }
+    clean() {
+        const { entries } = this;
+        for (const entry of entries)
+            delete entry.tx;
+        this.entries = [];
+    }
+    async commit() {
+        this.clean();
+    }
+    async rollback() {
+        this.clean();
+    }
+}

package/dist/es/index.js

@@ -0,0 +1,454 @@
+import { Attribute, EntryBase, Table, Transaction, Type } from "./db";
+export { Attribute, DB, EntryBase, Table, Transaction, Type } from "./db";
+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"]
+];
+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;
+    }
+    DATETIME() {
+        return new Type({ base: Date, type: "DATETIME" });
+    }
+    FKEY(attribute, options) {
+        const { attributeName, base, fieldName, size, tableName, type } = attribute;
+        return new 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 Type({ base: Number, size, type: "INT" });
+    }
+    INT8() {
+        return new Type({ base: String, size: 8, type: "INT8" });
+    }
+    VARCHAR(size) {
+        const message = "Sedentary.VARCHAR: 'size' argument: Wrong value, expected positive integer";
+        size = size ? this.checkSize(size, message) : undefined;
+        return new 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) {
+        if (!order)
+            return true;
+        if (!(order instanceof Array))
+            return false;
+        const provided = {};
+        for (const attribute of order) {
+            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 Attribute({ ...this.INT8(), attributeName: "id", fieldName: "id", modelName, notNull: true, tableName, unique: true })]
+            : [new 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 (func !== this.DATETIME && func !== this.INT && func !== this.INT8 && func !== this.VARCHAR)
+                    throw new Error(`${message1} ${message2}`);
+                return new 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 Type)
+                        return new 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 Type)
+                        return new 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 === 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, 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 || EntryBase) {
+        };
+        const table = new 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, order, tx) => {
+            if (order instanceof Transaction) {
+                tx = order;
+                order = undefined;
+            }
+            if (!this.checkOrderBy(order, attr2field, modelName))
+                throw new Error(`${modelName}.load: 'order' argument: Wrong type, expected 'string[]'`);
+            const [str] = this.createWhere(modelName, attr2field, where);
+            const ret = await load_(str, order, tx);
+            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 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;
+    }
+}

package/{index.d.ts → dist/types/index.d.ts}

@@ -1,5 +1,5 @@
 import { Attribute, DB, EntryBase, ForeignKeyOptions, Natural, Transaction, Type } from "./db";
-export { EntryBase, ForeignKeyActions, ForeignKeyOptions, Natural, Transaction, Type } from "./db";
+export { Attribute, DB, EntryBase, ForeignKeyActions, ForeignKeyOptions, Index, Natural, Table, Transaction, Type } from "./db";
 export declare type TypeDefinition<N extends Natural, E> = (() => Type<N, E>) | Type<N, E>;
 export interface AttributeOptions<N extends Natural, E> {
     defaultValue?: N;

package/package.json

@@ -39,6 +39,8 @@
     "sqlite"
   ],
   "license": "MIT",
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/es/index.js",
   "name": "sedentary",
   "prettier": {
     "arrowParens": "avoid",
@@ -57,15 +59,14 @@
     "packagejson": "node -r ts-node/register utils.ts packagejson",
     "test": "mocha -r ts-node/register test/*ts",
     "travis": "node -r ts-node/register utils.ts travis",
-    "tsc": "tsc --declaration",
+    "tsc": "tsc -p tsconfig.cjs.json && tsc -p tsconfig.es.json && tsc -p tsconfig.types.json",
     "version": "node -r ts-node/register utils.ts version"
   },
   "tsd": {
     "compilerOptions": {
       "alwaysStrict": true,
-      "declaration": true,
       "esModuleInterop": true,
-      "module": "commonjs",
+      "moduleResolution": "node",
       "noImplicitAny": true,
       "noImplicitReturns": true,
       "noImplicitThis": true,
@@ -73,10 +74,9 @@
       "strictBindCallApply": true,
       "strictFunctionTypes": true,
       "strictNullChecks": true,
-      "strictPropertyInitialization": true,
-      "target": "es2017"
+      "strictPropertyInitialization": true
     }
   },
-  "types": "index.d.ts",
-  "version": "0.0.25"
+  "types": "./dist/types/index.d.ts",
+  "version": "0.0.28"
 }