sedentary 0.0.11 → 0.0.15

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2017-2020 Daniele Ricci
+Copyright (c) 2017 Daniele Ricci
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -1,21 +1,24 @@
 # sedentary
 
-[![NPM version][npm-badge]][npm-url]
-[![Types][types-badge]][npm-url]
-[![NPM downloads][npm-downloads-badge]][npm-url]
-
 [![Build Status][travis-badge]][travis-url]
 [![Code Climate][code-badge]][code-url]
 [![Test Coverage][cover-badge]][code-url]
 
-[![Dependents][deps-badge]][npm-url]
+[![NPM version][npm-badge]][npm-url]
+[![NPM downloads][npm-downloads-badge]][npm-url]
 [![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]
 
 [code-badge]: https://codeclimate.com/github/iccicci/sedentary/badges/gpa.svg
 [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
@@ -24,7 +27,7 @@
 [npm-url]: https://www.npmjs.com/package/sedentary
 [stars-badge]: https://badgen.net/github/stars/iccicci/sedentary?icon=github&cache=300
 [travis-badge]: https://badgen.net/travis/iccicci/sedentary?icon=travis&cache=300
-[travis-url]: https://travis-ci.com/iccicci/sedentary
+[travis-url]: https://app.travis-ci.com/github/iccicci/sedentary
 [types-badge]: https://badgen.net/npm/types/sedentary?color=green&icon=typescript&cache=300
 
 # under development
@@ -95,10 +98,10 @@ The full documentation is on [sedentary.readthedocs.io](https://sedentary.readth
 
 Requires:
 
-- Node.js: **v10**
+- Node.js: **v12**
 - TypeScript: **v4.1** (or none if used in a JavaScript project).
 
-The package is tested under [all Node.js versions](https://travis-ci.org/iccicci/sedentary)
+The package is tested under [all Node.js versions](https://app.travis-ci.com/github/iccicci/sedentary)
 currently supported accordingly to [Node.js Release](https://github.com/nodejs/Release#readme).
 
 To work with the package under Windows, be sure to configure `bash.exe` as your _script-shell_.

package/index.d.ts

@@ -1,76 +1,117 @@
-import { DB, Meta, Record, Type } from "./lib/db";
-declare type TypeDefinition<N extends unknown, R extends unknown> = (() => Type<N, R>) | Type<N, R>;
-interface FieldOptions<N extends unknown, R extends unknown> {
+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, R>;
+    type: TypeDefinition<N, E>;
     unique?: boolean;
 }
-declare type FieldDefinition<N extends unknown, R extends unknown> = TypeDefinition<N, R> | FieldOptions<N, R>;
-declare type FieldsDefinition = {
-    [key: string]: FieldDefinition<unknown, unknown>;
+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<unknown, infer R> ? (R extends Record ? k : never) : never;
-declare type ForeignKey<T> = T extends FieldDefinition<unknown, infer R> ? () => Promise<R> : 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, unknown> ? N : never;
-declare type Native_<T> = T extends () => Type<infer N, infer R> ? Native__<Type<N, R>> : Native__<T>;
-declare type Native<T> = T extends FieldOptions<infer N, infer R> ? Native__<Type<N, R>> : Native_<T>;
-declare type Parent<T> = T extends Meta<unknown, infer R> ? R : never;
-declare type Options<M, T> = {
+declare type Native_<T> = T extends () => Type<infer N, infer E> ? Native__<Type<N, E>> : Native__<T>;
+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 unknown, T extends Record> = (new () => T) & {
-    [f in keyof F]?: Meta<Native<F[f]>, T>;
+declare type Model<A extends AttributesDefinition> = {
+    [a in keyof A]?: Native<A[a]>;
+} & {
+    [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 SchemaOptions {
-    log?: (message: string) => void;
+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);
+    constructor(filename: string, options?: SedentaryOptions);
     DATETIME(): Type<Date, unknown>;
-    FKEY<N extends unknown, R extends Record>(record: Type<N, R>): Type<N, R>;
+    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 Record & {
+    model<A extends AttributesDefinition, M extends Methods<T>, T extends Entry & {
+        id?: string;
+    } & ModelWithMetods<A, M>>(name: 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>>(name: 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>>(name: 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>>(name: 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>>(name: 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 Record & 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>>(name: string, attributes: A, options?: BaseModelOptions<T> & {
         primaryKey: K;
-    }): Ancestor<F, N, T>;
-    model<F extends FieldsDefinition, M extends Methods<T>, P extends Meta<unknown, Record>, N extends P extends Meta<infer N, Record> ? 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>>(name: string, attributes: A, options?: BaseModelOptions<T> & {
         parent: P;
-    }): Ancestor<F, N, T>;
-    model<F extends FieldsDefinition, M extends Methods<T>, T extends Record & {
+    }): 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>>(name: 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,32 +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(record) {
-        return new db_1.Type({ base: record.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";
@@ -48,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;
         }
     }
@@ -61,34 +74,40 @@ class Sedentary {
         await this.db.end();
         this.log("Connection closed");
     }
-    model(name, fields, options) {
+    model(name, attributes, options) {
         if (typeof name !== "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 (!attributes)
+            attributes = {};
+        if (!(attributes instanceof Object))
+            throw new Error(`Sedentary.model: '${name}' 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'`);
         for (const k in options)
-            if (["init", "int8id", "methods", "parent", "primaryKey", "sync", "tableName", "type"].indexOf(k) === -1)
+            if (!allowedOption.includes(k))
                 throw new Error(`Sedentary.model: '${name}' model: 'options' argument: Unknown '${k}' option`);
-        const constraints = [];
-        const { int8id, parent, primaryKey, sync, tableName } = Object.assign({ sync: this.sync, tableName: name + "s" }, options);
+        if (options.int8id && options.parent)
+            throw new Error(`Sedentary.model: '${name}' 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`);
+        if (options.parent && options.primaryKey)
+            throw new Error(`Sedentary.model: '${name}' model: 'parent' and 'primaryKey' options conflict each other`);
+        let autoIncrement = true;
+        const { indexes, int8id, parent, primaryKey, sync, tableName } = Object.assign({ sync: this.sync, tableName: name }, options);
         let { methods } = options;
-        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 })];
+        let aarray = int8id
+            ? [new db_1.Attribute(Object.assign(Object.assign({}, this.INT8()), { attributeName: "id", fieldName: "id", notNull: true, tableName, unique: true }))]
+            : [new db_1.Attribute(Object.assign(Object.assign({}, this.INT(4)), { attributeName: "id", fieldName: "id", notNull: true, tableName, unique: true }))];
+        let constraints = [{ attribute: aarray[0], constraintName: `${tableName}_id_unique`, type: "u" }];
+        const iarray = [];
+        const pk = aarray[0];
         if (methods && !(methods instanceof Object))
             throw new Error(`Sedentary.model: '${name}' model: 'methods' option: Wrong type, expected 'Object'`);
         if (parent) {
-            if (primaryKey)
-                throw new Error(`Sedentary.model: '${name}' model: Both 'parent' and 'primaryKey' options provided`);
             methods = (methods ? Object.assign(Object.assign({}, (parent.methods || {})), methods) : parent.methods);
             try {
                 if (!parent.isModel())
@@ -100,72 +119,127 @@ class Sedentary {
         }
         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)
-            constraints.push({ name: `${tableName}_${pkName}_unique`, type: "u", field: pkName });
-        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 } = (() => {
+        if (primaryKey && !Object.keys(attributes).includes(primaryKey))
+            throw new Error(`Sedentary.model: '${name}' model: 'primaryKey' option: Attribute '${primaryKey}' does not exists`);
+        if (parent || primaryKey) {
+            autoIncrement = false;
+            aarray = [];
+            constraints = [];
+        }
+        for (const attributeName in attributes) {
+            if (reservedNames.includes(attributeName))
+                throw new Error(`Sedentary.model: '${name}' 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, 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, unique, type } = { defaultValue: undefined, fieldName: fname, unique: false, type: null };
-                    const call = (defaultValue, fieldName, 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, unique }, func()));
-                    };
-                    if (field instanceof db_1.Type)
-                        return new db_1.Field(Object.assign({ fieldName: fname }, field));
-                    if (field instanceof Function)
-                        return call(undefined, fname, 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, unique, type } = field);
-                    if (!fieldName)
-                        fieldName = fname;
+                    if (attributeDefinition instanceof db_1.Type)
+                        return new db_1.Attribute(Object.assign({ attributeName, fieldName: attributeName, notNull: false, tableName }, attributeDefinition));
+                    if (attributeDefinition instanceof Function)
+                        return call(undefined, attributeName, false, false, attributeDefinition, `Sedentary.model: '${name}' model: '${attributeName}' attribute:`, "Wrong type, expected 'Attribute'");
+                    if (!(attributeDefinition instanceof Object))
+                        throw new Error(`Sedentary.model: '${name}' 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: '${name}' 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: '${name}' model: '${attributeName}' attribute: 'fieldName' option: Wrong type, expected 'string'`);
+                    if (typeof notNull !== "boolean")
+                        throw new Error(`Sedentary.model: '${name}' model: '${attributeName}' attribute: 'notNull' option: Wrong type, expected 'boolean'`);
+                    if (typeof unique !== "boolean")
+                        throw new Error(`Sedentary.model: '${name}' model: '${attributeName}' attribute: 'unique' option: Wrong type, expected 'boolean'`);
+                    if (type === undefined)
+                        throw new Error(`Sedentary.model: '${name}' model: '${attributeName}' attribute: Missing 'type' option`);
                     if (type instanceof db_1.Type)
-                        return new db_1.Field(Object.assign(Object.assign(Object.assign({}, field), { fieldName }), type));
+                        return new db_1.Attribute(Object.assign({ attributeName, defaultValue, fieldName, notNull, tableName, unique }, type));
                     if (type instanceof Function)
-                        return call(defaultValue, fieldName, 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: '${name}' model: '${attributeName}' attribute: 'type' option:`, "Wrong type, expected 'Type'");
+                    throw new Error(`Sedentary.model: '${name}' 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: '${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: '${name}' 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: '${name}' 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) {
-                constraints.push({
-                    name: `${tableName}_${fieldName}_unique`,
-                    type: "u",
-                    field: fieldName
-                });
+            const attribute = new db_1.Attribute({ attributeName, base, defaultValue, fieldName, foreignKey, 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 = attributes;
+            if (!(indexes instanceof Object))
+                throw new Error(`Sedentary.model: '${name}' 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: '${name}' 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: '${name}' model: '${indexName}' index: #${l + 1} attribute: Wrong type, expected 'string'`);
+                    if (!(attribute in flds))
+                        throw new Error(`Sedentary.model: '${name}' 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: '${name}' model: '${indexName}' index: Unknown index option '${k}'`);
+                    ({ attributes, type, unique } = Object.assign({ type: "btree", unique: false }, idx));
+                    if (!attributes)
+                        throw new Error(`Sedentary.model: '${name}' 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: '${indexName}' index: 'attributes' option: Wrong type, expected 'FieldNames'`);
+                    if (typeof type !== "string")
+                        throw new Error(`Sedentary.model: '${name}' model: '${indexName}' index: 'type' option: Wrong type, expected 'string'`);
+                    if (!["btree", "hash"].includes(type))
+                        throw new Error(`Sedentary.model: '${name}' model: '${indexName}' index: 'type' option: Wrong value, expected 'btree' or 'hash'`);
+                    if (typeof unique !== "boolean")
+                        throw new Error(`Sedentary.model: '${name}' model: '${indexName}' index: 'unique' option: Wrong type, expected 'boolean'`);
+                }
+                else
+                    throw new Error(`Sedentary.model: '${name}' model: '${indexName}' index: Wrong type, expected 'Object'`);
+                iarray.push({ fields: attributes, indexName, type, unique });
             }
         }
-        this.db.addTable(new db_1.Table({ constraints, fields: farray, parent, primaryKey, sync, tableName }));
+        this.db.tables.push(new db_1.Table({ autoIncrement, constraints, attributes: aarray, indexes: iarray, parent, sync, tableName }));
         this.models[name] = true;
         const init = parent
             ? options.init
@@ -176,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() {
@@ -196,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: name + ".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, "name", { value: name });
         Object.defineProperty(Class.prototype.save, "name", { value: name + ".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", "size", "type", "unique"])
+            Object.defineProperty(Class, key, { value: pk[key] });
         return Class;
     }
     checkSize(size, message) {
@@ -218,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";
@@ -256,7 +333,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;
     }