sedentary 0.0.49 → 0.0.50

package/dist/cjs/db.js

@@ -1,8 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.differ = exports.Transaction = exports.DB = exports.Table = exports.Attribute = exports.Type = exports.EntryBase = exports.transaction = exports.loaded = exports.actions = void 0;
+exports.differ = exports.Transaction = exports.DB = exports.Table = exports.Attribute = exports.Type = exports.EntryBase = exports.transaction = exports.size = exports.loaded = exports.base = exports.actions = void 0;
 exports.actions = Symbol("actions");
+exports.base = Symbol("base");
 exports.loaded = Symbol("loaded");
+exports.size = Symbol("size");
 exports.transaction = Symbol("transaction");
 class EntryBase {
     constructor(from) {

package/dist/cjs/index.js

@@ -1,22 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Sedentary = exports.Type = exports.transaction = exports.Transaction = exports.Table = exports.loaded = exports.EntryBase = exports.differ = exports.DB = exports.Attribute = void 0;
+exports.Sedentary = exports.Type = exports.transaction = exports.Transaction = exports.Table = exports.size = exports.loaded = exports.EntryBase = exports.differ = exports.DB = exports.base = 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, "base", { enumerable: true, get: function () { return db_2.base; } });
 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, "size", { enumerable: true, get: function () { return db_2.size; } });
 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 attributes = Symbol("attributes");
+const methods = Symbol("methods");
 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"],
-    ...["methods", "name", "postCommit", "postLoad", "postRemove", "postSave", "preCommit", "preLoad", "preRemove", "preSave", "primaryKey", "prototype", "save", "size", "tableName", "type"]
+    ...["attr2field", "attributeName", "cancel", "class", "construct", "constructor", "defaultValue", "fieldName", "foreignKeys", "load", "name"],
+    ...["postCommit", "postLoad", "postRemove", "postSave", "preCommit", "preLoad", "preRemove", "preSave", "primaryKey", "prototype", "save", "tableName", "type"]
 ];
 class Sedentary {
     constructor(options) {
@@ -43,38 +47,38 @@ class Sedentary {
         this.doSync = sync;
     }
     Boolean() {
-        return new db_1.Type({ base: Boolean, type: "BOOLEAN" });
+        return new db_1.Type({ [db_1.base]: Boolean, type: "BOOLEAN" });
     }
     DateTime() {
-        return new db_1.Type({ base: Date, type: "DATETIME" });
+        return new db_1.Type({ [db_1.base]: Date, type: "DATETIME" });
     }
     FKey(attribute, options) {
-        const { attributeName, base, fieldName, size, tableName, type } = attribute;
-        return new db_1.Type({ base, foreignKey: { attributeName, fieldName, options, tableName }, size, type });
+        const { attributeName, fieldName, tableName, type, [db_1.base]: _base, [db_1.size]: _size } = attribute;
+        return new db_1.Type({ [db_1.base]: _base, foreignKey: { attributeName, fieldName, options, tableName }, [db_1.size]: _size, type });
     }
-    Int(size) {
+    Int(_size) {
         const message = "Sedentary.INT: 'size' argument: Wrong value, expected 2 or 4";
-        size = size ? this.checkSize(size, message) : 4;
-        if (size !== 2 && size !== 4)
+        _size = _size ? this.checkSize(_size, message) : 4;
+        if (_size !== 2 && _size !== 4)
             throw new Error(message);
-        return new db_1.Type({ base: Number, size, type: "INT" });
+        return new db_1.Type({ [db_1.base]: Number, [db_1.size]: _size, type: "INT" });
     }
     Int8() {
-        return new db_1.Type({ base: BigInt, size: 8, type: "INT8" });
+        return new db_1.Type({ [db_1.base]: BigInt, [db_1.size]: 8, type: "INT8" });
     }
     JSON() {
-        return new db_1.Type({ base: Object, type: "JSON" });
+        return new db_1.Type({ [db_1.base]: Object, type: "JSON" });
     }
     Number() {
-        return new db_1.Type({ base: Number, type: "NUMBER" });
+        return new db_1.Type({ [db_1.base]: Number, type: "NUMBER" });
     }
     None() {
-        return new db_1.Type({ base: undefined, type: "NONE" });
+        return new db_1.Type({ [db_1.base]: undefined, type: "NONE" });
     }
-    VarChar(size) {
+    VarChar(_size) {
         const message = "Sedentary.VARCHAR: 'size' argument: Wrong value, expected positive integer";
-        size = size ? this.checkSize(size, message) : undefined;
-        return new db_1.Type({ base: String, size, type: "VARCHAR" });
+        _size = _size ? this.checkSize(_size, message) : undefined;
+        return new db_1.Type({ [db_1.base]: String, [db_1.size]: _size, type: "VARCHAR" });
     }
     checkDB() {
         if (!this.db)
@@ -211,15 +215,15 @@ class Sedentary {
         return this.db.escape(value);
     }
     /* eslint-enable @typescript-eslint/no-explicit-any */
-    model(modelName, attributes, options, methods) {
+    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])
             throw new Error(`Sedentary.model: '${modelName}' model: Model already defined`);
-        if (!attributes)
-            attributes = {};
-        if (!(attributes instanceof Object))
+        if (!_attributes)
+            _attributes = {};
+        if (!(_attributes instanceof Object))
             throw new Error(`Sedentary.model: '${modelName}' model: 'attributes' argument: Wrong type, expected 'Object'`);
         if (!options)
             options = {};
@@ -243,16 +247,16 @@ class Sedentary {
         const iArray = [];
         let pk = aArray[0];
         let attr2field = { id: "id" };
-        if (!methods)
-            methods = {};
-        if (!(methods instanceof Object))
+        if (!_methods)
+            _methods = {};
+        if (!(_methods instanceof Object))
             throw new Error(`Sedentary.model: '${modelName}' model: 'methods' option: Wrong type, expected 'Object'`);
         if (parent)
-            if (!parent.attributes)
+            if (!parent[attributes])
                 throw new Error(`Sedentary.model: '${modelName}' model: 'parent' option: Wrong type, expected 'Model'`);
         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))
+        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
@@ -261,7 +265,7 @@ class Sedentary {
             aArray = [];
             constraints = [];
         }
-        for (const attributeName of Object.keys(attributes).sort()) {
+        for (const attributeName of Object.keys(_attributes).sort()) {
             if (reservedNames.includes(attributeName))
                 throw new Error(`Sedentary.model: '${modelName}' model: '${attributeName}' attribute: Reserved name`);
             const call = (defaultValue, fieldName, notNull, unique, func, message1, message2) => {
@@ -271,8 +275,8 @@ class Sedentary {
                     throw new Error(`${message1} ${message2}`);
                 return new db_1.Attribute({ attributeName, defaultValue, fieldName, modelName, notNull, tableName, unique, ...func() });
             };
-            const attributeDefinition = attributes[attributeName];
-            let { base, defaultValue, fieldName, foreignKey, notNull, size, type, unique } = (() => {
+            const attributeDefinition = _attributes[attributeName];
+            let { [db_1.base]: _base, defaultValue, fieldName, foreignKey, notNull, [db_1.size]: _size, type, unique } = (() => {
                 const ret = (() => {
                     if (attributeDefinition instanceof db_1.Type)
                         return new db_1.Attribute({ attributeName, fieldName: attributeName, modelName, notNull: false, tableName, ...attributeDefinition });
@@ -298,15 +302,15 @@ class Sedentary {
                         return call(defaultValue, fieldName, notNull, unique, type, `Sedentary.model: '${modelName}' model: '${attributeName}' attribute: 'type' option:`, "Wrong type, expected 'Type'");
                     throw new Error(`Sedentary.model: '${modelName}' model: '${attributeName}' attribute: 'type' option: Wrong type, expected 'Type'`);
                 })();
-                const { base, defaultValue } = ret;
+                const { [db_1.base]: _base, defaultValue } = ret;
                 if (defaultValue !== undefined) {
-                    if (base === BigInt && typeof defaultValue !== "bigint")
+                    if (_base === BigInt && typeof defaultValue !== "bigint")
                         throw new Error(`Sedentary.model: '${modelName}' model: '${attributeName}' attribute: 'defaultValue' option: Wrong type, expected 'BigInt'`);
-                    if (base === Date && !(defaultValue instanceof Date))
+                    if (_base === Date && !(defaultValue instanceof Date))
                         throw new Error(`Sedentary.model: '${modelName}' model: '${attributeName}' attribute: 'defaultValue' option: Wrong type, expected 'Date'`);
-                    if (base === Number && typeof defaultValue !== "number")
+                    if (_base === Number && typeof defaultValue !== "number")
                         throw new Error(`Sedentary.model: '${modelName}' model: '${attributeName}' attribute: 'defaultValue' option: Wrong type, expected 'number'`);
-                    if (base === String && typeof defaultValue !== "string")
+                    if (_base === String && typeof defaultValue !== "string")
                         throw new Error(`Sedentary.model: '${modelName}' model: '${attributeName}' attribute: 'defaultValue' option: Wrong type, expected 'string'`);
                 }
                 return ret;
@@ -334,18 +338,19 @@ class Sedentary {
             }
             if (defaultValue)
                 notNull = true;
-            const attribute = new db_1.Attribute({ attributeName, base, defaultValue, fieldName, foreignKey, modelName, notNull, size, tableName, type, unique });
+            const attribute = new db_1.Attribute({ attributeName, [db_1.base]: _base, defaultValue, fieldName, foreignKey, modelName, notNull, [db_1.size]: _size, tableName, type, unique });
             if (primaryKey === attributeName)
                 pk = attribute;
             aArray.push(attribute);
-            attr2field[attributeName] = fieldName;
+            if (type !== "NONE")
+                attr2field[attributeName] = fieldName;
             if (foreignKey)
                 constraints.push({ attribute, constraintName: `fkey_${fieldName}_${foreignKey.tableName}_${foreignKey.fieldName}`, type: "f" });
             if (unique)
                 constraints.push({ attribute, constraintName: `${tableName}_${fieldName}_unique`, type: "u" });
         }
         if (indexes) {
-            const originalAttributes = attributes;
+            const originalAttributes = _attributes;
             if (!(indexes instanceof Object))
                 throw new Error(`Sedentary.model: '${modelName}' model: 'indexes' option: Wrong type, expected 'Object'`);
             for (const indexName in indexes) {
@@ -404,34 +409,34 @@ class Sedentary {
             return ret;
         }, {});
         for (const foreignKey in foreignKeys) {
-            if (foreignKey + "Load" in attributes)
+            if (foreignKey + "Load" in _attributes)
                 throw new Error(`Sedentary.model: '${modelName}' model: '${foreignKey}' attribute: '${foreignKey}Load' inferred methods conflicts with an attribute`);
-            if (foreignKey + "Load" in methods)
+            if (foreignKey + "Load" in _methods)
                 throw new Error(`Sedentary.model: '${modelName}' model: '${foreignKey}' attribute: '${foreignKey}Load' inferred methods conflicts with a method`);
         }
-        for (const method in methods)
-            if (method in attributes)
+        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 attributes) {
-                if (attribute in parent.attributes)
+            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 (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 foreignKeys) {
-                if (foreignKey + "Load" in parent.attributes)
+                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 (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`);
             }
-            for (const method in methods) {
-                if (method in parent.attributes)
+            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)
@@ -493,10 +498,10 @@ class Sedentary {
         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, attributes, { value: _attributes });
         Object.defineProperty(ret, "foreignKeys", { value: foreignKeys });
-        Object.defineProperty(ret, "methods", { value: methods });
-        Object.assign(ret.prototype, methods);
+        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: [] });
@@ -526,7 +531,7 @@ class Sedentary {
         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"])
+        for (const key of ["attributeName", db_1.base, "fieldName", "modelName", db_1.size, "tableName", "type", "unique"])
             Object.defineProperty(ret, key, { value: pk[key] });
         return ret;
     }

package/dist/es/db.js

@@ -1,5 +1,7 @@
 export const actions = Symbol("actions");
+export const base = Symbol("base");
 export const loaded = Symbol("loaded");
+export const size = Symbol("size");
 export const transaction = Symbol("transaction");
 export class EntryBase {
     constructor(from) {

package/dist/es/index.js

@@ -1,10 +1,12 @@
-import { actions, Attribute, EntryBase, loaded, Table, Transaction, transaction, Type } from "./db";
-export { Attribute, DB, differ, EntryBase, loaded, Table, Transaction, transaction, Type } from "./db";
+import { actions, Attribute, base, EntryBase, loaded, size, Table, Transaction, transaction, Type } from "./db";
+export { Attribute, base, DB, differ, EntryBase, loaded, size, Table, Transaction, transaction, Type } from "./db";
+const attributes = Symbol("attributes");
+const methods = Symbol("methods");
 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"],
-    ...["methods", "name", "postCommit", "postLoad", "postRemove", "postSave", "preCommit", "preLoad", "preRemove", "preSave", "primaryKey", "prototype", "save", "size", "tableName", "type"]
+    ...["attr2field", "attributeName", "cancel", "class", "construct", "constructor", "defaultValue", "fieldName", "foreignKeys", "load", "name"],
+    ...["postCommit", "postLoad", "postRemove", "postSave", "preCommit", "preLoad", "preRemove", "preSave", "primaryKey", "prototype", "save", "tableName", "type"]
 ];
 export class Sedentary {
     autoSync;
@@ -34,38 +36,38 @@ export class Sedentary {
         this.doSync = sync;
     }
     Boolean() {
-        return new Type({ base: Boolean, type: "BOOLEAN" });
+        return new Type({ [base]: Boolean, type: "BOOLEAN" });
     }
     DateTime() {
-        return new Type({ base: Date, type: "DATETIME" });
+        return new Type({ [base]: Date, type: "DATETIME" });
     }
     FKey(attribute, options) {
-        const { attributeName, base, fieldName, size, tableName, type } = attribute;
-        return new Type({ base, foreignKey: { attributeName, fieldName, options, tableName }, size, type });
+        const { attributeName, fieldName, tableName, type, [base]: _base, [size]: _size } = attribute;
+        return new Type({ [base]: _base, foreignKey: { attributeName, fieldName, options, tableName }, [size]: _size, type });
     }
-    Int(size) {
+    Int(_size) {
         const message = "Sedentary.INT: 'size' argument: Wrong value, expected 2 or 4";
-        size = size ? this.checkSize(size, message) : 4;
-        if (size !== 2 && size !== 4)
+        _size = _size ? this.checkSize(_size, message) : 4;
+        if (_size !== 2 && _size !== 4)
             throw new Error(message);
-        return new Type({ base: Number, size, type: "INT" });
+        return new Type({ [base]: Number, [size]: _size, type: "INT" });
     }
     Int8() {
-        return new Type({ base: BigInt, size: 8, type: "INT8" });
+        return new Type({ [base]: BigInt, [size]: 8, type: "INT8" });
     }
     JSON() {
-        return new Type({ base: Object, type: "JSON" });
+        return new Type({ [base]: Object, type: "JSON" });
     }
     Number() {
-        return new Type({ base: Number, type: "NUMBER" });
+        return new Type({ [base]: Number, type: "NUMBER" });
     }
     None() {
-        return new Type({ base: undefined, type: "NONE" });
+        return new Type({ [base]: undefined, type: "NONE" });
     }
-    VarChar(size) {
+    VarChar(_size) {
         const message = "Sedentary.VARCHAR: 'size' argument: Wrong value, expected positive integer";
-        size = size ? this.checkSize(size, message) : undefined;
-        return new Type({ base: String, size, type: "VARCHAR" });
+        _size = _size ? this.checkSize(_size, message) : undefined;
+        return new Type({ [base]: String, [size]: _size, type: "VARCHAR" });
     }
     checkDB() {
         if (!this.db)
@@ -202,15 +204,15 @@ export class Sedentary {
         return this.db.escape(value);
     }
     /* eslint-enable @typescript-eslint/no-explicit-any */
-    model(modelName, attributes, options, methods) {
+    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])
             throw new Error(`Sedentary.model: '${modelName}' model: Model already defined`);
-        if (!attributes)
-            attributes = {};
-        if (!(attributes instanceof Object))
+        if (!_attributes)
+            _attributes = {};
+        if (!(_attributes instanceof Object))
             throw new Error(`Sedentary.model: '${modelName}' model: 'attributes' argument: Wrong type, expected 'Object'`);
         if (!options)
             options = {};
@@ -234,16 +236,16 @@ export class Sedentary {
         const iArray = [];
         let pk = aArray[0];
         let attr2field = { id: "id" };
-        if (!methods)
-            methods = {};
-        if (!(methods instanceof Object))
+        if (!_methods)
+            _methods = {};
+        if (!(_methods instanceof Object))
             throw new Error(`Sedentary.model: '${modelName}' model: 'methods' option: Wrong type, expected 'Object'`);
         if (parent)
-            if (!parent.attributes)
+            if (!parent[attributes])
                 throw new Error(`Sedentary.model: '${modelName}' model: 'parent' option: Wrong type, expected 'Model'`);
         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))
+        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
@@ -252,7 +254,7 @@ export class Sedentary {
             aArray = [];
             constraints = [];
         }
-        for (const attributeName of Object.keys(attributes).sort()) {
+        for (const attributeName of Object.keys(_attributes).sort()) {
             if (reservedNames.includes(attributeName))
                 throw new Error(`Sedentary.model: '${modelName}' model: '${attributeName}' attribute: Reserved name`);
             const call = (defaultValue, fieldName, notNull, unique, func, message1, message2) => {
@@ -262,8 +264,8 @@ export class Sedentary {
                     throw new Error(`${message1} ${message2}`);
                 return new Attribute({ attributeName, defaultValue, fieldName, modelName, notNull, tableName, unique, ...func() });
             };
-            const attributeDefinition = attributes[attributeName];
-            let { base, defaultValue, fieldName, foreignKey, notNull, size, type, unique } = (() => {
+            const attributeDefinition = _attributes[attributeName];
+            let { [base]: _base, defaultValue, fieldName, foreignKey, notNull, [size]: _size, type, unique } = (() => {
                 const ret = (() => {
                     if (attributeDefinition instanceof Type)
                         return new Attribute({ attributeName, fieldName: attributeName, modelName, notNull: false, tableName, ...attributeDefinition });
@@ -289,15 +291,15 @@ export class Sedentary {
                         return call(defaultValue, fieldName, notNull, unique, type, `Sedentary.model: '${modelName}' model: '${attributeName}' attribute: 'type' option:`, "Wrong type, expected 'Type'");
                     throw new Error(`Sedentary.model: '${modelName}' model: '${attributeName}' attribute: 'type' option: Wrong type, expected 'Type'`);
                 })();
-                const { base, defaultValue } = ret;
+                const { [base]: _base, defaultValue } = ret;
                 if (defaultValue !== undefined) {
-                    if (base === BigInt && typeof defaultValue !== "bigint")
+                    if (_base === BigInt && typeof defaultValue !== "bigint")
                         throw new Error(`Sedentary.model: '${modelName}' model: '${attributeName}' attribute: 'defaultValue' option: Wrong type, expected 'BigInt'`);
-                    if (base === Date && !(defaultValue instanceof Date))
+                    if (_base === Date && !(defaultValue instanceof Date))
                         throw new Error(`Sedentary.model: '${modelName}' model: '${attributeName}' attribute: 'defaultValue' option: Wrong type, expected 'Date'`);
-                    if (base === Number && typeof defaultValue !== "number")
+                    if (_base === Number && typeof defaultValue !== "number")
                         throw new Error(`Sedentary.model: '${modelName}' model: '${attributeName}' attribute: 'defaultValue' option: Wrong type, expected 'number'`);
-                    if (base === String && typeof defaultValue !== "string")
+                    if (_base === String && typeof defaultValue !== "string")
                         throw new Error(`Sedentary.model: '${modelName}' model: '${attributeName}' attribute: 'defaultValue' option: Wrong type, expected 'string'`);
                 }
                 return ret;
@@ -325,18 +327,19 @@ export class Sedentary {
             }
             if (defaultValue)
                 notNull = true;
-            const attribute = new Attribute({ attributeName, base, defaultValue, fieldName, foreignKey, modelName, notNull, size, tableName, type, unique });
+            const attribute = new Attribute({ attributeName, [base]: _base, defaultValue, fieldName, foreignKey, modelName, notNull, [size]: _size, tableName, type, unique });
             if (primaryKey === attributeName)
                 pk = attribute;
             aArray.push(attribute);
-            attr2field[attributeName] = fieldName;
+            if (type !== "NONE")
+                attr2field[attributeName] = fieldName;
             if (foreignKey)
                 constraints.push({ attribute, constraintName: `fkey_${fieldName}_${foreignKey.tableName}_${foreignKey.fieldName}`, type: "f" });
             if (unique)
                 constraints.push({ attribute, constraintName: `${tableName}_${fieldName}_unique`, type: "u" });
         }
         if (indexes) {
-            const originalAttributes = attributes;
+            const originalAttributes = _attributes;
             if (!(indexes instanceof Object))
                 throw new Error(`Sedentary.model: '${modelName}' model: 'indexes' option: Wrong type, expected 'Object'`);
             for (const indexName in indexes) {
@@ -395,34 +398,34 @@ export class Sedentary {
             return ret;
         }, {});
         for (const foreignKey in foreignKeys) {
-            if (foreignKey + "Load" in attributes)
+            if (foreignKey + "Load" in _attributes)
                 throw new Error(`Sedentary.model: '${modelName}' model: '${foreignKey}' attribute: '${foreignKey}Load' inferred methods conflicts with an attribute`);
-            if (foreignKey + "Load" in methods)
+            if (foreignKey + "Load" in _methods)
                 throw new Error(`Sedentary.model: '${modelName}' model: '${foreignKey}' attribute: '${foreignKey}Load' inferred methods conflicts with a method`);
         }
-        for (const method in methods)
-            if (method in attributes)
+        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 attributes) {
-                if (attribute in parent.attributes)
+            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 (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 foreignKeys) {
-                if (foreignKey + "Load" in parent.attributes)
+                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 (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`);
             }
-            for (const method in methods) {
-                if (method in parent.attributes)
+            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)
@@ -484,10 +487,10 @@ export class Sedentary {
         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, attributes, { value: _attributes });
         Object.defineProperty(ret, "foreignKeys", { value: foreignKeys });
-        Object.defineProperty(ret, "methods", { value: methods });
-        Object.assign(ret.prototype, methods);
+        Object.defineProperty(ret, methods, { value: _methods });
+        Object.assign(ret.prototype, _methods);
         const ensureActions = (entry) => {
             if (!entry[actions])
                 Object.defineProperty(entry, actions, { configurable: true, value: [] });
@@ -517,7 +520,7 @@ export class Sedentary {
         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"])
+        for (const key of ["attributeName", base, "fieldName", "modelName", size, "tableName", "type", "unique"])
             Object.defineProperty(ret, key, { value: pk[key] });
         return ret;
     }

package/dist/types/db.d.ts

@@ -1,5 +1,7 @@
 export declare const actions: unique symbol;
+export declare const base: unique symbol;
 export declare const loaded: unique symbol;
+export declare const size: unique symbol;
 export declare const transaction: unique symbol;
 export interface Action {
     action: "remove" | "save";
@@ -25,10 +27,10 @@ export interface ForeignKeyOptions {
     onUpdate?: ForeignKeyActions;
 }
 export interface Type<T, E> {
-    base: unknown;
+    [base]: unknown;
     entry?: E;
     native?: T;
-    size?: number;
+    [size]?: number;
     type: string;
     foreignKey?: {
         attributeName: string;
@@ -98,7 +100,7 @@ export declare abstract class DB<T extends Transaction> {
     abstract escape(value: unknown): string;
     abstract load(tableName: string, attributes: Record<string, string>, pk: Attribute<unknown, unknown>, model: new () => EntryBase, table: Table): (where: string, order?: string | string[], limit?: number, tx?: Transaction, lock?: boolean) => Promise<EntryBase[]>;
     abstract remove(tableName: string, pk: Attribute<unknown, unknown>): (this: EntryBase & Record<string, unknown>) => Promise<number>;
-    abstract save(tableName: string, attributes: Record<string, string>, pk: Attribute<unknown, unknown>): (this: EntryBase & Record<string, unknown>) => Promise<number | false>;
+    abstract save(tableName: string, attr2field: Record<string, string>, pk: Attribute<unknown, unknown>): (this: EntryBase & Record<string, unknown>) => Promise<number | false>;
     abstract dropConstraints(table: Table): Promise<number[]>;
     abstract dropFields(table: Table): Promise<void>;
     abstract dropIndexes(table: Table, constraintIndexes: number[]): Promise<void>;

package/dist/types/index.d.ts

@@ -1,5 +1,5 @@
 import { Attribute, DB, EntryBase, ForeignKeyOptions, Transaction, Type } from "./db";
-export { Action, Attribute, DB, differ, EntryBase, ForeignKeyActions, ForeignKeyOptions, Index, loaded, Table, Transaction, transaction, Type } from "./db";
+export { Action, Attribute, base, DB, differ, EntryBase, ForeignKeyActions, ForeignKeyOptions, Index, loaded, size, 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;
@@ -12,6 +12,8 @@ export declare type AttributeDefinition<T, E> = TypeDefinition<T, E> | Attribute
 export declare type AttributesDefinition = {
     [key: string]: AttributeDefinition<unknown, unknown>;
 };
+declare const attributes: unique symbol;
+declare const methods: unique symbol;
 declare type ForeignKeysAttributes<T, k> = T extends AttributeDefinition<unknown, infer E> ? (E extends EntryBase ? k : never) : never;
 declare type ForeignKeys<A extends AttributesDefinition> = {
     [a in keyof A]?: ForeignKeysAttributes<A[a], a>;
@@ -57,13 +59,13 @@ declare type ForeignKey<A> = A extends AttributeDefinition<unknown, infer E> ? (
 declare type EntryBaseAttributes<A extends AttributesDefinition> = {
     [a in keyof A]: Native<A[a]>;
 };
-declare type EntryMethodsBase<P extends ModelStd> = P extends new () => EntryBase ? P["methods"] : EntryBase;
+declare type EntryMethodsBase<P extends ModelStd> = P extends new () => EntryBase ? P[typeof 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"] : {
+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[typeof attributes] : {
     id: {
         notNull: true;
         type: Type<BaseKeyType<B>, unknown>;
@@ -77,9 +79,9 @@ export interface ModelLoad<A extends AttributesDefinition, E extends EntryBase>
     cancel(where: Condition<A>, tx?: Transaction): Promise<number>;
 }
 declare type ModelBase<T, A extends AttributesDefinition, EA extends Record<string, unknown>, EM extends EntryBase, E extends EntryBase> = (new (from?: Partial<EA>, tx?: Transaction) => E) & Attribute<T, E> & {
-    attributes: A;
+    [attributes]: A;
     foreignKeys: Record<string, boolean>;
-    methods: EM;
+    [methods]: EM;
     parent?: ModelStd;
     tableName: string;
 } & {
@@ -87,9 +89,9 @@ declare type ModelBase<T, A extends AttributesDefinition, EA extends Record<stri
 } & ModelLoad<A, E>;
 declare type Model<T, A extends AttributesDefinition, EM extends EntryBase> = ModelBase<T, A, EntryBaseAttributes<A>, EM, EntryBaseAttributes<A> & EM>;
 declare type ModelStd = Attribute<unknown, EntryBase> & {
-    attributes: AttributesDefinition;
+    [attributes]: AttributesDefinition;
     foreignKeys: Record<string, boolean>;
-    methods: EntryBase;
+    [methods]: EntryBase;
     parent?: ModelStd;
 };
 export declare type Entry<M> = M extends new () => infer E ? E : never;
@@ -116,12 +118,12 @@ export declare class Sedentary<D extends DB<T>, T extends Transaction> {
     Boolean(): Type<boolean, unknown>;
     DateTime(): Type<Date, unknown>;
     FKey<T, E extends EntryBase>(attribute: Attribute<T, E>, options?: ForeignKeyOptions): Type<T, E>;
-    Int(size?: number): Type<number, unknown>;
+    Int(_size?: number): Type<number, unknown>;
     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>;
+    VarChar<S extends string>(_size?: number): Type<S, unknown>;
     private checkDB;
     private checkOrderBy;
     private checkSize;

package/package.json

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