sedentary 0.0.19 → 0.0.23

package/README.md

@@ -81,10 +81,9 @@ $ npm install --save sedentary
 
 # Disclaimer
 
-**Do not use this package itself in production! This package uses a simple self made JSON-DB engine just for testing
-purposes.**
+**Do not use this package itself! It does not support any DB engine.**
 
-For a real environment a _DB engine dedicated extension_ must be used:
+A _DB engine dedicated extension_ must be used:
 
 - MySQL: planned
 - PostgreSQL: [sedentary-pg](https://github.com/iccicci/sedentary-pg#readme)

package/{lib/db.d.ts → db.d.ts}

@@ -1,5 +1,11 @@
 export declare type Natural = Date | Record<string, unknown> | boolean | number | string;
 export declare class EntryBase {
+    constructor(from?: Partial<EntryBase> | "load");
+    construct(): void;
+    postLoad(): void;
+    postSave(): void;
+    preLoad(): void;
+    preSave(): void;
     save(): Promise<boolean>;
 }
 export declare type ForeignKeyActions = "cascade" | "no action" | "restrict" | "set default" | "set null";
@@ -7,7 +13,7 @@ export interface ForeignKeyOptions {
     onDelete?: ForeignKeyActions;
     onUpdate?: ForeignKeyActions;
 }
-export declare class Type<N extends Natural, E> {
+export interface Type<N extends Natural, E> {
     base: unknown;
     entry?: E;
     native?: N;
@@ -19,34 +25,20 @@ export declare class Type<N extends Natural, E> {
         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>);
+export declare class Type<N extends Natural, E> {
+    constructor(from: Type<N, E>);
 }
-export declare class Attribute<N extends Natural, E> extends Type<N, E> {
+export interface Attribute<N extends Natural, E> extends Type<N, E> {
     attributeName: string;
-    defaultValue?: unknown;
+    defaultValue?: Natural;
     fieldName: string;
     modelName: string;
     notNull: boolean;
     tableName: string;
     unique?: boolean;
+}
+export declare class Attribute<N extends Natural, E> extends Type<N, E> {
     constructor(from: Attribute<N, E>);
 }
 export interface Constraint {
@@ -65,11 +57,11 @@ interface ITable {
     autoIncrement: boolean;
     constraints: Constraint[];
     indexes: Index[];
-    parent: Meta<Natural, unknown>;
+    parent?: Attribute<Natural, unknown>;
     sync: boolean;
     tableName: string;
 }
-declare const Table_base: new (defaults?: ITable) => ITable;
+declare const Table_base: new (defaults?: ITable | undefined) => ITable;
 export declare class Table extends Table_base {
     autoIncrementOwn?: boolean;
     oid?: number;
@@ -77,7 +69,7 @@ export declare class Table extends Table_base {
 }
 export declare abstract class DB {
     tables: Table[];
-    protected log: (...data: unknown[]) => void;
+    protected log: (message: string) => void;
     protected sync: boolean;
     abstract connect(): Promise<void>;
     abstract end(): Promise<void>;
@@ -85,7 +77,9 @@ export declare abstract class DB {
     findTable(name: string): Table;
     protected indexesEq(a: Index, b: Index): boolean;
     syncDataBase(): Promise<void>;
-    protected syncLog(...data: unknown[]): void;
+    protected syncLog(message: string): void;
+    abstract escape(value: Natural): string;
+    abstract save(tableName: string, attributes: Attribute<Natural, unknown>[]): (this: Record<string, Natural>) => Promise<boolean>;
     abstract dropConstraints(table: Table): Promise<number[]>;
     abstract dropFields(table: Table): Promise<void>;
     abstract dropIndexes(table: Table, constraintIndexes: number[]): Promise<void>;
@@ -95,4 +89,6 @@ export declare abstract class DB {
     abstract syncSequence(table: Table): Promise<void>;
     abstract syncTable(table: Table): Promise<void>;
 }
+export declare class Transaction {
+}
 export {};

package/{lib/db.js → db.js}

@@ -1,8 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DB = exports.Table = exports.Attribute = exports.Meta = exports.Type = exports.EntryBase = void 0;
-/**/
+exports.Transaction = exports.DB = exports.Table = exports.Attribute = exports.Type = exports.EntryBase = void 0;
 class EntryBase {
+    constructor(from) {
+        if (from === "load")
+            this.preLoad();
+        else {
+            if (from)
+                Object.assign(this, from);
+            this.construct();
+        }
+    }
+    construct() { }
+    postLoad() { }
+    postSave() { }
+    preLoad() { }
+    preSave() { }
     async save() {
         return false;
     }
@@ -14,12 +27,6 @@ class Type {
     }
 }
 exports.Type = Type;
-class Meta extends Type {
-    constructor(from) {
-        super(from);
-    }
-}
-exports.Meta = Meta;
 class Attribute extends Type {
     constructor(from) {
         super(from);
@@ -42,6 +49,7 @@ exports.Table = Table;
 class DB {
     constructor(log) {
         this.tables = [];
+        this.sync = true;
         this.log = log;
     }
     findTable(name) {
@@ -72,9 +80,11 @@ class DB {
             await this.syncIndexes(table);
         }
     }
-    syncLog(...data) {
-        const args = this.sync ? data : ["NOT SYNCING:", ...data];
-        this.log(...args);
+    syncLog(message) {
+        this.log(this.sync ? message : "NOT SYNCING: " + message);
     }
 }
 exports.DB = DB;
+class Transaction {
+}
+exports.Transaction = Transaction;

package/index.d.ts

@@ -1,5 +1,5 @@
-import { DB, EntryBase, ForeignKeyOptions, Meta, Natural, Type } from "./lib/db";
-export { EntryBase, ForeignKeyActions, ForeignKeyOptions, Natural, Type } from "./lib/db";
+import { Attribute, DB, EntryBase, ForeignKeyOptions, Natural, Type } from "./db";
+export { EntryBase, ForeignKeyActions, ForeignKeyOptions, Natural, Type } from "./db";
 export declare type TypeDefinition<N extends Natural, E> = (() => Type<N, E>) | Type<N, E>;
 export interface AttributeOptions<N extends Natural, E> {
     defaultValue?: N;
@@ -16,13 +16,9 @@ declare type ForeignKeysAttributes<T, k> = T extends AttributeDefinition<Natural
 declare type ForeignKeys<A extends AttributesDefinition> = {
     [a in keyof A]?: ForeignKeysAttributes<A[a], a>;
 }[keyof A];
-declare type Methods<E> = {
-    [key: string]: (this: E) => unknown;
-};
 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 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;
@@ -33,93 +29,89 @@ export declare type IndexDefinition = IndexAttributes | IndexOptions;
 export declare type IndexesDefinition = {
     [key: string]: IndexDefinition;
 };
-declare type BaseModelOptions<B extends boolean, T> = {
+interface BaseModelOptions {
     indexes?: IndexesDefinition;
-    init?: (this: T) => void;
-    int8id?: B;
     sync?: boolean;
     tableName?: string;
-};
-export declare type ModelOptions<B extends boolean, K extends string, M extends Methods<T>, P extends Meta<Natural, EntryBase>, T extends EntryBase> = BaseModelOptions<B, T> & {
-    methods?: M;
-    parent?: P;
-    primaryKey?: K;
-};
-declare type ModelBaseOptions = {
-    indexes?: IndexesDefinition;
-    sync?: boolean;
-    tableName?: string;
-};
-export declare type ModelOptions2 = ModelBaseOptions & {
+}
+export interface ModelOptions extends BaseModelOptions {
     int8id?: boolean;
-    parent?: Type<Natural, EntryBase>;
+    parent?: Attribute<Natural, EntryBase>;
     primaryKey?: string;
+}
+declare type ConditionAttribute<N extends Natural> = N | [">" | "<" | ">=" | "<=" | "<>", N] | ["IN", ...N[]] | ["IS NULL"] | ["LIKE", string];
+declare type ConditionBase<A extends AttributesDefinition> = string | {
+    [a in keyof A]?: ConditionAttribute<Native<A[a]>>;
 };
+declare type Condition<A extends AttributesDefinition> = ConditionBase<A> | ["NOT", Condition<A>] | ["AND", ...Condition<A>[]] | ["OR", ...Condition<A>[]];
 declare type UnionToIntersection<U> = (U extends unknown ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
 declare type IsUnion<T> = [T] extends [UnionToIntersection<T>] ? false : true;
-declare type EntryIdNatural<B extends boolean> = IsUnion<B> extends true ? number : B extends true ? string : number;
-export declare type EntryId<B extends boolean> = {
-    id?: EntryIdNatural<B>;
-};
+declare type BaseKeyType<B extends boolean> = IsUnion<B> extends true ? number : B extends true ? string : number;
+declare type KeyType<B extends boolean, P extends ModelStd> = P extends new () => EntryBase ? (P extends Attribute<infer T, EntryBase> ? T : never) : BaseKeyType<B>;
 declare type ForeignKey<A> = A extends AttributeDefinition<Natural, infer E> ? () => Promise<E> : never;
-declare type ModelFKAttributes<A extends AttributesDefinition> = {
-    [a in ForeignKeys<A> & string as `${a}Load`]?: ForeignKey<A[a]>;
-};
-declare type ModelBaseAttributes<A extends AttributesDefinition> = {
+declare type EntryBaseAttributes<A extends AttributesDefinition> = {
     [a in keyof A]?: Native<A[a]>;
 };
-declare type ModelAttributes<A extends AttributesDefinition> = keyof ModelFKAttributes<A> extends never ? ModelBaseAttributes<A> : ModelBaseAttributes<A> & ModelFKAttributes<A>;
-declare type Ancestor<A, N extends Natural, T extends EntryBase> = (new () => T) & {
-    [a in keyof A]?: Meta<Native<A[a]>, T>;
+declare type EntryMethodsBase<P extends ModelStd> = P extends new () => EntryBase ? P["methods"] : EntryBase;
+declare type EntryMethodsFK<A extends AttributesDefinition> = {
+    [a in ForeignKeys<A> & string as `${a}Load`]: ForeignKey<A[a]>;
+};
+declare type EntryMethods<A extends AttributesDefinition, P extends ModelStd> = keyof EntryMethodsFK<A> extends never ? EntryMethodsBase<P> : EntryMethodsBase<P> & EntryMethodsFK<A>;
+declare type ModelAttributesIf<A extends AttributesDefinition, T> = keyof A extends never ? T : T & A;
+declare type ModelAttributes<A extends AttributesDefinition, B extends boolean, K extends string, P extends ModelStd> = K extends keyof A ? A : ModelAttributesIf<A, P extends new () => EntryBase ? P["attributes"] : {
+    id: Type<BaseKeyType<B>, unknown>;
+}>;
+declare type ModelBase<N extends Natural, A extends AttributesDefinition, EA extends Record<string, Natural | undefined>, EM extends EntryBase, E extends EntryBase> = (new (from?: EA) => E) & Attribute<N, E> & {
+    attributes: A;
+    foreignKeys: Record<string, boolean>;
+    methods: EM;
+    parent?: ModelStd;
+    tableName: string;
+    load: (where?: Condition<A>) => Promise<E[]>;
 } & {
-    load: (boh: boolean) => Promise<T[]>;
-} & Meta<N, T> & {
-    tmp: number;
+    [a in keyof A]: Attribute<Native<A[a]>, E>;
+};
+declare type Model<N extends Natural, A extends AttributesDefinition, EM extends EntryBase> = ModelBase<N, A, EntryBaseAttributes<A>, EM, EntryBaseAttributes<A> & EM>;
+declare type ModelStd = Attribute<Natural, EntryBase> & {
+    attributes: AttributesDefinition;
+    foreignKeys: Record<string, boolean>;
+    methods: EntryBase;
+    parent?: ModelStd;
 };
-declare type ModelBase<E extends EntryBase> = new () => E;
 export declare type Entry<M> = M extends new () => infer E ? E : never;
+export declare type Where<M> = M extends {
+    load: (where: infer T) => void;
+} ? Exclude<T, undefined> : never;
 export interface SedentaryOptions {
+    autoSync?: boolean;
     log?: ((message: string) => void) | null;
-    serverless?: boolean;
     sync?: boolean;
 }
 export declare class Sedentary {
+    protected autoSync: boolean;
     protected db: DB;
     protected log: (...data: unknown[]) => void;
     protected sync: boolean;
     private models;
-    constructor(filename: string, options?: SedentaryOptions);
+    constructor(options?: SedentaryOptions);
     DATETIME(): Type<Date, unknown>;
-    FKEY<N extends Natural, E extends EntryBase>(attribute: Type<N, E>, options?: ForeignKeyOptions): Type<N, E>;
+    FKEY<N extends Natural, E extends EntryBase>(attribute: Attribute<N, E>, options?: ForeignKeyOptions): Type<N, E>;
     INT(size?: number): Type<number, unknown>;
     INT8(): Type<string, unknown>;
     VARCHAR(size?: number): Type<string, unknown>;
+    checkDB(): void;
     checkSize(size: number, message: string): number;
-    connect(): Promise<void>;
+    connect(sync?: boolean): Promise<void>;
     end(): Promise<void>;
-    model2<E extends EntryBase>(modelName: string): ModelBase<E>;
-    model2<E extends EntryBase, M extends Record<string, <S extends M>(this: E & S) => unknown>>(modelName: string, methods: M & Record<string, (this: E & M) => void>): ModelBase<E & M>;
-    model<A extends AttributesDefinition, B extends boolean, E extends EntryBase & EntryId<B> & ModelAttributes<A>>(modelName: string, attributes: A, options?: BaseModelOptions<B, E>): Ancestor<A, string, E>;
-    model<A extends AttributesDefinition, B extends boolean, K extends keyof A, P extends Meta<Natural, EntryBase>, N extends P extends {
-        tmp: number;
-    } ? (P extends Meta<infer N, EntryBase> ? N : never) : Native<A[K]>, E extends (P extends {
-        tmp: number;
-    } ? Parent<P> : EntryBase) & ModelAttributes<A>>(modelName: string, attributes: A, options?: BaseModelOptions<B, E> & {
+    escape(value: Natural): string;
+    model<A extends AttributesDefinition, B extends boolean, K extends string, P extends ModelStd, EM extends EntryMethods<A, P>>(modelName: string, attributes: A, options?: BaseModelOptions & {
+        int8id?: B;
         parent?: P;
-        primaryKey?: K;
-    }): Ancestor<A, N, E>;
-    model<A extends AttributesDefinition, B extends boolean, E extends EntryBase & EntryId<B> & ModelAttributes<A>, M extends Record<string, <S extends M>(this: E & S) => unknown>>(modelName: string, attributes: A, options: BaseModelOptions<B, E>, methods: M & Record<string, (this: E & M) => unknown>): Ancestor<A, string, E & M>;
-    model<A extends AttributesDefinition, B extends boolean, K extends keyof A, P extends Meta<Natural, EntryBase>, N extends P extends {
-        tmp: number;
-    } ? (P extends Meta<infer N, EntryBase> ? N : never) : Native<A[K]>, E extends (P extends {
-        tmp: number;
-    } ? Parent<P> : EntryBase) & ModelAttributes<A>, M extends Record<string, <S extends M>(this: E & S) => unknown>>(modelName: string, attributes: A, options: BaseModelOptions<B, E> & {
+        primaryKey?: K | keyof A;
+    }): Model<K extends keyof A ? Native<A[K]> : KeyType<B, P>, ModelAttributes<A, B, K, P>, EM>;
+    model<A extends AttributesDefinition, B extends boolean, K extends string, P extends ModelStd, EA extends EntryBaseAttributes<ModelAttributes<A, B, K, P>>, EM extends EntryMethods<A, P>, M extends Record<string, <S extends M>(this: EA & EM & S, ...args: any[]) => void>>(modelName: string, attributes: A, options: BaseModelOptions & {
+        int8id?: B;
         parent?: P;
-        primaryKey?: K;
-    }, methods: M & Record<string, (this: E & M) => unknown>): Ancestor<A, N, E & M>;
-}
-export declare const Package: typeof Sedentary;
-export declare class Sedentary2 {
-    model<E extends EntryBase>(modelName: string): ModelBase<E>;
-    model<E extends EntryBase, M extends Record<string, <S extends M>(this: E & S) => unknown>>(modelName: string, methods: M & Record<string, (this: E & M) => void>): ModelBase<E & M>;
+        primaryKey?: K | keyof A;
+    }, methods: M & Record<keyof M, (this: EA & EM & M, ...args: any[]) => void>): Model<K extends keyof A ? Native<A[K]> : KeyType<B, P>, ModelAttributes<A, B, K, P>, EM & M>;
 }

package/index.js

@@ -1,37 +1,37 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Sedentary2 = exports.Package = exports.Sedentary = exports.Type = exports.EntryBase = 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");
+exports.Sedentary = exports.Type = exports.EntryBase = void 0;
+const db_1 = require("./db");
+var db_2 = require("./db");
 Object.defineProperty(exports, "EntryBase", { enumerable: true, get: function () { return db_2.EntryBase; } });
 Object.defineProperty(exports, "Type", { enumerable: true, get: function () { return db_2.Type; } });
-const allowedOption = ["indexes", "init", "int8id", "methods", "parent", "primaryKey", "sync", "tableName", "type"];
+const allowedOption = ["indexes", "int8id", "parent", "primaryKey", "sync", "tableName"];
 const reservedNames = [
-    ...["attributeName", "base", "class", "constructor", "defaultValue", "entry", "fieldName", "init", "isModel"],
-    ...["load", "meta", "methods", "name", "primaryKey", "prototype", "save", "size", "tableName", "type"]
+    ...["attributeName", "attributes", "base", "class", "construct", "constructor", "defaultValue", "entry", "fieldName", "foreignKeys", "load"],
+    ...["loaded", "methods", "name", "postLoad", "postSave", "preLoad", "preSave", "primaryKey", "prototype", "save", "size", "tableName", "tx", "type"]
 ];
 class Sedentary {
-    constructor(filename, options) {
+    constructor(options) {
         this.sync = true;
         this.models = {};
-        if (typeof filename !== "string")
-            throw new Error("new Sedentary: 'filename' argument: Wrong type, expected 'string'");
         if (!options)
             options = {};
         if (!(options instanceof Object))
             throw new Error("new Sedentary: 'options' argument: Wrong type, expected 'Object'");
         for (const k in options)
-            if (!["log", "sync"].includes(k))
+            if (!["autoSync", "log", "sync"].includes(k))
                 throw new Error(`new Sedentary: 'options' argument: Unknown '${k}' option`);
-        const { log, sync } = Object.assign({ sync: true }, options);
+        const { autoSync, log, sync } = Object.assign({ autoSync: true, sync: true }, options);
+        if (typeof autoSync !== "boolean")
+            throw new Error("new Sedentary: 'autoSync' option: Wrong type, expected 'boolean'");
         if (log !== null && log !== undefined && !(log instanceof Function))
             throw new Error("new Sedentary: 'log' option: Wrong type, expected 'null' or 'Function'");
         if (typeof sync !== "boolean")
             throw new Error("new Sedentary: 'sync' option: Wrong type, expected 'boolean'");
-        this.log = (0, log_1.createLogger)(log);
-        this.db = new minidb_1.MiniDB(filename, this.log);
+        this.autoSync = autoSync;
+        this.db = null;
+        // eslint-disable-next-line no-console
+        this.log = log ? log : log === null ? () => { } : console.log;
         this.sync = sync;
     }
     DATETIME() {
@@ -56,6 +56,10 @@ class Sedentary {
         size = size ? this.checkSize(size, message) : undefined;
         return new db_1.Type({ base: String, size, type: "VARCHAR" });
     }
+    checkDB() {
+        if (!this.db)
+            throw new Error("Package sedentary can't be used directly. Please check: https://www.npmjs.com/package/sedentary#disclaimer");
+    }
     checkSize(size, message) {
         const str = size.toString();
         const parsed = parseInt(str, 10);
@@ -63,16 +67,20 @@ class Sedentary {
             throw new Error(message);
         return parsed;
     }
-    async connect() {
+    async connect(sync) {
         try {
+            this.checkDB();
             this.log("Connecting...");
             await this.db.connect();
-            this.log("Connected, syncing...");
-            await this.db.syncDataBase();
-            this.log("Synced");
+            this.log("Connected");
+            if (this.autoSync || sync) {
+                this.log("Syncing...");
+                await this.db.syncDataBase();
+                this.log("Synced");
+            }
         }
         catch (e) {
-            this.log("Connecting:", e.message);
+            this.log("Connecting: " + (e instanceof Error ? e.message : JSON.stringify(e)));
             throw e;
         }
     }
@@ -81,16 +89,12 @@ class Sedentary {
         await this.db.end();
         this.log("Connection closed");
     }
-    model2(modelName, methods) {
-        const ret = function () {
-            this.save();
-        };
-        Object.defineProperty(ret, "name", { value: name });
-        if (methods)
-            Object.assign(ret.prototype, methods);
-        return ret;
+    escape(value) {
+        return this.db.escape(value);
     }
+    /* eslint-enable @typescript-eslint/no-explicit-any */
     model(modelName, attributes, options, methods) {
+        this.checkDB();
         if (typeof modelName !== "string")
             throw new Error("Sedentary.model: 'name' argument: Wrong type, expected 'string'");
         if (this.models[modelName])
@@ -120,19 +124,13 @@ class Sedentary {
         let constraints = [{ attribute: aarray[0], constraintName: `${tableName}_id_unique`, type: "u" }];
         const iarray = [];
         const pk = aarray[0];
-        if (methods && !(methods instanceof Object))
+        if (!methods)
+            methods = {};
+        if (!(methods instanceof Object))
             throw new Error(`Sedentary.model: '${modelName}' model: 'methods' option: Wrong type, expected 'Object'`);
-        const originalMethods = methods;
-        if (parent) {
-            try {
-                if (!parent.isModel())
-                    throw new Error();
-            }
-            catch (e) {
+        if (parent)
+            if (!parent.attributes)
                 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: '${modelName}' model: 'primaryKey' option: Wrong type, expected 'string'`);
         if (primaryKey && !Object.keys(attributes).includes(primaryKey))
@@ -191,21 +189,21 @@ class Sedentary {
                 return ret;
             })();
             if (foreignKey) {
-                if (!foreignKey.options)
-                    foreignKey.options = {};
-                if (!(foreignKey.options instanceof Object))
+                const options = foreignKey.options || {};
+                if (foreignKey.options !== undefined && !(foreignKey.options instanceof Object))
                     throw new Error(`Sedentary.FKEY: '${modelName}' model: '${attributeName}' attribute: Wrong options type, expected 'Object'`);
-                for (const k in foreignKey.options)
+                for (const k in options)
                     if (!["onDelete", "onUpdate"].includes(k))
                         throw new Error(`Sedentary.FKEY: '${modelName}' model: '${attributeName}' attribute: Unknown option '${k}'`);
                 for (const onChange of ["onDelete", "onUpdate"]) {
                     const actions = ["cascade", "no action", "restrict", "set default", "set null"];
-                    let action = foreignKey.options[onChange];
+                    let action = options[onChange];
                     if (!action)
-                        action = foreignKey.options[onChange] = "no action";
+                        action = options[onChange] = "no action";
                     if (action && !actions.includes(action))
                         throw new Error(`Sedentary.FKEY: '${modelName}' model: '${attributeName}' attribute: '${onChange}' option: Wrong value, expected ${actions.map(_ => `'${_}'`).join(" | ")}`);
                 }
+                foreignKey.options = options;
             }
             if (primaryKey === attributeName) {
                 notNull = true;
@@ -274,208 +272,72 @@ class Sedentary {
         }
         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 () {
-                    parent.init.call(this);
-                    options.init.call(this);
-                }
-                : parent.init
-            : options.init;
-        class Class {
-            constructor() {
-                if (init)
-                    init.call(this);
-            }
-            save() {
-                return new Promise((resolve, reject) => {
-                    const save = () => reject(new Error("eh no"));
-                    Object.defineProperty(save, "name", { value: modelName + ".save" });
-                    setTimeout(save, 10);
-                });
-            }
-        }
-        const load = (boh) => new Promise((resolve, reject) => setTimeout(() => {
-            if (boh)
-                return resolve([new Class()]);
-            reject(new Error("boh"));
-        }, 10));
-        Object.defineProperty(load, "name", { value: modelName + ".load" });
-        const metaAttributes = aarray.reduce((ret, curr) => {
-            ret[curr.attributeName] = curr;
-            return ret;
-        }, {});
-        const metaForeignKeys = aarray
+        const foreignKeys = aarray
             .filter(_ => _.foreignKey)
             .reduce((ret, curr) => {
-            ret[curr.attributeName] = curr;
+            ret[curr.attributeName] = true;
             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)
+        for (const foreignKey in foreignKeys) {
+            if (foreignKey + "Load" in attributes)
                 throw new Error(`Sedentary.model: '${modelName}' model: '${foreignKey}' attribute: '${foreignKey}Load' inferred methods conflicts with an attribute`);
-            if (originalMethods && foreignKey + "Load" in originalMethods)
+            if (foreignKey + "Load" in methods)
                 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`);
+        for (const method in methods)
+            if (method in attributes)
+                throw new Error(`Sedentary.model: '${modelName}' model: '${method}' method: conflicts with an attribute`);
         const checkParent = (parent) => {
             if (!parent)
                 return;
-            for (const attribute in metaAttributes) {
+            for (const attribute in attributes) {
                 if (attribute in parent.attributes)
                     throw new Error(`Sedentary.model: '${modelName}' model: '${attribute}' attribute: conflicts with an attribute of '${parent.modelName}' model`);
-                if (parent.methods && attribute in parent.methods)
+                if (attribute in parent.methods)
                     throw new Error(`Sedentary.model: '${modelName}' model: '${attribute}' attribute: conflicts with a method of '${parent.modelName}' model`);
                 for (const foreignKey in parent.foreignKeys)
                     if (attribute === foreignKey + "Load")
                         throw new Error(`Sedentary.model: '${modelName}' model: '${attribute}' attribute: conflicts with an inferred methods of '${parent.modelName}' model`);
             }
-            for (const foreignKey in metaForeignKeys) {
+            for (const foreignKey in foreignKeys) {
                 if (foreignKey + "Load" in parent.attributes)
                     throw new Error(`Sedentary.model: '${modelName}' model: '${foreignKey}' attribute: '${foreignKey}Load' inferred methods conflicts with an attribute of '${parent.modelName}' model`);
-                if (parent.methods && foreignKey + "Load" in parent.methods)
+                if (foreignKey + "Load" in parent.methods)
                     throw new Error(`Sedentary.model: '${modelName}' model: '${foreignKey}' attribute: '${foreignKey}Load' inferred methods conflicts with a method of '${parent.modelName}' model`);
             }
-            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`);
-                }
+            for (const method in methods) {
+                if (method in parent.attributes)
+                    throw new Error(`Sedentary.model: '${modelName}' model: '${method}' method: conflicts with an attribute of '${parent.modelName}' model`);
+                for (const foreignKey in parent.foreignKeys)
+                    if (foreignKey + "Load" === method)
+                        throw new Error(`Sedentary.model: '${modelName}' model: '${method}' method: conflicts with an inferred methods of '${parent.modelName}' model`);
+                if (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: 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", "modelName", "size", "type", "unique"])
-            Object.defineProperty(Class, key, { value: pk[key] });
-        return Class;
-    }
-}
-exports.Sedentary = Sedentary;
-exports.Package = Sedentary;
-const db = new Sedentary("gino");
-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()
-}, {
-    init: function () {
-        this.num = "0";
-        this.str = "0";
-    },
-    int8id: true
-    /*
-    methods: {
-      prova: (): string => "ok"
-    }
-    */
-}) {
-}
-class Super extends db.model("Super", {
-    a: db.INT,
-    n: db.FKEY(Item),
-    s: db.FKEY(Users.bar)
-}, {
-    parent: Item
-    /*
-    init:   async function() {
-      this.n = "23";
-      this.id = 0;
-      this.num = 0;
-      const a = this.nLoad ? await this.nLoad() : { prova: (): null => null };
-      a.prova();
-      this.prova();
-    }
-    */
-}) {
-}
-class Next extends db.model("Next", { a: db.INT, b: db.INT }, {
-    init: function () {
-        this.a = 23;
-    },
-    primaryKey: "a"
-}) {
-}
-class Current extends db.model("Current", { b: { type: db.FKEY(Next), unique: true } }, {
-    init: function () {
-        this.b = 24;
-    }
-}) {
-}
-class Last extends db.model("Last", { c: db.FKEY(Current.b) }, {
-    init: function () {
-        this.c = 24;
-    },
-    parent: Next
-}) {
-}
-(async function () {
-    const item = new Super();
-    try {
-        await item.save();
-    }
-    catch (e) {
-        console.log(Item.load, item.save, await Item.load(true), item, e.message);
-        //console.log(new Next(), Next.load, await Next.load(true), new Last(), item.prova());
-    }
-    return true;
-})();
-function model(modelName, attributes, options, methods) {
-    const model = function () { };
-    Object.defineProperty(model, "name", { value: modelName });
-    if (methods)
-        Object.assign(model.prototype, methods);
-    return model;
-}
-const T1 = model("T1", {});
-const t1 = new T1();
-t1.id = 0;
-console.log(t1);
-const T2 = model("T2", { a: db.INT, b: db.VARCHAR }, { int8id: true }, {
-    test: function (repeat = true) {
-        if (repeat)
-            this.b = this.test(false);
-        this.c = this.a = 0;
-        return "test";
-    }
-});
-const t2 = new T2();
-//t2.id = "0";
-const tt2 = (t) => console.log(t, t.test(), t.a, t.b);
-tt2(t2);
-class Sedentary2 {
-    model(modelName, methods) {
-        const ret = function () { };
+        const ret = class extends (parent || db_1.EntryBase) {
+        };
+        const load = (boh) => new Promise((resolve, reject) => setTimeout(() => {
+            if (boh)
+                return resolve([new ret()]);
+            reject(new Error("boh"));
+        }, 10));
+        Object.defineProperty(load, "name", { value: modelName + ".load" });
         Object.defineProperty(ret, "name", { value: modelName });
-        if (methods)
-            Object.assign(ret.prototype, methods);
-        ret.prototype.save = () => new Promise(resolve => resolve(false));
+        Object.defineProperty(ret, "load", { value: load });
+        Object.defineProperty(ret, "attributes", { value: attributes });
+        Object.defineProperty(ret, "foreignKeys", { value: foreignKeys });
+        Object.defineProperty(ret, "methods", { value: methods });
+        Object.assign(ret.prototype, methods);
+        ret.prototype.save = this.db.save(tableName, aarray);
+        Object.defineProperty(ret.prototype.save, "name", { value: modelName + ".save" });
+        for (const attribute of aarray)
+            Object.defineProperty(ret, attribute.attributeName, { value: attribute });
+        for (const key of ["attributeName", "base", "fieldName", "modelName", "size", "tableName", "type", "unique"])
+            Object.defineProperty(ret, key, { value: pk[key] });
         return ret;
     }
 }
-exports.Sedentary2 = Sedentary2;
-const db2 = new Sedentary2();
-const T22 = db2.model("T2", {
-    c: function () {
-        this.id = "0";
-        this.c();
-        return 0;
-    }
-});
+exports.Sedentary = Sedentary;

package/package.json

@@ -1,14 +1,18 @@
 {
   "author": "Daniele Ricci <daniele.icc@gmail.com> (https://github.com/iccicci)",
   "bugs": "https://github.com/iccicci/sedentary/issues",
+  "contributors": [
+    "Daniele Ricci <daniele.icc@gmail.com> (https://github.com/iccicci)",
+    "yossarian <sergiybiluk@gmail.com> (https://github.com/captain-yossarian)"
+  ],
   "dependencies": {},
   "description": "The ORM which never needs to migrate",
   "devDependencies": {
     "@types/mocha": "9.0.0",
-    "@types/node": "17.0.0",
+    "@types/node": "17.0.5",
     "@types/yamljs": "0.2.31",
-    "@typescript-eslint/eslint-plugin": "5.7.0",
-    "@typescript-eslint/parser": "5.7.0",
+    "@typescript-eslint/eslint-plugin": "5.8.1",
+    "@typescript-eslint/parser": "5.8.1",
     "eslint": "8.5.0",
     "mocha": "9.1.3",
     "nyc": "15.1.0",
@@ -58,9 +62,21 @@
   },
   "tsd": {
     "compilerOptions": {
-      "strict": false
+      "alwaysStrict": true,
+      "declaration": true,
+      "esModuleInterop": true,
+      "module": "commonjs",
+      "noImplicitAny": true,
+      "noImplicitReturns": true,
+      "noImplicitThis": true,
+      "strict": true,
+      "strictBindCallApply": true,
+      "strictFunctionTypes": true,
+      "strictNullChecks": true,
+      "strictPropertyInitialization": true,
+      "target": "es2017"
     }
   },
   "types": "index.d.ts",
-  "version": "0.0.19"
+  "version": "0.0.23"
 }

package/lib/log.d.ts

@@ -1,4 +0,0 @@
-export declare function createLogger(log: ((message: string) => void) | null | undefined): {
-    (...data: any[]): void;
-    (message?: any, ...optionalParams: any[]): void;
-};

package/lib/log.js

@@ -1,20 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createLogger = void 0;
-const console_1 = require("console");
-const stream_1 = require("stream");
-class Logger extends stream_1.Writable {
-    constructor(log) {
-        super();
-        this.log = log;
-    }
-    _write(chunk, encoding, callback) {
-        this.log(chunk.toString());
-        callback();
-    }
-}
-function createLogger(log) {
-    // eslint-disable-next-line no-console
-    return log ? new console_1.Console(new Logger(log)).log : log === null ? () => { } : console.log;
-}
-exports.createLogger = createLogger;

package/lib/log.ts

@@ -1,22 +0,0 @@
-import { Console } from "console";
-import { Writable } from "stream";
-
-class Logger extends Writable {
-  private log: (message: string) => void;
-
-  constructor(log: (message: string) => void) {
-    super();
-
-    this.log = log;
-  }
-
-  _write(chunk: Buffer, encoding: string, callback: () => void) {
-    this.log(chunk.toString());
-    callback();
-  }
-}
-
-export function createLogger(log: ((message: string) => void) | null | undefined) {
-  // eslint-disable-next-line no-console
-  return log ? new Console(new Logger(log)).log : log === null ? () => {} : console.log;
-}

package/lib/minidb.d.ts

@@ -1,17 +0,0 @@
-import { DB, Table } from "./db";
-export declare class MiniDB extends DB {
-    private body;
-    private file;
-    constructor(filename: string, log: (message: string) => void);
-    connect(): Promise<void>;
-    dropConstraints(table: Table): Promise<number[]>;
-    dropFields(table: Table): Promise<void>;
-    dropIndexes(table: Table, constraintIndexes: number[]): Promise<void>;
-    end(): Promise<void>;
-    save(): Promise<void>;
-    syncConstraints(table: Table): Promise<void>;
-    syncIndexes(table: Table): Promise<void>;
-    syncFields(table: Table): Promise<void>;
-    syncSequence(table: Table): Promise<void>;
-    syncTable(table: Table): Promise<void>;
-}

package/lib/minidb.js

@@ -1,190 +0,0 @@
-"use strict";
-/* eslint-disable @typescript-eslint/no-explicit-any */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MiniDB = void 0;
-const db_1 = require("./db");
-const fs_1 = require("fs");
-const { readFile, writeFile } = fs_1.promises;
-class MiniDB extends db_1.DB {
-    constructor(filename, log) {
-        super(log);
-        this.file = filename;
-    }
-    async connect() {
-        this.body = { next: {}, tables: {} };
-        try {
-            this.body = JSON.parse((await readFile(this.file)).toString());
-        }
-        catch (e) {
-            if (e.code !== "ENOENT")
-                throw e;
-        }
-    }
-    async dropConstraints(table) {
-        const { constraints } = this.body.tables[table.tableName] || { constraints: { f: {}, u: {} } };
-        for (const constraint of Object.keys(constraints.f).sort()) {
-            const arr = table.constraints.filter(({ constraintName, type }) => constraintName === constraint && type === "f");
-            const dbOptions = arr.length ? arr[0].attribute.foreignKey.options : { onDelete: "delete", onUpdate: "delete" };
-            const inOptions = constraints.f[constraint].options;
-            if (dbOptions.onDelete !== inOptions.onDelete || dbOptions.onUpdate !== inOptions.onUpdate) {
-                this.syncLog(`'${table.tableName}': Removing foreign key: '${constraint}'`);
-                if (this.sync)
-                    delete constraints.f[constraint];
-            }
-        }
-        for (const constraint of Object.keys(constraints.u).sort()) {
-            if (!table.constraints.filter(({ constraintName, type }) => constraintName === constraint && type === "u").length) {
-                this.syncLog(`'${table.tableName}': Removing unique constraint from field: '${constraints.u[constraint].on}'`);
-                if (this.sync)
-                    delete constraints.u[constraint];
-            }
-        }
-        await this.save();
-        return [];
-    }
-    async dropFields(table) {
-        const { fields } = this.body.tables[table.tableName] || { fields: {} };
-        for (const attribute of Object.keys(fields).sort()) {
-            if (!table.findField(attribute)) {
-                this.syncLog(`'${table.tableName}': Removing field: '${attribute}'`);
-                if (this.sync)
-                    delete fields[attribute];
-            }
-        }
-        await this.save();
-    }
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    async dropIndexes(table, constraintIndexes) {
-        const { indexes } = this.body.tables[table.tableName] || { indexes: {} };
-        for (const name of Object.keys(indexes).sort()) {
-            const index = table.indexes.filter(_ => _.indexName === name);
-            if (index.length === 0 || !this.indexesEq(indexes[name], index[0])) {
-                this.syncLog(`'${table.tableName}': Removing index: '${name}'`);
-                if (this.sync)
-                    delete indexes[name];
-            }
-        }
-        await this.save();
-    }
-    async end() { }
-    async save() {
-        await writeFile(this.file, JSON.stringify(this.body));
-    }
-    async syncConstraints(table) {
-        const { constraints } = this.body.tables[table.tableName] || { constraints: { f: {}, u: {} } };
-        for (const constraint of table.constraints) {
-            const { attribute, constraintName, type } = constraint;
-            if (!constraints[type][constraintName]) {
-                if (type === "f") {
-                    const { fieldName, options, tableName } = attribute.foreignKey;
-                    const onDelete = options.onDelete !== "no action" ? ` on delete ${options.onDelete}` : "";
-                    const onUpdate = options.onUpdate !== "no action" ? ` on update ${options.onUpdate}` : "";
-                    this.syncLog(`'${table.tableName}': Adding foreign key '${constraint.constraintName}' on field: '${attribute.fieldName}' references '${tableName}(${fieldName})'${onDelete}${onUpdate}`);
-                    if (this.sync)
-                        constraints[type][constraintName] = { on: attribute.fieldName, options, fieldName, tableName };
-                }
-                else {
-                    this.syncLog(`'${table.tableName}': Adding unique constraint on field: '${attribute.fieldName}'`);
-                    if (this.sync)
-                        constraints[type][constraintName] = { on: attribute.fieldName };
-                }
-            }
-        }
-        await this.save();
-    }
-    async syncIndexes(table) {
-        const { indexes } = this.body.tables[table.tableName] || { indexes: {} };
-        for (const index of table.indexes) {
-            const { indexName } = index;
-            if (!(indexName in indexes)) {
-                this.syncLog(`'${table.tableName}': Adding index: '${indexName}' on (${index.fields.map(_ => `'${_}'`).join(", ")}) type '${index.type}'${index.unique ? " unique" : ""}`);
-                if (this.sync)
-                    indexes[indexName] = index;
-            }
-        }
-        await this.save();
-    }
-    async syncFields(table) {
-        for (const attribute of table.attributes) {
-            const { fields } = this.body.tables[table.tableName] || { fields: {} };
-            const { defaultValue, fieldName, notNull, size, type } = attribute;
-            let field = fields[fieldName];
-            if (!field) {
-                this.syncLog(`'${table.tableName}': Adding field: '${fieldName}' '${type}' '${size || ""}'`);
-                if (this.sync)
-                    field = fields[fieldName] = { size, type };
-                else
-                    field = {};
-            }
-            if (field.size !== size || field.type !== type) {
-                this.syncLog(`'${table.tableName}': Changing field type: '${fieldName}' '${type}' '${size || ""}'`);
-                if (this.sync)
-                    field = fields[fieldName] = Object.assign(Object.assign({}, field), { size, type });
-            }
-            if (field.default) {
-                if (!defaultValue) {
-                    this.syncLog(`'${table.tableName}': Dropping default value for field: '${fieldName}'`);
-                    if (this.sync)
-                        delete field.default;
-                }
-                else if (field.default !== defaultValue) {
-                    this.syncLog(`'${table.tableName}': Changing default value to '${defaultValue}' for field: '${fieldName}'`);
-                    if (this.sync)
-                        field.default = defaultValue;
-                }
-            }
-            else if (defaultValue) {
-                this.syncLog(`'${table.tableName}': Setting default value '${defaultValue instanceof Date ? defaultValue.toISOString() : defaultValue}' for field: '${fieldName}'`);
-                if (this.sync)
-                    field.default = defaultValue;
-            }
-            if (field.notNull) {
-                if (!notNull) {
-                    this.syncLog(`'${table.tableName}': Dropping not null for field: '${fieldName}'`);
-                    if (this.sync)
-                        delete field.notNull;
-                }
-            }
-            else if (notNull) {
-                this.syncLog(`'${table.tableName}': Setting not null for field: '${fieldName}'`);
-                if (this.sync)
-                    field.notNull = true;
-            }
-        }
-        await this.save();
-    }
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    async syncSequence(table) { }
-    async syncTable(table) {
-        if (this.body.tables[table.tableName]) {
-            (() => {
-                if (table.parent) {
-                    if (this.body.tables[table.tableName].parent === table.parent.tableName)
-                        return;
-                }
-                else if (!this.body.tables[table.tableName].parent)
-                    return;
-                this.syncLog(`Removing table: '${table.tableName}'`);
-                if (this.sync)
-                    delete this.body.tables[table.tableName];
-            })();
-        }
-        if (!this.body.tables[table.tableName]) {
-            this.syncLog(`Adding table: '${table.tableName}'`);
-            if (this.sync)
-                this.body.tables[table.tableName] = { constraints: { f: {}, u: {} }, fields: {}, indexes: {} };
-            if (table.parent) {
-                this.syncLog(`Setting parent: '${table.parent.tableName}' - to table: '${table.tableName}'`);
-                if (this.sync)
-                    this.body.tables[table.tableName].parent = table.parent.tableName;
-            }
-            if (table.autoIncrement && !this.body.next[table.tableName]) {
-                this.syncLog(`Setting auto increment: '${table.tableName}'`);
-                if (this.sync)
-                    this.body.next[table.tableName] = 1;
-            }
-        }
-        await this.save();
-    }
-}
-exports.MiniDB = MiniDB;

package/requirements.txt

@@ -1,2 +0,0 @@
-sphinx
-sphinx_rtd_theme