sedentary 0.0.13 → 0.0.17

package/README.md

@@ -9,6 +9,7 @@
 [![Stars][stars-badge]][github-url]
 
 [![Types][types-badge]][npm-url]
+[![Documentation][doc-badge]][doc-url]
 [![Dependents][deps-badge]][npm-url]
 [![Donate][donate-badge]][donate-url]
 
@@ -16,6 +17,8 @@
 [code-url]: https://codeclimate.com/github/iccicci/sedentary
 [cover-badge]: https://codeclimate.com/github/iccicci/sedentary/badges/coverage.svg
 [deps-badge]: https://badgen.net/npm/dependents/sedentary?icon=npm&cache=300
+[doc-badge]: https://readthedocs.org/projects/sedentary/badge/?version=latest
+[doc-url]: https://sedentary.readthedocs.io/
 [donate-badge]: https://badgen.net/badge/donate/bitcoin?icon=bitcoin&cache=300
 [donate-url]: https://blockchain.info/address/1Md9WFAHrXTb3yPBwQWmUfv2RmzrtbHioB
 [github-url]: https://github.com/iccicci/sedentary
@@ -115,10 +118,6 @@ To work with the package under Windows, be sure to configure `bash.exe` as your
 
 Do not hesitate to report any bug or inconsistency [@github](https://github.com/iccicci/sedentary/issues).
 
-# ChangeLog
-
-[ChangeLog](https://github.com/iccicci/sedentary/blob/master/CHANGELOG.md)
-
 # Donating
 
 If you find useful this package, please consider the opportunity to donate some satoshis to this bitcoin address:

package/index.d.ts

@@ -1,79 +1,117 @@
-import { DB, Entry, Index, Meta, Natural, Type } from "./lib/db";
-declare type TypeDefinition<N extends Natural, E extends Entry> = (() => Type<N, E>) | Type<N, E>;
-interface FieldOptions<N extends Natural, E extends Entry> {
+import { DB, Entry, Meta, Natural, Type } from "./lib/db";
+export { Entry, Natural, Type } from "./lib/db";
+export declare type TypeDefinition<N extends Natural, E> = (() => Type<N, E>) | Type<N, E>;
+export interface AttributeOptions<N extends Natural, E> {
     defaultValue?: N;
     fieldName?: string;
     notNull?: boolean;
     type: TypeDefinition<N, E>;
     unique?: boolean;
 }
-declare type FieldDefinition<N extends Natural, E extends Entry> = TypeDefinition<N, E> | FieldOptions<N, E>;
-declare type FieldsDefinition = {
-    [key: string]: FieldDefinition<Natural, Entry>;
+export declare type AttributeDefinition<N extends Natural, E> = TypeDefinition<N, E> | AttributeOptions<N, E>;
+export declare type AttributesDefinition = {
+    [key: string]: AttributeDefinition<Natural, unknown>;
 };
-declare type ForeignKeyFileds<T, k> = T extends FieldDefinition<Natural, infer E> ? (E extends Entry ? k : never) : never;
-declare type ForeignKey<T> = T extends FieldDefinition<Natural, infer E> ? () => Promise<E> : never;
-declare type Keys<F extends FieldsDefinition> = {
-    [f in keyof F]?: ForeignKeyFileds<F[f], f>;
+declare type KeysAttributes<T, k> = T extends AttributeDefinition<Natural, infer E> ? (E extends Entry ? k : never) : never;
+declare type Keys<F extends AttributesDefinition> = {
+    [f in keyof F]?: KeysAttributes<F[f], f>;
 }[keyof F];
 declare type Methods<T> = {
     [key: string]: (this: T) => unknown;
 };
-declare type Native__<T> = T extends Type<infer N, Entry> ? N : never;
+declare type Native__<T> = T extends Type<infer N, unknown> ? N : never;
 declare type Native_<T> = T extends () => Type<infer N, infer E> ? Native__<Type<N, E>> : Native__<T>;
-declare type Native<T> = T extends FieldOptions<infer N, infer E> ? Native__<Type<N, E>> : Native_<T>;
-declare type Parent<T> = T extends Meta<Natural, infer R> ? R : never;
-declare type Options<M, T> = {
-    indexes?: {
-        [key: string]: Index;
-    };
+declare type Native<T> = T extends AttributeOptions<infer N, infer E> ? Native__<Type<N, E>> : Native_<T>;
+declare type Parent<T> = T extends Meta<Natural, infer E> ? E : never;
+export declare type IndexAttributes = string[] | string;
+export interface IndexOptions {
+    attributes: IndexAttributes;
+    type?: "btree" | "hash";
+    unique?: boolean;
+}
+export declare type IndexDefinition = IndexAttributes | IndexOptions;
+export declare type IndexesDefinition = {
+    [key: string]: IndexDefinition;
+};
+declare type BaseModelOptions<T> = {
+    indexes?: IndexesDefinition;
     init?: (this: T) => void;
-    methods?: M;
     sync?: boolean;
     tableName?: string;
 };
-declare type Model<F extends FieldsDefinition, M> = {
-    [f in keyof F]?: Native<F[f]>;
+export declare type ModelOptions<K extends string, M extends Methods<T>, P extends Meta<Natural, Entry>, T extends Entry> = BaseModelOptions<T> & {
+    int8id?: boolean;
+    methods?: M;
+    parent?: P;
+    primaryKey?: K;
+};
+declare type ForeignKey<T> = T extends AttributeDefinition<Natural, infer E> ? () => Promise<E> : never;
+declare type ModelWithMetods<A extends AttributesDefinition, M> = {
+    [a in keyof A]?: Native<A[a]>;
 } & {
-    [f in Keys<F> & string as `${f}Load`]?: ForeignKey<F[f]>;
+    [a in Keys<A> & string as `${a}Load`]?: ForeignKey<A[a]>;
 } & M;
-declare type Ancestor<F, N extends Natural, E extends Entry> = (new () => E) & {
-    [f in keyof F]?: Meta<Native<F[f]>, E>;
+declare type Model<A extends AttributesDefinition> = {
+    [a in keyof A]?: Native<A[a]>;
 } & {
-    load: (boh: boolean) => Promise<E[]>;
-} & Meta<N, E>;
-export interface SchemaOptions {
-    log?: (message: string) => void;
+    [a in Keys<A> & string as `${a}Load`]?: ForeignKey<A[a]>;
+};
+declare type Ancestor<A, N extends Natural, T extends Entry> = (new () => T) & {
+    [a in keyof A]?: Meta<Native<A[a]>, T>;
+} & {
+    load: (boh: boolean) => Promise<T[]>;
+} & Meta<N, T>;
+export interface SedentaryOptions {
+    log?: ((message: string) => void) | null;
+    serverless?: boolean;
     sync?: boolean;
 }
 export declare class Sedentary {
     protected db: DB;
-    protected log: (message: string) => void;
-    private sync;
+    protected log: (...data: unknown[]) => void;
+    protected sync: boolean;
     private models;
-    constructor(filename: string, options?: SchemaOptions);
-    DATETIME(): Type<Date, Entry>;
-    FKEY<N extends Natural, E extends Entry>(field: Type<N, E>): Type<N, E>;
-    INT(size?: number): Type<number, Entry>;
-    INT8(): Type<string, Entry>;
-    VARCHAR(size?: number): Type<string, Entry>;
+    constructor(filename: string, options?: SedentaryOptions);
+    DATETIME(): Type<Date, unknown>;
+    FKEY<N extends Natural, E extends Entry>(attribute: Type<N, E>): Type<N, E>;
+    INT(size?: number): Type<number, unknown>;
+    INT8(): Type<string, unknown>;
+    VARCHAR(size?: number): Type<string, unknown>;
     connect(): Promise<void>;
     end(): Promise<void>;
-    model<F extends FieldsDefinition, M extends Methods<T>, T extends Entry & {
+    model<A extends AttributesDefinition, M extends Methods<T>, T extends Entry & {
+        id?: string;
+    } & ModelWithMetods<A, M>>(modelName: string, attributes: A, options?: BaseModelOptions<T> & {
+        int8id: true;
+        methods: M;
+    }): Ancestor<A, string, T>;
+    model<A extends AttributesDefinition, K extends keyof A, M extends Methods<T>, N extends K extends keyof A ? Native<A[K]> : never, T extends Entry & ModelWithMetods<A, M>>(modelName: string, attributes: A, options?: BaseModelOptions<T> & {
+        methods: M;
+        primaryKey: K;
+    }): Ancestor<A, N, T>;
+    model<A extends AttributesDefinition, M extends Methods<T>, P extends Meta<Natural, Entry>, N extends P extends Meta<infer N, Entry> ? N : never, T extends Parent<P> & ModelWithMetods<A, M>>(modelName: string, attributes: A, options?: BaseModelOptions<T> & {
+        methods: M;
+        parent: P;
+    }): Ancestor<A, N, T>;
+    model<A extends AttributesDefinition, M extends Methods<T>, T extends Entry & {
+        id?: number;
+    } & ModelWithMetods<A, M>>(modelName: string, attributes: A, options?: BaseModelOptions<T> & {
+        methods: M;
+    }): Ancestor<A, number, T>;
+    model<A extends AttributesDefinition, T extends Entry & {
         id?: string;
-    } & Model<F, M>>(name: string, fields: F, options?: Options<M, T> & {
+    } & Model<A>>(modelName: string, attributes: A, options?: BaseModelOptions<T> & {
         int8id: true;
-    }): Ancestor<F, string, T>;
-    model<F extends FieldsDefinition, K extends keyof F, M extends Methods<T>, N extends K extends keyof F ? Native<F[K]> : never, T extends Entry & Model<F, M>>(name: string, fields: F, options?: Options<M, T> & {
+    }): Ancestor<A, string, T>;
+    model<A extends AttributesDefinition, K extends keyof A, N extends K extends keyof A ? Native<A[K]> : never, T extends Entry & Model<A>>(modelName: string, attributes: A, options?: BaseModelOptions<T> & {
         primaryKey: K;
-    }): Ancestor<F, N, T>;
-    model<F extends FieldsDefinition, M extends Methods<T>, P extends Meta<Natural, Entry>, N extends P extends Meta<infer N, Entry> ? N : never, T extends Parent<P> & Model<F, M>>(name: string, fields: F, options?: Options<M, T> & {
+    }): Ancestor<A, N, T>;
+    model<A extends AttributesDefinition, P extends Meta<Natural, Entry>, N extends P extends Meta<infer N, Entry> ? N : never, T extends Parent<P> & Model<A>>(modelName: string, attributes: A, options?: BaseModelOptions<T> & {
         parent: P;
-    }): Ancestor<F, N, T>;
-    model<F extends FieldsDefinition, M extends Methods<T>, T extends Entry & {
+    }): Ancestor<A, N, T>;
+    model<A extends AttributesDefinition, T extends Entry & {
         id?: number;
-    } & Model<F, M>>(name: string, fields: F, options?: Options<M, T>): Ancestor<F, number, T>;
+    } & Model<A>>(modelName: string, attributes: A, options?: BaseModelOptions<T>): Ancestor<A, number, T>;
     checkSize(size: number, message: string): number;
 }
 export declare const Package: typeof Sedentary;
-export {};

package/index.js

@@ -1,33 +1,45 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Package = exports.Sedentary = void 0;
+exports.Package = exports.Sedentary = exports.Type = exports.Entry = void 0;
 const db_1 = require("./lib/db");
+const log_1 = require("./lib/log");
 const minidb_1 = require("./lib/minidb");
+var db_2 = require("./lib/db");
+Object.defineProperty(exports, "Entry", { enumerable: true, get: function () { return db_2.Entry; } });
+Object.defineProperty(exports, "Type", { enumerable: true, get: function () { return db_2.Type; } });
 const allowedOption = ["indexes", "init", "int8id", "methods", "parent", "primaryKey", "sync", "tableName", "type"];
+const reservedNames = [
+    ...["attributeName", "base", "class", "constructor", "defaultValue", "entry", "fieldName", "init", "isModel"],
+    ...["load", "meta", "methods", "name", "primaryKey", "prototype", "save", "size", "tableName", "type"]
+];
 class Sedentary {
     constructor(filename, options) {
         this.sync = true;
         this.models = {};
         if (typeof filename !== "string")
-            throw new Error("Sedentary.constructor: 'filename' argument: Wrong type, expected 'string'");
+            throw new Error("new Sedentary: 'filename' argument: Wrong type, expected 'string'");
         if (!options)
             options = {};
         if (!(options instanceof Object))
-            throw new Error("Sedentary.constructor: 'options' argument: Wrong type, expected 'Object'");
-        for (const k in options) {
-            if (["log", "sync"].indexOf(k) === -1)
-                throw new Error(`Sedentary.constructor: 'options' argument: Unknown '${k}' option`);
-            this[k] = options[k];
-        }
-        // eslint-disable-next-line no-console
-        this.log || (this.log = console.log);
+            throw new Error("new Sedentary: 'options' argument: Wrong type, expected 'Object'");
+        for (const k in options)
+            if (!["log", "sync"].includes(k))
+                throw new Error(`new Sedentary: 'options' argument: Unknown '${k}' option`);
+        const { log, sync } = Object.assign({ sync: true }, options);
+        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.log = (0, log_1.createLogger)(log);
         this.db = new minidb_1.MiniDB(filename, this.log);
+        this.sync = sync;
     }
     DATETIME() {
         return new db_1.Type({ base: Date, type: "DATETIME" });
     }
-    FKEY(field) {
-        return new db_1.Type({ base: field.base, size: 0, type: "" });
+    FKEY(attribute) {
+        const { attributeName, base, fieldName, size, tableName, type } = attribute;
+        return new db_1.Type({ base, foreignKey: { attributeName, fieldName, tableName }, size, type });
     }
     INT(size) {
         const message = "Sedentary.INT: 'size' argument: Wrong value, expected 2 or 4";
@@ -49,11 +61,11 @@ class Sedentary {
             this.log("Connecting...");
             await this.db.connect();
             this.log("Connected, syncing...");
-            await this.db.sync();
+            await this.db.syncDataBase();
             this.log("Synced");
         }
         catch (e) {
-            this.log("Connecting: " + e.message);
+            this.log("Connecting:", e.message);
             throw e;
         }
     }
@@ -62,166 +74,173 @@ class Sedentary {
         await this.db.end();
         this.log("Connection closed");
     }
-    model(name, fields, options) {
-        if (typeof name !== "string")
+    model(modelName, attributes, options) {
+        if (typeof modelName !== "string")
             throw new Error("Sedentary.model: 'name' argument: Wrong type, expected 'string'");
-        if (this.models[name])
-            throw new Error(`Sedentary.model: '${name}' model: Model already defined`);
-        if (!fields)
-            fields = {};
-        if (!(fields instanceof Object))
-            throw new Error(`Sedentary.model: '${name}' model: 'fields' argument: Wrong type, expected 'Object'`);
+        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: '${name}' model: 'options' argument: Wrong type, expected 'Object'`);
+            throw new Error(`Sedentary.model: '${modelName}' model: 'options' argument: Wrong type, expected 'Object'`);
         for (const k in options)
-            if (allowedOption.indexOf(k) === -1)
-                throw new Error(`Sedentary.model: '${name}' model: 'options' argument: Unknown '${k}' option`);
+            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: '${name}' model: 'int8id' and 'parent' options conflict each other`);
+            throw new Error(`Sedentary.model: '${modelName}' model: 'int8id' and 'parent' options conflict each other`);
         if (options.int8id && options.primaryKey)
-            throw new Error(`Sedentary.model: '${name}' model: 'int8id' and 'primaryKey' options conflict each other`);
+            throw new Error(`Sedentary.model: '${modelName}' model: 'int8id' and 'primaryKey' options conflict each other`);
         if (options.parent && options.primaryKey)
-            throw new Error(`Sedentary.model: '${name}' model: 'parent' and 'primaryKey' options conflict each other`);
-        const constraints = [];
-        const { indexes, int8id, parent, primaryKey, sync, tableName } = Object.assign({ sync: this.sync, tableName: name + "s" }, options);
+            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.sync, tableName: modelName }, options);
         let { methods } = 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 }))];
+        let constraints = [{ attribute: aarray[0], constraintName: `${tableName}_id_unique`, type: "u" }];
         const iarray = [];
-        const pkName = primaryKey || "id";
-        let farray = int8id
-            ? [new db_1.Field({ fieldName: "id", notNull: true, size: 8, type: "INT8", unique: true })]
-            : [new db_1.Field({ fieldName: "id", notNull: true, size: 4, type: "INT", unique: true })];
+        const pk = aarray[0];
         if (methods && !(methods instanceof Object))
-            throw new Error(`Sedentary.model: '${name}' model: 'methods' option: Wrong type, expected 'Object'`);
+            throw new Error(`Sedentary.model: '${modelName}' model: 'methods' option: Wrong type, expected 'Object'`);
         if (parent) {
-            methods = (methods ? Object.assign(Object.assign({}, (parent.methods || {})), methods) : parent.methods);
             try {
                 if (!parent.isModel())
                     throw new Error();
             }
             catch (e) {
-                throw new Error(`Sedentary.model: '${name}' model: 'parent' option: Wrong type, expected 'Model'`);
+                throw new Error(`Sedentary.model: '${modelName}' model: 'parent' option: Wrong type, expected 'Model'`);
             }
+            methods = (methods ? Object.assign(Object.assign({}, (parent.methods || {})), methods) : parent.methods);
         }
         if (primaryKey && typeof primaryKey !== "string")
-            throw new Error(`Sedentary.model: '${name}' model: 'primaryKey' option: Wrong type, expected 'string'`);
-        if (primaryKey && Object.keys(fields).indexOf(primaryKey) === -1)
-            throw new Error(`Sedentary.model: '${name}' model: 'primaryKey' option: Field '${primaryKey}' does not exists`);
-        if (parent || primaryKey)
-            farray = [];
-        if (!parent)
-            iarray.push({ fields: [pkName], name: `${tableName}_${pkName}_unique`, type: "btree", unique: true });
-        for (const fname in fields) {
-            if (["base", "constructor", "load", "meta", "name", "prototype", "save", "size", "type"].indexOf(fname) !== -1)
-                throw new Error(`Sedentary.model: '${name}' model: '${fname}' field: Reserved name`);
-            const field = fields[fname];
-            // eslint-disable-next-line prefer-const
-            let { defaultValue, fieldName, notNull, size, type, unique } = (() => {
+            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) {
+            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 db_1.Attribute(Object.assign({ attributeName, defaultValue, fieldName, modelName, notNull, tableName, unique }, func()));
+            };
+            const attributeDefinition = attributes[attributeName];
+            let { base, defaultValue, fieldName, foreignKey, notNull, size, type, unique } = (() => {
                 const ret = (() => {
-                    // eslint-disable-next-line prefer-const
-                    let { defaultValue, fieldName, notNull, unique, type } = { defaultValue: undefined, fieldName: fname, notNull: false, unique: false, type: null };
-                    const call = (defaultValue, fieldName, notNull, unique, func, message) => {
-                        if (func !== this.DATETIME && func !== this.FKEY && func !== this.INT && func !== this.INT8 && func !== this.VARCHAR)
-                            throw new Error(message);
-                        return new db_1.Field(Object.assign({ defaultValue, fieldName, notNull, unique }, func()));
-                    };
-                    if (field instanceof db_1.Type)
-                        return new db_1.Field(Object.assign({ fieldName: fname }, Object.assign({ notNull: false }, field)));
-                    if (field instanceof Function)
-                        return call(undefined, fname, false, false, field, `Sedentary.model: '${name}' model: '${fname}' field: Wrong type, expected 'Field'`);
-                    if (!(field instanceof Object))
-                        throw new Error(`Sedentary.model: '${name}' model: '${fname}' field: Wrong field type, expected 'Field'`);
-                    ({ defaultValue, fieldName, notNull, unique, type } = Object.assign({ notNull: false }, field));
-                    if (!fieldName)
-                        fieldName = fname;
+                    if (attributeDefinition instanceof db_1.Type)
+                        return new db_1.Attribute(Object.assign({ 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 { defaultValue, fieldName, notNull, unique, type } = attributeDefaults;
                     if (defaultValue === null)
-                        throw new Error(`Sedentary.model: '${name}' model: '${fname}' field: 'defaultValue' option: Does 'null' default value really makes sense?`);
+                        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: '${name}' model: '${fname}' field: 'fieldName' option: Wrong type, expected 'string'`);
-                    if (!type)
-                        throw new Error(`Sedentary.model: '${name}' model: '${fname}' field: Missing 'type' option`);
+                        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.Field(Object.assign(Object.assign(Object.assign({}, Object.assign({ notNull: false }, field)), { fieldName }), type));
+                        return new db_1.Attribute(Object.assign({ attributeName, defaultValue, fieldName, modelName, notNull, tableName, unique }, type));
                     if (type instanceof Function)
-                        return call(defaultValue, fieldName, notNull, unique, type, `Sedentary.model: '${name}' model: '${fname}' field: 'type' option: Wrong type, expected 'Type'`);
-                    throw new Error(`Sedentary.model: '${name}' model: '${fname}' field: 'type' option: Wrong type, expected 'Type'`);
+                        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: '${name}' model: '${fname}' field: 'defaultValue' option: Wrong type, expected '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: '${name}' model: '${fname}' field: 'defaultValue' option: Wrong type, expected '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: '${name}' model: '${fname}' field: 'defaultValue' option: Wrong type, expected 'string'`);
+                        throw new Error(`Sedentary.model: '${modelName}' model: '${attributeName}' attribute: 'defaultValue' option: Wrong type, expected 'string'`);
                 }
                 return ret;
             })();
-            if (primaryKey === fname) {
+            if (primaryKey === attributeName) {
                 notNull = true;
                 unique = true;
             }
             if (defaultValue)
                 notNull = true;
-            farray.push(new db_1.Field({ defaultValue, fieldName, notNull, size, type, unique }));
-            if (unique && fname !== pkName)
-                iarray.push({ fields: [fieldName], name: `${tableName}_${fieldName}_unique`, type: "btree", unique: true });
+            const attribute = new db_1.Attribute({ attributeName, base, defaultValue, fieldName, foreignKey, modelName, notNull, size, tableName, type, unique });
+            aarray.push(attribute);
+            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 = fields;
+            const flds = attributes;
             if (!(indexes instanceof Object))
-                throw new Error(`Sedentary.model: '${name}' model: 'indexes' option: Wrong type, expected 'Object'`);
-            for (const iname in indexes) {
-                if (iarray.filter(_ => _.name === iname).length !== 0)
-                    throw new Error(`Sedentary.model: '${name}' model: '${iname}' index: index name already inferred by the unique constraint on a field`);
-                const idx = indexes[iname];
-                const checkField = (field, l) => {
-                    if (typeof field !== "string")
-                        throw new Error(`Sedentary.model: '${name}' model: '${iname}' index: #${l + 1} field: Wrong type, expected 'string'`);
-                    if (!(field in flds))
-                        throw new Error(`Sedentary.model: '${name}' model: '${iname}' index: #${l + 1} field: Unknown field '${field}'`);
+                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 fields;
+                let attributes;
                 let type = "btree";
                 let unique = false;
                 if (idx instanceof Array) {
-                    idx.forEach(checkField);
-                    fields = idx;
+                    idx.forEach(checkAttribute);
+                    attributes = idx;
                 }
                 else if (typeof idx === "string") {
-                    checkField(idx, 0);
-                    fields = [idx];
+                    checkAttribute(idx, 0);
+                    attributes = [idx];
                 }
                 else if (idx instanceof Object) {
                     for (const k in idx)
-                        if (["fields", "type", "unique"].indexOf(k) === -1)
-                            throw new Error(`Sedentary.model: '${name}' model: '${iname}' index: Unknown index option '${k}'`);
-                    ({ fields, type, unique } = Object.assign({ type: "btree", unique: false }, idx));
-                    if (!fields)
-                        throw new Error(`Sedentary.model: '${name}' model: '${iname}' index: Missing 'fields' option`);
-                    if (fields instanceof Array)
-                        fields.forEach(checkField);
-                    else if (typeof fields === "string") {
-                        checkField(fields, 0);
-                        fields = [fields];
+                        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));
+                    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: '${name}' model: '${iname}' index: 'fields' option: Wrong type, expected 'FieldNames'`);
+                        throw new Error(`Sedentary.model: '${modelName}' model: '${indexName}' index: 'attributes' option: Wrong type, expected 'FieldNames'`);
                     if (typeof type !== "string")
-                        throw new Error(`Sedentary.model: '${name}' model: '${iname}' index: 'type' option: Wrong type, expected 'string'`);
-                    if (["btree", "hash"].indexOf(type) === -1)
-                        throw new Error(`Sedentary.model: '${name}' model: '${iname}' index: 'type' option: Wrong value, expected 'btree' or 'hash'`);
+                        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: '${name}' model: '${iname}' index: 'unique' option: Wrong type, expected 'boolean'`);
+                        throw new Error(`Sedentary.model: '${modelName}' model: '${indexName}' index: 'unique' option: Wrong type, expected 'boolean'`);
                 }
                 else
-                    throw new Error(`Sedentary.model: '${name}' model: '${iname}' index: Wrong type, expected 'Object'`);
-                iarray.push({ fields, name: iname, type, unique });
+                    throw new Error(`Sedentary.model: '${modelName}' model: '${indexName}' index: Wrong type, expected 'Object'`);
+                iarray.push({ fields: attributes, indexName, type, unique });
             }
         }
-        this.db.addTable(new db_1.Table({ constraints, fields: farray, indexes: iarray, parent, primaryKey, sync, tableName }));
-        this.models[name] = true;
+        this.db.tables.push(new db_1.Table({ autoIncrement, constraints, attributes: aarray, indexes: iarray, parent, sync, tableName }));
+        this.models[modelName] = true;
         const init = parent
             ? options.init
                 ? function () {
@@ -231,7 +250,7 @@ class Sedentary {
                 : parent.init
             : options.init;
         const flds = {};
-        for (const key in fields)
+        for (const key in attributes)
             flds[key] = null;
         class Class {
             constructor() {
@@ -241,7 +260,7 @@ class Sedentary {
             save() {
                 return new Promise((resolve, reject) => {
                     const save = () => reject(new Error("eh no"));
-                    Object.defineProperty(save, "name", { value: name + ".save" });
+                    Object.defineProperty(save, "name", { value: modelName + ".save" });
                     setTimeout(save, 10);
                 });
             }
@@ -251,15 +270,19 @@ class Sedentary {
                 return resolve([new Class()]);
             reject(new Error("boh"));
         }, 10));
-        Object.defineProperty(load, "name", { value: name + "s.load" });
-        const meta = { tableName, primaryKey, init, methods };
-        Object.defineProperty(Class, "name", { value: name });
+        Object.defineProperty(load, "name", { value: modelName + ".load" });
+        const meta = { base: Number, type: "meta", tableName, primaryKey, init, methods };
+        Object.defineProperty(Class, "isModel", { value: () => true });
         Object.defineProperty(Class, "load", { value: load });
         Object.defineProperty(Class, "meta", { value: new db_1.Meta(meta) });
-        Object.defineProperty(Class.prototype.save, "name", { value: name + ".save" });
+        Object.defineProperty(Class, "name", { value: modelName });
+        Object.defineProperty(Class.prototype.save, "name", { value: modelName + ".save" });
         Object.assign(Class, new db_1.Meta(meta));
-        Object.assign(Class, Object.assign(Object.assign({}, fields), { isModel: () => true }));
         Object.assign(Class.prototype, methods);
+        for (const attribute of aarray)
+            Object.defineProperty(Class, attribute.attributeName, { value: attribute });
+        for (const key of ["attributeName", "base", "fieldName", "modelName", "size", "type", "unique"])
+            Object.defineProperty(Class, key, { value: pk[key] });
         return Class;
     }
     checkSize(size, message) {
@@ -273,12 +296,11 @@ class Sedentary {
 exports.Sedentary = Sedentary;
 exports.Package = Sedentary;
 const db = new Sedentary("gino");
-const Users = db.model("User", { foo: db.INT(), bar: db.VARCHAR() }, {});
-const fields = {
+const Users = db.model("User", { foo: db.INT(), bar: { type: db.VARCHAR(), unique: true } }, {});
+class Item extends db.model("Item", {
     num: db.FKEY(Users),
     str: db.VARCHAR()
-};
-class Item extends db.model("Item", fields, {
+}, {
     init: function () {
         this.num = 0;
         this.str = "0";
@@ -301,6 +323,7 @@ class Super extends db.model("Super", {
         this.num = 0;
         const a = this.nLoad ? await this.nLoad() : { prova: () => null };
         a.prova();
+        this.prova();
     }
 }) {
 }
@@ -311,7 +334,7 @@ class Next extends db.model("Next", { a: db.INT, b: db.INT }, {
     primaryKey: "a"
 }) {
 }
-class Current extends db.model("Current", { b: db.FKEY(Next) }, {
+class Current extends db.model("Current", { b: { type: db.FKEY(Next), unique: true } }, {
     init: function () {
         this.b = 24;
     }