sedentary 0.0.20 → 0.0.24

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,7 +1,9 @@
-export declare type Natural = Date | Record<string, unknown> | boolean | number | string;
+export declare type Natural = Date | Record<string, unknown> | boolean | number | string | null;
 export declare class EntryBase {
+    constructor(from?: Partial<EntryBase>);
     construct(): void;
     postLoad(): void;
+    postSave(): void;
     preLoad(): void;
     preSave(): void;
     save(): Promise<boolean>;
@@ -29,7 +31,7 @@ export declare class Type<N extends Natural, E> {
 }
 export interface Attribute<N extends Natural, E> extends Type<N, E> {
     attributeName: string;
-    defaultValue?: unknown;
+    defaultValue?: Natural;
     fieldName: string;
     modelName: string;
     notNull: boolean;
@@ -55,7 +57,11 @@ interface ITable {
     autoIncrement: boolean;
     constraints: Constraint[];
     indexes: Index[];
-    parent: any;
+    model: {
+        load: (where: any, order?: string[], tx?: Transaction) => Promise<EntryBase[]>;
+    };
+    parent?: Attribute<Natural, unknown>;
+    pk: Attribute<Natural, unknown>;
     sync: boolean;
     tableName: string;
 }
@@ -76,6 +82,10 @@ export declare abstract class DB {
     protected indexesEq(a: Index, b: Index): boolean;
     syncDataBase(): Promise<void>;
     protected syncLog(message: string): void;
+    begin(): Promise<Transaction>;
+    abstract escape(value: Natural): string;
+    abstract load(tableName: string, attributes: Record<string, string>, pk: Attribute<Natural, unknown>, model: new () => EntryBase, table: Table): (where: string, order?: string[], tx?: Transaction) => Promise<EntryBase[]>;
+    abstract save(tableName: string, attributes: Record<string, string>, pk: Attribute<Natural, unknown>): (this: EntryBase & 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>;
@@ -85,4 +95,11 @@ export declare abstract class DB {
     abstract syncSequence(table: Table): Promise<void>;
     abstract syncTable(table: Table): Promise<void>;
 }
+export declare class Transaction {
+    private entries;
+    addEntry(entry: EntryBase): void;
+    clean(): void;
+    commit(): Promise<void>;
+    rollback(): Promise<void>;
+}
 export {};

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

@@ -1,9 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DB = exports.Table = exports.Attribute = 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() {
@@ -73,5 +83,29 @@ class DB {
     syncLog(message) {
         this.log(this.sync ? message : "NOT SYNCING: " + message);
     }
+    async begin() {
+        return new Transaction();
+    }
 }
 exports.DB = DB;
+class Transaction {
+    constructor() {
+        this.entries = [];
+    }
+    addEntry(entry) {
+        this.entries.push(entry);
+    }
+    clean() {
+        const { entries } = this;
+        for (const entry of entries)
+            delete entry.tx;
+        this.entries = [];
+    }
+    async commit() {
+        this.clean();
+    }
+    async rollback() {
+        this.clean();
+    }
+}
+exports.Transaction = Transaction;

package/index.d.ts

@@ -1,5 +1,5 @@
-import { Attribute, DB, EntryBase, ForeignKeyOptions, Natural, Type } from "./lib/db";
-export { EntryBase, ForeignKeyActions, ForeignKeyOptions, Natural, Type } from "./lib/db";
+import { Attribute, DB, EntryBase, ForeignKeyOptions, Natural, Transaction, Type } from "./db";
+export { EntryBase, ForeignKeyActions, ForeignKeyOptions, Natural, Transaction, Type } from "./db";
 export declare type TypeDefinition<N extends Natural, E> = (() => Type<N, E>) | Type<N, E>;
 export interface AttributeOptions<N extends Natural, E> {
     defaultValue?: N;
@@ -16,7 +16,7 @@ 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 Native__<T> = T extends Type<infer N, unknown> ? N : never;
+declare type Native__<T> = T extends Type<infer N, unknown> ? N | null : 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>;
 export declare type IndexAttributes = string[] | string;
@@ -36,14 +36,15 @@ interface BaseModelOptions {
 }
 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] | ["LIKE", string] | ["IN", ...N[]];
+declare type ConditionAttribute<N extends Natural> = N | ["=" | ">" | "<" | ">=" | "<=" | "<>", N] | ["IN", N[]] | ["IS NULL"] | ["LIKE", string] | ["NOT"];
 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 Order<A extends AttributesDefinition> = (keyof A | `-${string & keyof 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 BaseKeyType<B extends boolean> = IsUnion<B> extends true ? number : B extends true ? string : number;
@@ -61,16 +62,19 @@ declare type ModelAttributesIf<A extends AttributesDefinition, T> = keyof A exte
 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> & {
+interface ModelLoad<A extends AttributesDefinition, E extends EntryBase> {
     attributes: A;
+    load(where: Condition<A>, order?: Order<A>, tx?: Transaction): Promise<E[]>;
+    load(where: Condition<A>, tx: Transaction): Promise<E[]>;
+}
+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> & {
     foreignKeys: Record<string, boolean>;
     methods: EM;
     parent?: ModelStd;
     tableName: string;
-    load: (where?: Condition<A>) => Promise<E[]>;
 } & {
     [a in keyof A]: Attribute<Native<A[a]>, E>;
-};
+} & ModelLoad<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;
@@ -79,28 +83,40 @@ declare type ModelStd = Attribute<Natural, EntryBase> & {
     parent?: ModelStd;
 };
 export declare type Entry<M> = M extends new () => infer E ? E : never;
-export declare type Where<M> = M extends {
-    load: (where: infer T) => void;
+export declare type OrderBy<M> = M extends {
+    load(where: unknown, order?: infer T, tx?: Transaction): void;
+    load(where: unknown, tx?: Transaction): void;
 } ? Exclude<T, undefined> : never;
+export declare type Where<M> = M extends {
+    load(where: infer T, order?: unknown, tx?: Transaction): void;
+    load(where: unknown, tx?: Transaction): void;
+} ? T : 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 doSync: boolean;
     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: Attribute<N, E>, options?: ForeignKeyOptions): Type<N, E>;
     INT(size?: number): Type<number, unknown>;
     INT8(): Type<string, unknown>;
     VARCHAR(size?: number): Type<string, unknown>;
-    checkSize(size: number, message: string): number;
-    connect(): Promise<void>;
+    private checkDB;
+    private checkOrderBy;
+    private checkSize;
+    private createWhere;
+    connect(sync?: boolean): Promise<void>;
+    sync(): Promise<void>;
     end(): Promise<void>;
+    begin(): Promise<Transaction>;
+    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;
@@ -112,4 +128,3 @@ export declare class Sedentary {
         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>;
 }
-export declare const Package: typeof Sedentary;

package/index.js

@@ -1,38 +1,40 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Package = exports.Sedentary = exports.Type = exports.EntryBase = void 0;
-const db_1 = require("./lib/db");
-const minidb_1 = require("./lib/minidb");
-var db_2 = require("./lib/db");
+exports.Sedentary = exports.Type = exports.Transaction = 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, "Transaction", { enumerable: true, get: function () { return db_2.Transaction; } });
 Object.defineProperty(exports, "Type", { enumerable: true, get: function () { return db_2.Type; } });
+const operators = ["=", ">", "<", ">=", "<=", "<>", "IN", "IS NULL", "LIKE", "NOT"];
 const allowedOption = ["indexes", "int8id", "parent", "primaryKey", "sync", "tableName"];
 const reservedNames = [
-    ...["attributeName", "attributes", "base", "class", "construct", "constructor", "defaultValue", "entry", "fieldName", "foreignKeys", "load"],
-    ...["methods", "name", "postLoad", "postSave", "preLoad", "preSave", "primaryKey", "prototype", "save", "size", "tableName", "type"]
+    ...["attr2field", "attributeName", "attributes", "base", "class", "construct", "constructor", "defaultValue", "entry", "fieldName", "foreignKeys", "load"],
+    ...["loaded", "methods", "name", "postLoad", "postSave", "preLoad", "preSave", "primaryKey", "prototype", "save", "size", "tableName", "tx", "type"]
 ];
 class Sedentary {
-    constructor(filename, options) {
-        this.sync = true;
+    constructor(options) {
+        this.doSync = 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.autoSync = autoSync;
+        this.db = null;
         // eslint-disable-next-line no-console
         this.log = log ? log : log === null ? () => { } : console.log;
-        this.db = new minidb_1.MiniDB(filename, this.log);
-        this.sync = sync;
+        this.doSync = sync;
     }
     DATETIME() {
         return new db_1.Type({ base: Date, type: "DATETIME" });
@@ -56,6 +58,28 @@ 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");
+    }
+    checkOrderBy(order, attributes, modelName) {
+        if (!order)
+            return true;
+        if (!(order instanceof Array))
+            return false;
+        const provided = {};
+        for (const attribute of order) {
+            if (typeof attribute !== "string")
+                return false;
+            const attributeName = attribute.startsWith("-") ? attribute.substring(1) : attribute;
+            if (!(attributeName in attributes))
+                throw new Error(`${modelName}.load: 'order' argument: '${attributeName}' is not an attribute name`);
+            if (provided[attributeName])
+                throw new Error(`${modelName}.load: 'order' argument: Reused '${attributeName}' attribute`);
+            provided[attributeName] = true;
+        }
+        return true;
+    }
     checkSize(size, message) {
         const str = size.toString();
         const parsed = parseInt(str, 10);
@@ -63,26 +87,109 @@ class Sedentary {
             throw new Error(message);
         return parsed;
     }
-    async connect() {
+    createWhere(modelName, attributes, where) {
+        if (typeof where === "string")
+            return [where, true, true];
+        if (typeof where !== "object")
+            throw new Error(`${modelName}.load: 'where' argument: Wrong type, expected 'Array', 'Object' or 'string'`);
+        if (!where)
+            return ["", false, false];
+        if (where instanceof Array) {
+            const length = where.length;
+            if (!length)
+                throw new Error(`${modelName}.load: 'where' argument: Empty Array`);
+            if (!["AND", "NOT", "OR"].includes(where[0]))
+                throw new Error(`${modelName}.load: 'where' argument: Wrong logical operator, expected 'AND', 'OR' or 'NOT'`);
+            if (length === 1)
+                return ["", false, false];
+            if (where[0] === "NOT") {
+                if (length > 2)
+                    throw new Error(`${modelName}.load: 'where' argument: 'NOT' operator is unary`);
+                const [res] = this.createWhere(modelName, attributes, where[1]);
+                return [res === "" ? "" : `NOT (${res})`, false, false];
+            }
+            const conditions = where
+                .filter((_, i) => i)
+                .map(_ => this.createWhere(modelName, attributes, _))
+                .filter(([_]) => _);
+            if (conditions.length === 1)
+                return conditions[0];
+            const isOr = where[0] === "OR";
+            return [isOr ? conditions.map(([_, , a]) => (a ? `(${_})` : _)).join(" OR ") : conditions.map(([_, o]) => (o ? `(${_})` : _)).join(" AND "), isOr, false];
+        }
+        const conditions = [];
+        for (const key in where) {
+            const field = attributes[key];
+            if (!field)
+                throw new Error(`${modelName}.load: 'where' argument: Unknown '${key}' attribute`);
+            const value = where[key];
+            if (value instanceof Array) {
+                const operator = value[0];
+                const length = value.length;
+                if (!length)
+                    throw new Error(`${modelName}.load: 'where' argument: Missing arithmetic operator, expected one of: ${operators.map(_ => `'${_}'`).join(", ")}`);
+                if (!operators.includes(operator))
+                    throw new Error(`${modelName}.load: 'where' argument: Wrong arithmetic operator, expected one of: ${operators.map(_ => `'${_}'`).join(", ")}`);
+                if (operator === "IS NULL") {
+                    if (length !== 1)
+                        throw new Error(`${modelName}.load: 'where' argument: 'IS NULL' operator is unary`);
+                    conditions.push(`${field} IS NULL`);
+                }
+                else if (operator === "NOT") {
+                    if (length !== 1)
+                        throw new Error(`${modelName}.load: 'where' argument: 'NOT' operator is unary`);
+                    conditions.push(`NOT ${field}`);
+                }
+                else {
+                    if (length !== 2)
+                        throw new Error(`${modelName}.load: 'where' argument: '${operator}' operator is binary`);
+                    if (operator === "IN") {
+                        if (!(value[1] instanceof Array))
+                            throw new Error(`${modelName}.load: 'where' argument: 'IN' right operand: Wrong type, expected Array`);
+                        conditions.push(`${field} IN (${value[1].map(_ => this.escape(_)).join(", ")})`);
+                    }
+                    else
+                        conditions.push(`${field} ${operator} ${this.escape(value[1])}`);
+                }
+            }
+            else
+                conditions.push(`${field} = ${this.escape(value)}`);
+        }
+        return [conditions.length ? conditions.join(" AND ") : "", false, false];
+    }
+    async connect(sync) {
         try {
+            this.checkDB();
             this.log("Connecting...");
             await this.db.connect();
-            this.log("Connected, syncing...");
-            await this.db.syncDataBase();
-            this.log("Synced");
+            this.log("Connected");
+            if (this.autoSync || sync)
+                await this.sync();
         }
         catch (e) {
             this.log("Connecting: " + (e instanceof Error ? e.message : JSON.stringify(e)));
             throw e;
         }
     }
+    async sync() {
+        this.log("Syncing...");
+        await this.db.syncDataBase();
+        this.log("Synced");
+    }
     async end() {
         this.log("Closing connection...");
         await this.db.end();
         this.log("Connection closed");
     }
+    async begin() {
+        return this.db.begin();
+    }
+    escape(value) {
+        return this.db.escape(value);
+    }
     /* eslint-enable @typescript-eslint/no-explicit-any */
     model(modelName, attributes, options, methods) {
+        this.checkDB();
         if (typeof modelName !== "string")
             throw new Error("Sedentary.model: 'name' argument: Wrong type, expected 'string'");
         if (this.models[modelName])
@@ -105,25 +212,28 @@ class Sedentary {
         if (options.parent && options.primaryKey)
             throw new Error(`Sedentary.model: '${modelName}' model: 'parent' and 'primaryKey' options conflict each other`);
         let autoIncrement = true;
-        const { indexes, int8id, parent, primaryKey, sync, tableName } = Object.assign({ sync: this.sync, tableName: modelName }, options);
+        const { indexes, int8id, parent, primaryKey, sync, tableName } = Object.assign({ sync: this.doSync, tableName: modelName }, options);
         let aarray = int8id
             ? [new db_1.Attribute(Object.assign(Object.assign({}, this.INT8()), { attributeName: "id", fieldName: "id", modelName, notNull: true, tableName, unique: true }))]
             : [new db_1.Attribute(Object.assign(Object.assign({}, this.INT(4)), { attributeName: "id", fieldName: "id", modelName, notNull: true, tableName, unique: true }))];
         let constraints = [{ attribute: aarray[0], constraintName: `${tableName}_id_unique`, type: "u" }];
         const iarray = [];
-        const pk = aarray[0];
-        if (methods && !(methods instanceof Object))
+        let pk = aarray[0];
+        let attr2field = { id: "id" };
+        if (!methods)
+            methods = {};
+        if (!(methods instanceof Object))
             throw new Error(`Sedentary.model: '${modelName}' model: 'methods' option: Wrong type, expected 'Object'`);
-        const originalMethods = methods;
         if (parent)
             if (!parent.attributes)
                 throw new Error(`Sedentary.model: '${modelName}' model: 'parent' option: Wrong type, expected 'Model'`);
-        //methods = (methods ? { ...(parent.methods || {}), ...methods } : parent.methods) as never;
         if (primaryKey && typeof primaryKey !== "string")
             throw new Error(`Sedentary.model: '${modelName}' model: 'primaryKey' option: Wrong type, expected 'string'`);
         if (primaryKey && !Object.keys(attributes).includes(primaryKey))
             throw new Error(`Sedentary.model: '${modelName}' model: 'primaryKey' option: Attribute '${primaryKey}' does not exists`);
         if (parent || primaryKey) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            attr2field = parent ? Object.assign({}, parent.attr2field) : {};
             autoIncrement = false;
             aarray = [];
             constraints = [];
@@ -200,7 +310,10 @@ class Sedentary {
             if (defaultValue)
                 notNull = true;
             const attribute = new db_1.Attribute({ attributeName, base, defaultValue, fieldName, foreignKey, modelName, notNull, size, tableName, type, unique });
+            if (primaryKey === attributeName)
+                pk = attribute;
             aarray.push(attribute);
+            attr2field[attributeName] = fieldName;
             if (foreignKey)
                 constraints.push({ attribute, constraintName: `fkey_${fieldName}_${foreignKey.tableName}_${foreignKey.fieldName}`, type: "f" });
             if (unique)
@@ -258,7 +371,6 @@ class Sedentary {
                 iarray.push({ fields: attributes, indexName, type, unique });
             }
         }
-        this.db.tables.push(new db_1.Table({ autoIncrement, constraints, attributes: aarray, indexes: iarray, parent, sync, tableName }));
         this.models[modelName] = true;
         const foreignKeys = aarray
             .filter(_ => _.foreignKey)
@@ -269,13 +381,12 @@ class Sedentary {
         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 attributes)
-                    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;
@@ -294,37 +405,49 @@ class Sedentary {
                 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 (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`);
             }
             checkParent(parent.parent);
         };
         checkParent(parent);
-        const ret = function () { };
-        const load = (boh) => new Promise((resolve, reject) => setTimeout(() => {
-            if (boh)
-                return resolve([new ret()]);
-            reject(new Error("boh"));
-        }, 10));
+        const ret = class extends (parent || db_1.EntryBase) {
+        };
+        const table = new db_1.Table({ autoIncrement, constraints, attributes: aarray, indexes: iarray, model: ret, parent, pk, sync, tableName });
+        this.db.tables.push(table);
+        const load_ = this.db.load(tableName, attr2field, pk, ret, table);
+        const load = async (where, order, tx) => {
+            if (order instanceof db_1.Transaction) {
+                tx = order;
+                order = undefined;
+            }
+            if (!this.checkOrderBy(order, attr2field, modelName))
+                throw new Error(`${modelName}.load: 'order' argument: Wrong type, expected 'string[]'`);
+            const [str] = this.createWhere(modelName, attr2field, where);
+            const ret = await load_(str, order, tx);
+            return ret;
+        };
         Object.defineProperty(load, "name", { value: modelName + ".load" });
         Object.defineProperty(ret, "name", { value: modelName });
         Object.defineProperty(ret, "load", { value: load });
+        Object.defineProperty(ret, "attr2field", { value: attr2field });
         Object.defineProperty(ret, "attributes", { value: attributes });
         Object.defineProperty(ret, "foreignKeys", { value: foreignKeys });
-        Object.defineProperty(ret, "methods", { value: methods || {} });
-        if (methods)
-            Object.assign(ret.prototype, methods);
-        ret.prototype.save = function () {
-            return Promise.resolve(false);
+        Object.defineProperty(ret, "methods", { value: methods });
+        Object.assign(ret.prototype, methods);
+        const save = this.db.save(tableName, attr2field, pk);
+        ret.prototype.save = async function () {
+            this.preSave();
+            const ret = await save.call(this);
+            if (ret)
+                this.postSave();
+            return ret;
         };
+        Object.defineProperty(ret.prototype.save, "name", { value: modelName + ".save" });
         for (const attribute of aarray)
             Object.defineProperty(ret, attribute.attributeName, { value: attribute });
         for (const key of ["attributeName", "base", "fieldName", "modelName", "size", "tableName", "type", "unique"])
@@ -333,4 +456,3 @@ class Sedentary {
     }
 }
 exports.Sedentary = Sedentary;
-exports.Package = Sedentary;

package/package.json

@@ -1,20 +1,24 @@
 {
   "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.5",
+    "@types/node": "17.0.8",
     "@types/yamljs": "0.2.31",
-    "@typescript-eslint/eslint-plugin": "5.8.1",
-    "@typescript-eslint/parser": "5.8.1",
-    "eslint": "8.5.0",
+    "@typescript-eslint/eslint-plugin": "5.9.0",
+    "@typescript-eslint/parser": "5.9.0",
+    "eslint": "8.6.0",
     "mocha": "9.1.3",
     "nyc": "15.1.0",
     "prettier": "2.5.1",
     "ts-node": "10.4.0",
-    "tsd": "0.19.0",
+    "tsd": "0.19.1",
     "typescript": "4.5.4",
     "yamljs": "0.3.0"
   },
@@ -74,5 +78,5 @@
     }
   },
   "types": "index.d.ts",
-  "version": "0.0.20"
+  "version": "0.0.24"
 }

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,191 +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) {
-            const err = e;
-            if (err.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/lib/transaction.d.ts

@@ -1,2 +0,0 @@
-export declare class Transaction {
-}

package/lib/transaction.js

@@ -1,6 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Transaction = void 0;
-class Transaction {
-}
-exports.Transaction = Transaction;

package/requirements.txt

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

package/utils.d.ts

@@ -1 +0,0 @@
-export {};

package/utils.js

@@ -1,130 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const yamljs_1 = __importDefault(require("yamljs"));
-const fs_1 = require("fs");
-const { readFile, writeFile } = fs_1.promises;
-const { VERSION, npm_package_name } = process.env;
-const common = ["*.tgz", "coverage", "node_modules", "test.json", ""];
-const git = [".gitignore", ".npmignore", ".nyc_output", "docs/build", "docs/__pycache__", "index.d.ts", "index.js", "lib/*.d.ts", "lib/*.js"];
-const npm = [".*", "Makefile", "docs", "index.ts", "lib/db.ts", "lib/minidb.ts", "lib/transaction.ts", "sedentary-*", "test", "tsconfig.json", "utils.ts"];
-const descriptions = { sedentary: "", "sedentary-mysql": " - MySQL", "sedentary-pg": " - PostgreSQL", "sedentary-sqlite": " - SQLite" };
-const urls = { sedentary: "", "sedentary-mysql": "-mysql", "sedentary-pg": "-pg", "sedentary-sqlite": "-sqlite" };
-const deps = { sedentary: {}, "sedentary-mysql": {}, "sedentary-pg": { pg: "8.7.1", "pg-format": "1.0.4" }, "sedentary-sqlite": {} };
-const devd = { sedentary: {}, "sedentary-mysql": {}, "sedentary-pg": { "@types/pg": "8.6.3", "@types/pg-format": "1.0.2" }, "sedentary-sqlite": {} };
-const packagejson = {
-    author: "Daniele Ricci <daniele.icc@gmail.com> (https://github.com/iccicci)",
-    dependencies: {},
-    devDependencies: {
-        "@types/mocha": "9.0.0",
-        "@types/node": "17.0.5",
-        "@types/yamljs": "0.2.31",
-        "@typescript-eslint/eslint-plugin": "5.8.1",
-        "@typescript-eslint/parser": "5.8.1",
-        eslint: "8.5.0",
-        mocha: "9.1.3",
-        prettier: "2.5.1",
-        nyc: "15.1.0",
-        "ts-node": "10.4.0",
-        tsd: "0.19.0",
-        typescript: "4.5.4",
-        yamljs: "0.3.0"
-    },
-    engines: { node: ">=12.0" },
-    funding: { url: "https://blockchain.info/address/1Md9WFAHrXTb3yPBwQWmUfv2RmzrtbHioB" },
-    keywords: ["DB", "ORM", "database", "migration", "mysql", "postgresql", "sqlite"],
-    license: "MIT",
-    prettier: {
-        arrowParens: "avoid",
-        endOfLine: "lf",
-        jsxBracketSameLine: true,
-        printWidth: 200,
-        trailingComma: "none",
-        useTabs: false
-    },
-    readmeFilename: "README.md",
-    scripts: {
-        coverage: "nyc -r lcov -r text -r text-summary -r html mocha -r ts-node/register test/*ts",
-        gitignore: "node -r ts-node/register utils.ts gitignore",
-        npmignore: "node -r ts-node/register utils.ts npmignore",
-        packagejson: "node -r ts-node/register utils.ts packagejson",
-        test: "mocha -r ts-node/register test/*ts",
-        travis: "node -r ts-node/register utils.ts travis",
-        tsc: "tsc --declaration",
-        version: "node -r ts-node/register utils.ts version"
-    },
-    tsd: { compilerOptions: {} },
-    types: "index.d.ts"
-};
-const before_script_common = [
-    "curl -L https://codeclimate.com/downloads/test-reporter/test-reporter-latest-linux-amd64 > ./cc-test-reporter",
-    "chmod +x ./cc-test-reporter",
-    "./cc-test-reporter before-build"
-];
-const conditions = { sedentary: "", "sedentary-pg": "&& $PG_VERSION == 14 " };
-const travis = {
-    common: {
-        after_script: [`if [[ \`node --version\` =~ ^v16 ${conditions[npm_package_name]}]] ; then ./cc-test-reporter after-build --exit-code $TRAVIS_TEST_RESULT ; fi`],
-        before_script: before_script_common,
-        language: "node_js",
-        node_js: ["16", "14", "12"],
-        script: "npm run coverage",
-        sudo: "required"
-    },
-    sedentary: { env: { global: ["CC_TEST_REPORTER_ID=1aa1f737e7bf7d2859a2c7d9a0d9634a0d9aa89e3a19476d576faa7d02a1d46f"] } },
-    "sedentary-pg": {
-        before_install: ["sudo service postgresql stop", "sudo service postgresql restart $PG_VERSION"],
-        before_script: [
-            ...before_script_common,
-            'psql -c "CREATE DATABASE sedentary;" -U postgres',
-            "psql -c \"ALTER DATABASE sedentary SET timezone TO 'GMT';\" -U postgres",
-            'export SPG=\'{"database":"sedentary","password":"postgres","user":"postgres"}\''
-        ],
-        env: {
-            global: ["CC_TEST_REPORTER_ID=c7519657dfea145349c1b7a98f7134f033c25f598b40ad5b077744eb4beb7c66"],
-            matrix: ["PG_VERSION=14", "PG_VERSION=13", "PG_VERSION=12", "PG_VERSION=11", "PG_VERSION=10"]
-        }
-    }
-};
-function sort(obj) {
-    const ret = {};
-    if (obj instanceof Array || !(obj instanceof Object))
-        return obj;
-    Object.entries(obj)
-        .sort(([a], [b]) => (a < b ? -1 : 1))
-        .forEach(([k, v]) => (ret[k] = sort(v)));
-    return ret;
-}
-(async function () {
-    if (process.argv[2] === "gitignore")
-        writeFile(".gitignore", [...git, ...common].join("\n"), "utf-8");
-    if (process.argv[2] === "npmignore")
-        writeFile(".npmignore", [...npm, ...common].join("\n"), "utf-8");
-    if (process.argv[2] === "travis")
-        writeFile(".travis.yml", yamljs_1.default.stringify(sort(Object.assign(Object.assign({}, travis.common), travis[npm_package_name])), 4, 2), "utf-8");
-    if (process.argv[2] === "packagejson") {
-        const bugs = `https://github.com/iccicci/sedentary${urls[npm_package_name]}/issues`;
-        const description = "The ORM which never needs to migrate" + descriptions[npm_package_name];
-        const homepage = `https://github.com/iccicci/sedentary${urls[npm_package_name]}#readme`;
-        const repository = `https://github.com/iccicci/sedentary${urls[npm_package_name]}`;
-        const pkg = JSON.parse(await readFile("package.json", "utf-8"));
-        const { compilerOptions } = JSON.parse(await readFile("tsconfig.json", "utf-8"));
-        const { name, version } = pkg;
-        const tsd = { compilerOptions };
-        let { dependencies, devDependencies } = pkg;
-        try {
-            const { version } = JSON.parse(await readFile("../package.json", "utf-8"));
-            dependencies = Object.assign(Object.assign({}, deps[npm_package_name]), { sedentary: version });
-            devDependencies = Object.assign(Object.assign({}, devDependencies), devd[npm_package_name]);
-        }
-        catch (e) { }
-        await writeFile("package.json", JSON.stringify(sort(Object.assign(Object.assign({}, packagejson), { bugs, dependencies, devDependencies, description, homepage, name, repository, tsd, version })), null, 2), "utf-8");
-    }
-    if (process.argv[2] === "version") {
-        const pkg = JSON.parse(await readFile("package.json", "utf-8"));
-        pkg.version = VERSION;
-        await writeFile("package.json", JSON.stringify(pkg, null, 2), "utf-8");
-    }
-})();