sedentary 0.0.14 → 0.0.18

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,5 +1,5 @@
-import { DB, Entry, Meta, Natural, Type } from "./lib/db";
-export { Entry, Natural, Type } from "./lib/db";
+import { DB, Entry, ForeignKeyOptions, Meta, Natural, Type } from "./lib/db";
+export { Entry, ForeignKeyActions, ForeignKeyOptions, 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;
@@ -30,10 +30,11 @@ export interface IndexOptions {
     unique?: boolean;
 }
 export declare type IndexDefinition = IndexAttributes | IndexOptions;
-export declare type BaseModelOptions<T> = {
-    indexes?: {
-        [key: string]: IndexDefinition;
-    };
+export declare type IndexesDefinition = {
+    [key: string]: IndexDefinition;
+};
+declare type BaseModelOptions<T> = {
+    indexes?: IndexesDefinition;
     init?: (this: T) => void;
     sync?: boolean;
     tableName?: string;
@@ -60,18 +61,19 @@ declare type Ancestor<A, N extends Natural, T extends Entry> = (new () => T) & {
 } & {
     load: (boh: boolean) => Promise<T[]>;
 } & Meta<N, T>;
-export interface SchemaOptions {
+export interface SedentaryOptions {
     log?: ((message: string) => void) | null;
+    serverless?: boolean;
     sync?: boolean;
 }
 export declare class Sedentary {
     protected db: DB;
     protected log: (...data: unknown[]) => void;
-    private sync;
+    protected sync: boolean;
     private models;
-    constructor(filename: string, options?: SchemaOptions);
+    constructor(filename: string, options?: SedentaryOptions);
     DATETIME(): Type<Date, unknown>;
-    FKEY<N extends Natural, E extends Entry>(attribute: Type<N, E>): Type<N, E>;
+    FKEY<N extends Natural, E extends Entry>(attribute: Type<N, E>, options?: ForeignKeyOptions): Type<N, E>;
     INT(size?: number): Type<number, unknown>;
     INT8(): Type<string, unknown>;
     VARCHAR(size?: number): Type<string, unknown>;
@@ -79,37 +81,37 @@ export declare class Sedentary {
     end(): Promise<void>;
     model<A extends AttributesDefinition, M extends Methods<T>, T extends Entry & {
         id?: string;
-    } & ModelWithMetods<A, M>>(name: string, attributes: A, options?: BaseModelOptions<T> & {
+    } & 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>>(name: string, attributes: A, options?: BaseModelOptions<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>>(name: string, attributes: A, options?: BaseModelOptions<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>>(name: string, attributes: A, options?: BaseModelOptions<T> & {
+    } & 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<A>>(name: string, attributes: A, options?: BaseModelOptions<T> & {
+    } & Model<A>>(modelName: string, attributes: A, options?: BaseModelOptions<T> & {
         int8id: true;
     }): 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> & {
+    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<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> & {
+    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<A, N, T>;
     model<A extends AttributesDefinition, T extends Entry & {
         id?: number;
-    } & Model<A>>(name: string, attributes: A, options?: BaseModelOptions<T>): Ancestor<A, 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;

package/index.js

@@ -25,19 +25,21 @@ class Sedentary {
         for (const k in options)
             if (!["log", "sync"].includes(k))
                 throw new Error(`new Sedentary: 'options' argument: Unknown '${k}' option`);
-        this.log = (0, log_1.createLogger)(options.log);
-        if ("sync" in options)
-            this.sync = options.sync;
+        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(attribute) {
-        const { attributeName, base, fieldName, size, tableName, type, unique } = attribute;
-        if (!unique)
-            throw new Error(`Sedentary.FKEY: '${tableName}' table: '${attributeName}' attribute: is not unique: can't be used as FKEY target`);
-        return new db_1.Type({ base, foreignKey: { attributeName, fieldName, tableName }, size, type });
+    FKEY(attribute, options) {
+        const { attributeName, base, fieldName, size, tableName, type } = attribute;
+        return new db_1.Type({ base, foreignKey: { attributeName, fieldName, options, tableName }, size, type });
     }
     INT(size) {
         const message = "Sedentary.INT: 'size' argument: Wrong value, expected 2 or 4";
@@ -59,7 +61,7 @@ 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) {
@@ -72,111 +74,131 @@ class Sedentary {
         await this.db.end();
         this.log("Connection closed");
     }
-    model(name, attributes, 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 (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: '${name}' model: 'attributes' argument: Wrong type, expected '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.includes(k))
-                throw new Error(`Sedentary.model: '${name}' model: 'options' argument: Unknown '${k}' option`);
+                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 { indexes, int8id, parent, primaryKey, sync, tableName } = Object.assign({ sync: this.sync, tableName: name }, 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", 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 }))];
+            ? [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 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'`);
+        const originalMethods = methods;
         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'`);
+            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: '${name}' model: 'primaryKey' option: Attribute '${primaryKey}' does not exists`);
+            throw new Error(`Sedentary.model: '${modelName}' model: 'primaryKey' option: Attribute '${primaryKey}' does not exists`);
         if (parent || primaryKey) {
+            autoIncrement = false;
             aarray = [];
             constraints = [];
         }
-        for (const attributeName in attributes) {
+        for (const attributeName of Object.keys(attributes).sort()) {
             if (reservedNames.includes(attributeName))
-                throw new Error(`Sedentary.model: '${name}' model: '${attributeName}' attribute: Reserved name`);
+                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, notNull, tableName, unique }, func()));
+                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 = (() => {
                     if (attributeDefinition instanceof db_1.Type)
-                        return new db_1.Attribute(Object.assign({ attributeName, fieldName: attributeName, notNull: false, tableName }, attributeDefinition));
+                        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: '${name}' model: '${attributeName}' attribute:`, "Wrong type, expected 'Attribute'");
+                        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: '${name}' model: '${attributeName}' attribute: Wrong attribute type, expected 'Attribute'`);
+                        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: '${attributeName}' attribute: '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: '${attributeName}' attribute: 'fieldName' option: Wrong type, expected '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: '${name}' model: '${attributeName}' attribute: 'notNull' option: Wrong type, expected '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: '${name}' model: '${attributeName}' attribute: 'unique' option: Wrong type, expected 'boolean'`);
+                        throw new Error(`Sedentary.model: '${modelName}' model: '${attributeName}' attribute: 'unique' option: Wrong type, expected 'boolean'`);
                     if (type === undefined)
-                        throw new Error(`Sedentary.model: '${name}' model: '${attributeName}' attribute: Missing 'type' option`);
+                        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, notNull, tableName, unique }, 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: '${attributeName}' attribute: 'type' option:`, "Wrong type, expected 'Type'");
-                    throw new Error(`Sedentary.model: '${name}' model: '${attributeName}' attribute: '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: '${attributeName}' attribute: '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: '${attributeName}' attribute: '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: '${attributeName}' attribute: 'defaultValue' option: Wrong type, expected 'string'`);
+                        throw new Error(`Sedentary.model: '${modelName}' model: '${attributeName}' attribute: 'defaultValue' option: Wrong type, expected 'string'`);
                 }
                 return ret;
             })();
+            if (foreignKey) {
+                if (!foreignKey.options)
+                    foreignKey.options = {};
+                if (!(foreignKey.options instanceof Object))
+                    throw new Error(`Sedentary.FKEY: '${modelName}' model: '${attributeName}' attribute: Wrong options type, expected 'Object'`);
+                for (const k in foreignKey.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 = foreignKey.options[onChange];
+                    if (!action)
+                        action = foreignKey.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(" | ")}`);
+                }
+            }
             if (primaryKey === attributeName) {
                 notNull = true;
                 unique = true;
             }
             if (defaultValue)
                 notNull = true;
-            const attribute = new db_1.Attribute({ attributeName, base, defaultValue, fieldName, foreignKey, notNull, size, tableName, type, unique });
+            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" });
@@ -186,16 +208,16 @@ class Sedentary {
         if (indexes) {
             const flds = attributes;
             if (!(indexes instanceof Object))
-                throw new Error(`Sedentary.model: '${name}' model: 'indexes' option: Wrong type, expected '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: '${name}' model: '${indexName}' index: index name already inferred by the unique constraint on an attribute`);
+                    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: '${name}' model: '${indexName}' index: #${l + 1} attribute: Wrong type, expected '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: '${name}' model: '${indexName}' index: #${l + 1} attribute: Unknown attribute '${attribute}'`);
+                        throw new Error(`Sedentary.model: '${modelName}' model: '${indexName}' index: #${l + 1} attribute: Unknown attribute '${attribute}'`);
                 };
                 let attributes;
                 let type = "btree";
@@ -211,10 +233,10 @@ class Sedentary {
                 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}'`);
+                            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: '${name}' model: '${indexName}' index: Missing 'attributes' option`);
+                        throw new Error(`Sedentary.model: '${modelName}' model: '${indexName}' index: Missing 'attributes' option`);
                     if (attributes instanceof Array)
                         attributes.forEach(checkAttribute);
                     else if (typeof attributes === "string") {
@@ -222,21 +244,21 @@ class Sedentary {
                         attributes = [attributes];
                     }
                     else
-                        throw new Error(`Sedentary.model: '${name}' model: '${indexName}' index: 'attributes' 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: '${indexName}' index: 'type' option: Wrong type, expected '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: '${name}' model: '${indexName}' index: 'type' option: Wrong value, expected 'btree' or 'hash'`);
+                        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: '${indexName}' 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: '${indexName}' index: Wrong type, expected 'Object'`);
+                    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, attributes: aarray, 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 () {
@@ -245,9 +267,6 @@ class Sedentary {
                 }
                 : parent.init
             : options.init;
-        const flds = {};
-        for (const key in attributes)
-            flds[key] = null;
         class Class {
             constructor() {
                 if (init)
@@ -256,7 +275,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);
                 });
             }
@@ -266,18 +285,70 @@ class Sedentary {
                 return resolve([new Class()]);
             reject(new Error("boh"));
         }, 10));
-        Object.defineProperty(load, "name", { value: name + ".load" });
-        const meta = { base: Number, type: "meta", tableName, primaryKey, init, methods };
+        Object.defineProperty(load, "name", { value: modelName + ".load" });
+        const metaAttributes = aarray.reduce((ret, curr) => {
+            ret[curr.attributeName] = curr;
+            return ret;
+        }, {});
+        const metaForeignKeys = aarray
+            .filter(_ => _.foreignKey)
+            .reduce((ret, curr) => {
+            ret[curr.attributeName] = curr;
+            return ret;
+        }, {});
+        const meta = new db_1.Meta({ base: Number, attributes: metaAttributes, foreignKeys: metaForeignKeys, modelName, parent: parent, type: "meta", tableName, primaryKey, init, methods });
+        for (const foreignKey in metaForeignKeys) {
+            if (foreignKey + "Load" in metaAttributes)
+                throw new Error(`Sedentary.model: '${modelName}' model: '${foreignKey}' attribute: '${foreignKey}Load' inferred methods conflicts with an attribute`);
+            if (originalMethods && foreignKey + "Load" in originalMethods)
+                throw new Error(`Sedentary.model: '${modelName}' model: '${foreignKey}' attribute: '${foreignKey}Load' inferred methods conflicts with a method`);
+        }
+        if (originalMethods)
+            for (const method in originalMethods)
+                if (method in metaAttributes)
+                    throw new Error(`Sedentary.model: '${modelName}' model: '${method}' method: conflicts with an attribute`);
+        const checkParent = (parent) => {
+            if (!parent)
+                return;
+            for (const attribute in metaAttributes) {
+                if (attribute in parent.attributes)
+                    throw new Error(`Sedentary.model: '${modelName}' model: '${attribute}' attribute: conflicts with an attribute of '${parent.modelName}' model`);
+                if (parent.methods && 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 metaForeignKeys) {
+                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 (parent.methods && 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`);
+            }
+            if (originalMethods) {
+                for (const method in originalMethods) {
+                    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`);
+                    if (parent.methods && method in parent.methods)
+                        throw new Error(`Sedentary.model: '${modelName}' model: '${method}' method: conflicts with a method of '${parent.modelName}' model`);
+                }
+            }
+            checkParent(parent.parent);
+        };
+        checkParent(parent);
         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.defineProperty(Class, "meta", { value: meta });
+        Object.defineProperty(Class, "name", { value: modelName });
+        Object.defineProperty(Class.prototype.save, "name", { value: modelName + ".save" });
+        Object.assign(Class, meta);
         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"])
+        for (const key of ["attributeName", "base", "fieldName", "modelName", "size", "type", "unique"])
             Object.defineProperty(Class, key, { value: pk[key] });
         return Class;
     }
@@ -319,6 +390,7 @@ class Super extends db.model("Super", {
         this.num = 0;
         const a = this.nLoad ? await this.nLoad() : { prova: () => null };
         a.prova();
+        this.prova();
     }
 }) {
 }
@@ -335,9 +407,9 @@ class Current extends db.model("Current", { b: { type: db.FKEY(Next), unique: tr
     }
 }) {
 }
-class Last extends db.model("Last", { b: db.FKEY(Current.b) }, {
+class Last extends db.model("Last", { c: db.FKEY(Current.b) }, {
     init: function () {
-        this.b = 24;
+        this.c = 24;
     },
     parent: Next
 }) {
@@ -353,3 +425,29 @@ class Last extends db.model("Last", { b: db.FKEY(Current.b) }, {
     }
     return true;
 })();
+/*
+export let factory = () => {
+    class Foo {
+        a = 3;
+        b = 'bar'
+        c?: boolean
+    }
+    return Foo as (new () => { [key in keyof Foo]: Foo[key] })
+};
+
+export const FooConstr = factory()
+export type TypeExtractor<T> = T extends (new() => infer E) ? E : never;
+export type FooType = TypeExtractor<typeof FooConstr>;
+
+const foo = new FooConstr()
+
+function rino(a:FooType){
+    if(a instanceof FooConstr){console.log("sisi")}
+    if(a instanceof FooType){console.log("sisi")}
+}
+
+rino(foo);
+
+
+B.prototype instanceof A
+*/

package/lib/db.d.ts

@@ -3,6 +3,11 @@ export declare class Entry {
     init(): void;
     save(): Promise<boolean>;
 }
+export declare type ForeignKeyActions = "cascade" | "no action" | "restrict" | "set default" | "set null";
+export interface ForeignKeyOptions {
+    onDelete?: ForeignKeyActions;
+    onUpdate?: ForeignKeyActions;
+}
 export declare class Type<N extends Natural, E> {
     base: unknown;
     entry?: E;
@@ -12,16 +17,25 @@ export declare class Type<N extends Natural, E> {
     foreignKey?: {
         attributeName: string;
         fieldName: string;
+        options?: ForeignKeyOptions;
         tableName: string;
     };
     constructor(from: Type<N, E>);
 }
 export declare class Meta<N extends Natural, E> extends Type<N, E> {
+    attributes: {
+        [key: string]: unknown;
+    };
+    foreignKeys: {
+        [key: string]: unknown;
+    };
     init: () => void;
     isModel?: () => boolean;
     methods: {
         [key: string]: () => unknown;
     };
+    modelName: string;
+    parent?: Meta<Natural, E>;
     primaryKey: string;
     tableName: string;
     constructor(from: Meta<N, E>);
@@ -30,6 +44,7 @@ export declare class Attribute<N extends Natural, E> extends Type<N, E> {
     attributeName: string;
     defaultValue?: unknown;
     fieldName: string;
+    modelName: string;
     notNull: boolean;
     tableName: string;
     unique?: boolean;
@@ -48,32 +63,30 @@ export interface Index {
 }
 interface ITable {
     attributes: Attribute<Natural, unknown>[];
+    autoIncrement: boolean;
     constraints: Constraint[];
     indexes: Index[];
-    oid?: number;
     parent: Meta<Natural, unknown>;
-    primaryKey: string;
     sync: boolean;
     tableName: string;
 }
 declare const Table_base: new (defaults?: ITable) => ITable;
 export declare class Table extends Table_base {
-    autoIncrement: boolean;
-    autoIncrementOwn: boolean;
-    constructor(defaults: ITable);
+    autoIncrementOwn?: boolean;
+    oid?: number;
+    findField(name: string): Attribute<Natural, unknown>;
 }
 export declare abstract class DB {
-    tables: {
-        [key: string]: Table;
-    };
-    tablesArr: Table[];
+    tables: Table[];
     protected log: (...data: unknown[]) => void;
+    protected sync: boolean;
     abstract connect(): Promise<void>;
     abstract end(): Promise<void>;
     constructor(log: (message: string) => void);
-    addTable(table: Table): void;
+    findTable(name: string): Table;
     protected indexesEq(a: Index, b: Index): boolean;
-    sync(): Promise<void>;
+    syncDataBase(): Promise<void>;
+    protected syncLog(...data: unknown[]): void;
     abstract dropConstraints(table: Table): Promise<number[]>;
     abstract dropFields(table: Table): Promise<void>;
     abstract dropIndexes(table: Table, constraintIndexes: number[]): Promise<void>;