sedentary 0.0.29 → 0.0.32

package/README.md

@@ -97,8 +97,8 @@ The full documentation is on [sedentary.readthedocs.io](https://sedentary.readth
 
 Requires:
 
-- Node.js: **v12**
-- TypeScript: **v4.1** (or none if used in a JavaScript project).
+- Node.js: **v14**
+- TypeScript: **v4.6** (or none if used in a JavaScript project).
 
 The package is tested under [all Node.js versions](https://app.travis-ci.com/github/iccicci/sedentary)
 currently supported accordingly to [Node.js Release](https://github.com/nodejs/Release#readme).

package/dist/cjs/db.js

@@ -13,9 +13,14 @@ class EntryBase {
     }
     construct() { }
     postLoad() { }
+    postRemove() { }
     postSave() { }
     preLoad() { }
+    preRemove() { }
     preSave() { }
+    async remove() {
+        return false;
+    }
     async save() {
         return false;
     }
@@ -86,16 +91,18 @@ class DB {
 }
 exports.DB = DB;
 class Transaction {
-    constructor() {
+    constructor(log) {
         this.entries = [];
+        this.log = log;
     }
     addEntry(entry) {
+        Object.defineProperty(entry, "tx", { configurable: true, value: this });
         this.entries.push(entry);
     }
     clean() {
         const { entries } = this;
         for (const entry of entries)
-            delete entry.tx;
+            Object.defineProperty(entry, "tx", { configurable: true, value: null });
         this.entries = [];
     }
     async commit() {

package/dist/cjs/index.js

@@ -419,19 +419,26 @@ class Sedentary {
         };
         checkParent(parent);
         const ret = class extends (parent || db_1.EntryBase) {
+            constructor(from, tx) {
+                super(from);
+                if (tx)
+                    tx.addEntry(this);
+            }
         };
         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) => {
+        const load = async (where, order, tx, lock) => {
             if (order instanceof db_1.Transaction) {
+                if (typeof tx === "boolean" && tx)
+                    lock = true;
                 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);
+            const ret = await load_(str, order, tx, lock);
             return ret;
         };
         Object.defineProperty(load, "name", { value: modelName + ".load" });
@@ -442,6 +449,17 @@ class Sedentary {
         Object.defineProperty(ret, "foreignKeys", { value: foreignKeys });
         Object.defineProperty(ret, "methods", { value: methods });
         Object.assign(ret.prototype, methods);
+        const remove = this.db.remove(tableName, pk);
+        ret.prototype.remove = async function () {
+            if (!this.loaded)
+                throw new Error(`${modelName}.remove: Can't remove a never saved Entry`);
+            this.preRemove();
+            const ret = await remove.call(this);
+            if (ret)
+                this.postRemove();
+            return ret;
+        };
+        Object.defineProperty(ret.prototype.remove, "name", { value: modelName + ".remove" });
         const save = this.db.save(tableName, attr2field, pk);
         ret.prototype.save = async function () {
             this.preSave();

package/dist/es/db.js

@@ -10,9 +10,14 @@ export class EntryBase {
     }
     construct() { }
     postLoad() { }
+    postRemove() { }
     postSave() { }
     preLoad() { }
+    preRemove() { }
     preSave() { }
+    async remove() {
+        return false;
+    }
     async save() {
         return false;
     }
@@ -82,13 +87,18 @@ export class DB {
 }
 export class Transaction {
     entries = [];
+    log;
+    constructor(log) {
+        this.log = log;
+    }
     addEntry(entry) {
+        Object.defineProperty(entry, "tx", { configurable: true, value: this });
         this.entries.push(entry);
     }
     clean() {
         const { entries } = this;
         for (const entry of entries)
-            delete entry.tx;
+            Object.defineProperty(entry, "tx", { configurable: true, value: null });
         this.entries = [];
     }
     async commit() {

package/dist/es/index.js

@@ -413,19 +413,26 @@ export class Sedentary {
         };
         checkParent(parent);
         const ret = class extends (parent || EntryBase) {
+            constructor(from, tx) {
+                super(from);
+                if (tx)
+                    tx.addEntry(this);
+            }
         };
         const table = new 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) => {
+        const load = async (where, order, tx, lock) => {
             if (order instanceof Transaction) {
+                if (typeof tx === "boolean" && tx)
+                    lock = true;
                 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);
+            const ret = await load_(str, order, tx, lock);
             return ret;
         };
         Object.defineProperty(load, "name", { value: modelName + ".load" });
@@ -436,6 +443,17 @@ export class Sedentary {
         Object.defineProperty(ret, "foreignKeys", { value: foreignKeys });
         Object.defineProperty(ret, "methods", { value: methods });
         Object.assign(ret.prototype, methods);
+        const remove = this.db.remove(tableName, pk);
+        ret.prototype.remove = async function () {
+            if (!this.loaded)
+                throw new Error(`${modelName}.remove: Can't remove a never saved Entry`);
+            this.preRemove();
+            const ret = await remove.call(this);
+            if (ret)
+                this.postRemove();
+            return ret;
+        };
+        Object.defineProperty(ret.prototype.remove, "name", { value: modelName + ".remove" });
         const save = this.db.save(tableName, attr2field, pk);
         ret.prototype.save = async function () {
             this.preSave();

package/dist/types/db.d.ts

@@ -3,9 +3,12 @@ export declare class EntryBase {
     constructor(from?: Partial<EntryBase>);
     construct(): void;
     postLoad(): void;
+    postRemove(): void;
     postSave(): void;
     preLoad(): void;
+    preRemove(): void;
     preSave(): void;
+    remove(): Promise<boolean>;
     save(): Promise<boolean>;
 }
 export declare type ForeignKeyActions = "cascade" | "no action" | "restrict" | "set default" | "set null";
@@ -84,7 +87,8 @@ export declare abstract class DB<T extends Transaction> {
     protected syncLog(message: string): void;
     abstract begin(): Promise<T>;
     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 load(tableName: string, attributes: Record<string, string>, pk: Attribute<Natural, unknown>, model: new () => EntryBase, table: Table): (where: string, order?: string[], tx?: Transaction, lock?: boolean) => Promise<EntryBase[]>;
+    abstract remove(tableName: string, pk: Attribute<Natural, unknown>): (this: EntryBase & Record<string, Natural>) => Promise<boolean>;
     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>;
@@ -97,6 +101,8 @@ export declare abstract class DB<T extends Transaction> {
 }
 export declare class Transaction {
     private entries;
+    protected log: (message: string) => void;
+    constructor(log: (message: string) => void);
     addEntry(entry: EntryBase): void;
     clean(): void;
     commit(): Promise<void>;

package/dist/types/index.d.ts

@@ -62,12 +62,12 @@ 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>;
 }>;
-interface ModelLoad<A extends AttributesDefinition, E extends EntryBase> {
+export 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[]>;
+    load(where: Condition<A>, order?: Order<A>, tx?: Transaction, lock?: boolean): Promise<E[]>;
+    load(where: Condition<A>, tx: Transaction, lock?: boolean): 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> & {
+declare type ModelBase<N extends Natural, A extends AttributesDefinition, EA extends Record<string, Natural | undefined>, EM extends EntryBase, E extends EntryBase> = (new (from?: EA, tx?: Transaction) => E) & Attribute<N, E> & {
     foreignKeys: Record<string, boolean>;
     methods: EM;
     parent?: ModelStd;
@@ -100,7 +100,7 @@ export declare class Sedentary<D extends DB<T>, T extends Transaction> {
     protected autoSync: boolean;
     protected db: D;
     protected doSync: boolean;
-    protected log: (...data: unknown[]) => void;
+    protected log: (message: string) => void;
     private models;
     constructor(options?: SedentaryOptions);
     DATETIME(): Type<Date, unknown>;

package/package.json

@@ -9,21 +9,21 @@
   "description": "The ORM which never needs to migrate",
   "devDependencies": {
     "@types/mocha": "9.1.0",
-    "@types/node": "17.0.19",
+    "@types/node": "17.0.23",
     "@types/yamljs": "0.2.31",
-    "@typescript-eslint/eslint-plugin": "5.12.1",
-    "@typescript-eslint/parser": "5.12.1",
-    "eslint": "8.9.0",
-    "mocha": "9.2.1",
+    "@typescript-eslint/eslint-plugin": "5.17.0",
+    "@typescript-eslint/parser": "5.17.0",
+    "eslint": "8.12.0",
+    "mocha": "9.2.2",
     "nyc": "15.1.0",
-    "prettier": "2.5.1",
-    "ts-node": "10.5.0",
+    "prettier": "2.6.1",
+    "ts-node": "10.7.0",
     "tsd": "0.19.1",
-    "typescript": "4.5.5",
+    "typescript": "4.6.3",
     "yamljs": "0.3.0"
   },
   "engines": {
-    "node": ">=12.0"
+    "node": ">=14.0"
   },
   "funding": {
     "url": "https://blockchain.info/address/1Md9WFAHrXTb3yPBwQWmUfv2RmzrtbHioB"
@@ -79,5 +79,5 @@
     }
   },
   "types": "./dist/types/index.d.ts",
-  "version": "0.0.29"
+  "version": "0.0.32"
 }