sedentary 0.0.46 → 0.0.49

package/dist/cjs/db.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Transaction = exports.DB = exports.Table = exports.Attribute = exports.Type = exports.EntryBase = exports.loaded = exports.actions = void 0;
+exports.differ = exports.Transaction = exports.DB = exports.Table = exports.Attribute = exports.Type = exports.EntryBase = exports.transaction = exports.loaded = exports.actions = void 0;
 exports.actions = Symbol("actions");
 exports.loaded = Symbol("loaded");
+exports.transaction = Symbol("transaction");
 class EntryBase {
     constructor(from) {
         if (from === "load")
@@ -104,14 +105,14 @@ class Transaction {
         this.log = log;
     }
     addEntry(entry) {
-        Object.defineProperty(entry, "tx", { configurable: true, value: this });
+        Object.defineProperty(entry, exports.transaction, { configurable: true, value: this });
         this.entries.push(entry);
     }
     clean() {
         const { entries } = this;
         for (const entry of entries) {
             Object.defineProperty(entry, exports.actions, { configurable: true, value: undefined });
-            Object.defineProperty(entry, "tx", { configurable: true, value: undefined });
+            Object.defineProperty(entry, exports.transaction, { configurable: true, value: undefined });
         }
         this.entries = [];
     }
@@ -133,3 +134,31 @@ class Transaction {
     }
 }
 exports.Transaction = Transaction;
+const sortedEntries = (obj) => Object.entries(obj).sort((entryA, entryB) => (entryA[0] > entryB[0] ? -1 : 1));
+function differ(a, b) {
+    if (typeof a !== "object")
+        return a !== b;
+    if (typeof b !== "object")
+        return true;
+    if (a === null)
+        return b !== null;
+    if (b === null)
+        return true;
+    if (a instanceof Array) {
+        if (!(b instanceof Array))
+            return true;
+        for (const [i, value] of a.entries())
+            if (differ(value, b[i]))
+                return true;
+        return false;
+    }
+    const entriesA = sortedEntries(a);
+    const entriesB = sortedEntries(b);
+    if (entriesA.length !== entriesB.length)
+        return true;
+    for (const [i, [key, value]] of entriesA.entries())
+        if (key !== entriesB[i][0] || differ(value, entriesB[i][1]))
+            return true;
+    return false;
+}
+exports.differ = differ;

package/dist/cjs/index.js

@@ -1,38 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Sedentary = exports.Type = exports.Transaction = exports.Table = exports.EntryBase = exports.DB = exports.Attribute = void 0;
+exports.Sedentary = exports.Type = exports.transaction = exports.Transaction = exports.Table = exports.loaded = exports.EntryBase = exports.differ = exports.DB = exports.Attribute = void 0;
 const db_1 = require("./db");
 var db_2 = require("./db");
 Object.defineProperty(exports, "Attribute", { enumerable: true, get: function () { return db_2.Attribute; } });
 Object.defineProperty(exports, "DB", { enumerable: true, get: function () { return db_2.DB; } });
+Object.defineProperty(exports, "differ", { enumerable: true, get: function () { return db_2.differ; } });
 Object.defineProperty(exports, "EntryBase", { enumerable: true, get: function () { return db_2.EntryBase; } });
+Object.defineProperty(exports, "loaded", { enumerable: true, get: function () { return db_2.loaded; } });
 Object.defineProperty(exports, "Table", { enumerable: true, get: function () { return db_2.Table; } });
 Object.defineProperty(exports, "Transaction", { enumerable: true, get: function () { return db_2.Transaction; } });
+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 = [
     ...["attr2field", "attributeName", "attributes", "base", "class", "construct", "constructor", "defaultValue", "entry", "fieldName", "foreignKeys", "load"],
-    ...[
-        "loaded",
-        "methods",
-        "name",
-        "postCommit",
-        "postLoad",
-        "postRemove",
-        "postSave",
-        "preCommit",
-        "preLoad",
-        "preRemove",
-        "preSave",
-        "primaryKey",
-        "prototype",
-        "save",
-        "size",
-        "tableName",
-        "tx",
-        "type"
-    ]
+    ...["methods", "name", "postCommit", "postLoad", "postRemove", "postSave", "preCommit", "preLoad", "preRemove", "preSave", "primaryKey", "prototype", "save", "size", "tableName", "type"]
 ];
 class Sedentary {
     constructor(options) {
@@ -84,6 +68,9 @@ class Sedentary {
     Number() {
         return new db_1.Type({ base: Number, type: "NUMBER" });
     }
+    None() {
+        return new db_1.Type({ base: undefined, type: "NONE" });
+    }
     VarChar(size) {
         const message = "Sedentary.VARCHAR: 'size' argument: Wrong value, expected positive integer";
         size = size ? this.checkSize(size, message) : undefined;
@@ -280,7 +267,7 @@ class Sedentary {
             const call = (defaultValue, fieldName, notNull, unique, func, message1, message2) => {
                 if (func === this.FKey)
                     throw new Error(`${message1} 'this.FKey' can't be used directly`);
-                if (![this.Boolean, this.DateTime, this.Int, this.JSON, this.Int8, this.Number, this.VarChar].includes(func))
+                if (![this.Boolean, this.DateTime, this.Int, this.JSON, this.Int8, this.None, this.Number, this.VarChar].includes(func))
                     throw new Error(`${message1} ${message2}`);
                 return new db_1.Attribute({ attributeName, defaultValue, fieldName, modelName, notNull, tableName, unique, ...func() });
             };
@@ -510,18 +497,20 @@ class Sedentary {
         Object.defineProperty(ret, "foreignKeys", { value: foreignKeys });
         Object.defineProperty(ret, "methods", { value: methods });
         Object.assign(ret.prototype, methods);
+        const ensureActions = (entry) => {
+            if (!entry[db_1.actions])
+                Object.defineProperty(entry, db_1.actions, { configurable: true, value: [] });
+            return entry[db_1.actions];
+        };
         const remove = this.db.remove(tableName, pk);
         ret.prototype.remove = async function () {
-            if (!this.loaded)
+            if (!this[db_1.loaded])
                 throw new Error(`${modelName}.remove: Can't remove a never saved Entry`);
             this.preRemove();
             const records = await remove.call(this);
             this.postRemove(records);
-            if (this.tx) {
-                if (!this[db_1.actions])
-                    Object.defineProperty(this, db_1.actions, { configurable: true, value: [] });
-                this[db_1.actions].push({ action: "remove", records });
-            }
+            if (this[db_1.transaction])
+                ensureActions(this).push({ action: "remove", records });
             return records;
         };
         Object.defineProperty(ret.prototype.remove, "name", { value: modelName + ".remove" });
@@ -530,11 +519,8 @@ class Sedentary {
             this.preSave();
             const records = await save.call(this);
             this.postSave(records);
-            if (this.tx) {
-                if (!this[db_1.actions])
-                    Object.defineProperty(this, db_1.actions, { configurable: true, value: [] });
-                this[db_1.actions].push({ action: "save", records });
-            }
+            if (this[db_1.transaction])
+                ensureActions(this).push({ action: "save", records });
             return records;
         };
         Object.defineProperty(ret.prototype.save, "name", { value: modelName + ".save" });

package/dist/es/db.js

@@ -1,5 +1,6 @@
 export const actions = Symbol("actions");
 export const loaded = Symbol("loaded");
+export const transaction = Symbol("transaction");
 export class EntryBase {
     constructor(from) {
         if (from === "load")
@@ -100,14 +101,14 @@ export class Transaction {
         this.log = log;
     }
     addEntry(entry) {
-        Object.defineProperty(entry, "tx", { configurable: true, value: this });
+        Object.defineProperty(entry, transaction, { configurable: true, value: this });
         this.entries.push(entry);
     }
     clean() {
         const { entries } = this;
         for (const entry of entries) {
             Object.defineProperty(entry, actions, { configurable: true, value: undefined });
-            Object.defineProperty(entry, "tx", { configurable: true, value: undefined });
+            Object.defineProperty(entry, transaction, { configurable: true, value: undefined });
         }
         this.entries = [];
     }
@@ -128,3 +129,30 @@ export class Transaction {
         this.clean();
     }
 }
+const sortedEntries = (obj) => Object.entries(obj).sort((entryA, entryB) => (entryA[0] > entryB[0] ? -1 : 1));
+export function differ(a, b) {
+    if (typeof a !== "object")
+        return a !== b;
+    if (typeof b !== "object")
+        return true;
+    if (a === null)
+        return b !== null;
+    if (b === null)
+        return true;
+    if (a instanceof Array) {
+        if (!(b instanceof Array))
+            return true;
+        for (const [i, value] of a.entries())
+            if (differ(value, b[i]))
+                return true;
+        return false;
+    }
+    const entriesA = sortedEntries(a);
+    const entriesB = sortedEntries(b);
+    if (entriesA.length !== entriesB.length)
+        return true;
+    for (const [i, [key, value]] of entriesA.entries())
+        if (key !== entriesB[i][0] || differ(value, entriesB[i][1]))
+            return true;
+    return false;
+}

package/dist/es/index.js

@@ -1,29 +1,10 @@
-import { actions, Attribute, EntryBase, Table, Transaction, Type } from "./db";
-export { Attribute, DB, EntryBase, Table, Transaction, Type } from "./db";
+import { actions, Attribute, EntryBase, loaded, Table, Transaction, transaction, Type } from "./db";
+export { Attribute, DB, differ, EntryBase, loaded, Table, Transaction, transaction, Type } from "./db";
 const operators = ["=", ">", "<", ">=", "<=", "<>", "IN", "IS NULL", "LIKE", "NOT"];
 const allowedOption = ["indexes", "int8id", "parent", "primaryKey", "sync", "tableName"];
 const reservedNames = [
     ...["attr2field", "attributeName", "attributes", "base", "class", "construct", "constructor", "defaultValue", "entry", "fieldName", "foreignKeys", "load"],
-    ...[
-        "loaded",
-        "methods",
-        "name",
-        "postCommit",
-        "postLoad",
-        "postRemove",
-        "postSave",
-        "preCommit",
-        "preLoad",
-        "preRemove",
-        "preSave",
-        "primaryKey",
-        "prototype",
-        "save",
-        "size",
-        "tableName",
-        "tx",
-        "type"
-    ]
+    ...["methods", "name", "postCommit", "postLoad", "postRemove", "postSave", "preCommit", "preLoad", "preRemove", "preSave", "primaryKey", "prototype", "save", "size", "tableName", "type"]
 ];
 export class Sedentary {
     autoSync;
@@ -78,6 +59,9 @@ export class Sedentary {
     Number() {
         return new Type({ base: Number, type: "NUMBER" });
     }
+    None() {
+        return new Type({ base: undefined, type: "NONE" });
+    }
     VarChar(size) {
         const message = "Sedentary.VARCHAR: 'size' argument: Wrong value, expected positive integer";
         size = size ? this.checkSize(size, message) : undefined;
@@ -274,7 +258,7 @@ export class Sedentary {
             const call = (defaultValue, fieldName, notNull, unique, func, message1, message2) => {
                 if (func === this.FKey)
                     throw new Error(`${message1} 'this.FKey' can't be used directly`);
-                if (![this.Boolean, this.DateTime, this.Int, this.JSON, this.Int8, this.Number, this.VarChar].includes(func))
+                if (![this.Boolean, this.DateTime, this.Int, this.JSON, this.Int8, this.None, this.Number, this.VarChar].includes(func))
                     throw new Error(`${message1} ${message2}`);
                 return new Attribute({ attributeName, defaultValue, fieldName, modelName, notNull, tableName, unique, ...func() });
             };
@@ -504,18 +488,20 @@ export class Sedentary {
         Object.defineProperty(ret, "foreignKeys", { value: foreignKeys });
         Object.defineProperty(ret, "methods", { value: methods });
         Object.assign(ret.prototype, methods);
+        const ensureActions = (entry) => {
+            if (!entry[actions])
+                Object.defineProperty(entry, actions, { configurable: true, value: [] });
+            return entry[actions];
+        };
         const remove = this.db.remove(tableName, pk);
         ret.prototype.remove = async function () {
-            if (!this.loaded)
+            if (!this[loaded])
                 throw new Error(`${modelName}.remove: Can't remove a never saved Entry`);
             this.preRemove();
             const records = await remove.call(this);
             this.postRemove(records);
-            if (this.tx) {
-                if (!this[actions])
-                    Object.defineProperty(this, actions, { configurable: true, value: [] });
-                this[actions].push({ action: "remove", records });
-            }
+            if (this[transaction])
+                ensureActions(this).push({ action: "remove", records });
             return records;
         };
         Object.defineProperty(ret.prototype.remove, "name", { value: modelName + ".remove" });
@@ -524,11 +510,8 @@ export class Sedentary {
             this.preSave();
             const records = await save.call(this);
             this.postSave(records);
-            if (this.tx) {
-                if (!this[actions])
-                    Object.defineProperty(this, actions, { configurable: true, value: [] });
-                this[actions].push({ action: "save", records });
-            }
+            if (this[transaction])
+                ensureActions(this).push({ action: "save", records });
             return records;
         };
         Object.defineProperty(ret.prototype.save, "name", { value: modelName + ".save" });

package/dist/types/db.d.ts

@@ -1,5 +1,6 @@
 export declare const actions: unique symbol;
 export declare const loaded: unique symbol;
+export declare const transaction: unique symbol;
 export interface Action {
     action: "remove" | "save";
     records: number | false;
@@ -117,4 +118,5 @@ export declare class Transaction {
     protected preCommit(): void;
     rollback(): Promise<void>;
 }
+export declare function differ(a: unknown, b: unknown): boolean;
 export {};

package/dist/types/index.d.ts

@@ -1,5 +1,5 @@
 import { Attribute, DB, EntryBase, ForeignKeyOptions, Transaction, Type } from "./db";
-export { Action, Attribute, DB, EntryBase, ForeignKeyActions, ForeignKeyOptions, Index, Table, Transaction, Type } from "./db";
+export { Action, Attribute, DB, differ, EntryBase, ForeignKeyActions, ForeignKeyOptions, Index, loaded, Table, Transaction, transaction, Type } from "./db";
 export declare type TypeDefinition<T, E> = (() => Type<T, E>) | Type<T, E>;
 export interface AttributeOptions<T, E> {
     defaultValue?: T;
@@ -120,6 +120,7 @@ export declare class Sedentary<D extends DB<T>, T extends Transaction> {
     Int8(): Type<bigint, unknown>;
     JSON<T>(): Type<T, unknown>;
     Number(): Type<number, unknown>;
+    None<T>(): Type<T, unknown>;
     VarChar<S extends string>(size?: number): Type<S, unknown>;
     private checkDB;
     private checkOrderBy;

package/package.json

@@ -58,5 +58,5 @@
     }
   },
   "types": "./dist/types/index.d.ts",
-  "version": "0.0.46"
+  "version": "0.0.49"
 }