sedentary 0.0.54 → 0.1.1

package/README.md

@@ -1,8 +1,8 @@
 # sedentary
 
 [![Build Status][travis-badge]][travis-url]
-[![Code Climate][code-badge]][code-url]
-[![Test Coverage][cover-badge]][code-url]
+[![Code Quality][qlty-badge]][qlty-url]
+[![Test Coverage][cover-badge]][qlty-url]
 
 [![NPM version][npm-badge]][npm-url]
 [![NPM downloads][npm-downloads-badge]][npm-url]
@@ -13,27 +13,27 @@
 [![Dependents][deps-badge]][npm-url]
 [![Donate][donate-badge]][donate-url]
 
-[code-badge]: https://codeclimate.com/github/iccicci/sedentary/badges/gpa.svg
-[code-url]: https://codeclimate.com/github/iccicci/sedentary
-[cover-badge]: https://codeclimate.com/github/iccicci/sedentary/badges/coverage.svg
-[deps-badge]: https://badgen.net/npm/dependents/sedentary?icon=npm&cache=300
+[cover-badge]: https://qlty.sh/gh/iccicci/projects/sedentary/coverage.svg
+[qlty-badge]: https://qlty.sh/gh/iccicci/projects/sedentary/maintainability.svg
+[qlty-url]: https://qlty.sh/gh/iccicci/projects/sedentary
+[deps-badge]: https://img.shields.io/librariesio/dependents/npm/sedentary?logo=npm
 [doc-badge]: https://readthedocs.org/projects/sedentary/badge/?version=latest
 [doc-url]: https://sedentary.readthedocs.io/
-[donate-badge]: https://badgen.net/badge/donate/bitcoin?icon=bitcoin&cache=300
+[donate-badge]: https://img.shields.io/static/v1?label=donate&message=bitcoin&color=blue&logo=bitcoin
 [donate-url]: https://blockchain.info/address/1Md9WFAHrXTb3yPBwQWmUfv2RmzrtbHioB
 [github-url]: https://github.com/iccicci/sedentary
-[npm-downloads-badge]: https://badgen.net/npm/dw/sedentary?icon=npm&cache=300
-[npm-badge]: https://badgen.net/npm/v/sedentary?color=green&icon=npm&cache=300
+[npm-downloads-badge]: https://img.shields.io/npm/dw/sedentary?logo=npm
+[npm-badge]: https://img.shields.io/npm/v/sedentary?color=green&logo=npm
 [npm-url]: https://www.npmjs.com/package/sedentary
-[stars-badge]: https://badgen.net/github/stars/iccicci/sedentary?icon=github&cache=300
-[travis-badge]: https://badgen.net/travis/iccicci/sedentary?icon=travis&cache=300
+[stars-badge]: https://img.shields.io/github/stars/iccicci/sedentary?logo=github&style=flat&color=green
+[travis-badge]: https://img.shields.io/travis/com/iccicci/sedentary?logo=travis
 [travis-url]: https://app.travis-ci.com/github/iccicci/sedentary
-[types-badge]: https://badgen.net/npm/types/sedentary?color=green&icon=typescript&cache=300
-
-# under development
+[types-badge]: https://img.shields.io/static/v1?label=types&message=included&color=green&logo=typescript
 
 # Description
 
+This package contains the base logic and types for the Sedentary ORM. **It must not be used directly** because it does not implement any DB engine; use a dedicated extension such as [sedentary-pg](https://www.npmjs.com/package/sedentary-pg) instead.
+
 An ORM which automatically syncs the DB schema on models change, no migrations between versions are required.
 
 This package is designed **to make easy the process of applying changes to the database after model definition
@@ -46,19 +46,19 @@ changes to the models (or the database schema). This package tries to solve thes
 # Usage
 
 ```javascript
-import { Sedentary } from "sedentary";
+import { SedentaryPG } from "sedentary-pg";
 
-const db = new Sedentary("file.db");
+const db = new SedentaryPG({ database: "db", user: "user", password: "pass" });
 
-class Items extends db.model("Item", {
-  num: db.INT,
-  str: db.VarChar(30)
+const Items = db.model("Item", {
+  num: db.Int(),
+  str: db.VarChar({ size: 30 })
 });
 
 (async function () {
   await db.connect();
 
-  const item = Items.create();
+  const item = new Items();
 
   item.num = 0;
   item.str = "0";
@@ -71,6 +71,22 @@ class Items extends db.model("Item", {
 })();
 ```
 
+With TypeScript the instance can be typed using `Entry<typeof Model>`:
+
+```typescript
+import { Entry, SedentaryPG } from "sedentary-pg";
+
+const db = new SedentaryPG({ database: "db", user: "user", password: "pass" });
+
+const Items = db.model("Item", { num: db.Int(), str: db.VarChar({ size: 30 }) });
+type Item = Entry<typeof Items>;
+
+const item: Item = new Items();
+
+item.num = 0;
+item.str = "0";
+```
+
 # Installation
 
 With [npm](https://www.npmjs.com/package/sedentary):
@@ -85,9 +101,9 @@ $ npm install --save sedentary
 
 A _DB engine dedicated extension_ must be used:
 
-- MySQL: planned
-- PostgreSQL: [sedentary-pg](https://github.com/iccicci/sedentary-pg#readme)
-- SQLite: planned
+- MySQL: in todo, not yet planned
+- PostgreSQL: [sedentary-pg](https://www.npmjs.com/package/sedentary-pg)
+- SQLite: in todo, not yet planned
 
 # Documentation
 
@@ -97,13 +113,13 @@ The full documentation is on [sedentary.readthedocs.io](https://sedentary.readth
 
 Requires:
 
-- Node.js: **v14**
-- TypeScript: **v4.6** (or none if used in a JavaScript project).
+- Node.js: **v20**
+- TypeScript: **v5.7** (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).
 
-To work with the package under Windows, be sure to configure `bash.exe` as your _script-shell_.
+To work with the package under Windows, `bash.exe` can be configured as the _script-shell_.
 
 ```
 > npm config set script-shell bash.exe
@@ -115,9 +131,12 @@ To work with the package under Windows, be sure to configure `bash.exe` as your
 
 # Bugs
 
-Do not hesitate to report any bug or inconsistency [@github](https://github.com/iccicci/sedentary/issues).
+Bugs and inconsistencies can be reported [@github](https://github.com/iccicci/sedentary/issues).
 
 # Donating
 
-If you find useful this package, please consider the opportunity to donate some satoshis to this bitcoin address:
+Satoshis can be donated to this bitcoin address if the package is found useful:
+
+<!-- cSpell: disable -->
+
 **1Md9WFAHrXTb3yPBwQWmUfv2RmzrtbHioB**

package/dist/cjs/db.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.deepDiff = exports.deepCopy = 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.Transaction = exports.DB = exports.Table = exports.Attribute = exports.Type = exports.EntryBase = exports.transaction = exports.size = exports.loaded = exports.base = exports.actions = void 0;
+exports.deepCopy = deepCopy;
+exports.deepDiff = deepDiff;
 exports.actions = Symbol("actions");
 exports.base = Symbol("base");
 exports.loaded = Symbol("loaded");
@@ -29,21 +31,24 @@ class EntryBase {
     preLoad() { }
     preRemove() { }
     preSave() { }
-    async remove() {
-        return false;
+    remove() {
+        return Promise.resolve(false);
     }
-    async save() {
-        return false;
+    save() {
+        return Promise.resolve(false);
     }
 }
 exports.EntryBase = EntryBase;
+// eslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging
 class Type {
     constructor(from) {
         Object.assign(this, from);
     }
 }
 exports.Type = Type;
+// eslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging
 class Attribute extends Type {
+    // eslint-disable-next-line @typescript-eslint/no-useless-constructor
     constructor(from) {
         super(from);
     }
@@ -58,10 +63,10 @@ function autoImplement() {
 }
 class Table extends autoImplement() {
     findAttribute(name) {
-        return this.attributes.filter(_ => _.attributeName === name)[0];
+        return this.attributes.find(_ => _.attributeName === name);
     }
     findField(name) {
-        return this.attributes.filter(_ => _.fieldName === name)[0];
+        return this.attributes.find(_ => _.fieldName === name);
     }
 }
 exports.Table = Table;
@@ -72,12 +77,12 @@ class DB {
         this.log = log;
     }
     findTable(name) {
-        return this.tables.filter(_ => _.tableName === name)[0];
+        return this.tables.find(_ => _.tableName === name);
     }
     indexesEq(a, b) {
         if (a.fields.length !== b.fields.length)
             return false;
-        for (const i in a.fields)
+        for (let i = 0; i < a.fields.length; ++i)
             if (a.fields[i] !== b.fields[i])
                 return false;
         if (a.type !== b.type)
@@ -100,7 +105,7 @@ class DB {
         }
     }
     syncLog(message) {
-        this.log(this.sync ? message : "NOT SYNCING: " + message);
+        this.log(this.sync ? message : `NOT SYNCING: ${message}`);
     }
 }
 exports.DB = DB;
@@ -121,12 +126,13 @@ class Transaction {
         }
         this.entries = [];
     }
-    async commit() {
+    commit() {
         const { entries } = this;
         for (const entry of entries)
             if (entry[exports.actions])
                 entry.postCommit(entry[exports.actions]);
         this.clean();
+        return Promise.resolve();
     }
     preCommit() {
         const { entries } = this;
@@ -134,8 +140,9 @@ class Transaction {
             if (entry[exports.actions])
                 entry.preCommit(entry[exports.actions]);
     }
-    async rollback() {
+    rollback() {
         this.clean();
+        return Promise.resolve();
     }
 }
 exports.Transaction = Transaction;
@@ -149,7 +156,6 @@ function deepCopy(o) {
         ret[k] = deepCopy(v);
     return ret;
 }
-exports.deepCopy = deepCopy;
 function deepDiff(a, b) {
     if (typeof a !== "object")
         return a !== b;
@@ -176,4 +182,3 @@ function deepDiff(a, b) {
             return true;
     return false;
 }
-exports.deepDiff = deepDiff;

package/dist/cjs/index.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Sedentary = exports.Type = exports.transaction = exports.Transaction = exports.Table = exports.size = exports.loaded = exports.EntryBase = exports.deepDiff = exports.deepCopy = exports.DB = exports.base = exports.Attribute = void 0;
+exports.toSqlName = toSqlName;
 const db_1 = require("./db");
 var db_2 = require("./db");
 Object.defineProperty(exports, "Attribute", { enumerable: true, get: function () { return db_2.Attribute; } });
@@ -20,9 +21,53 @@ const methods = Symbol("methods");
 const operators = ["=", ">", "<", ">=", "<=", "<>", "IN", "IS NULL", "LIKE", "NOT"];
 const allowedOption = ["indexes", "int8id", "parent", "primaryKey", "sync", "tableName"];
 const reservedNames = [
-    ...["attr2field", "attributeName", "cancel", "class", "construct", "constructor", "defaultValue", "fieldName", "foreignKeys", "load", "name"],
-    ...["postCommit", "postLoad", "postRemove", "postSave", "preCommit", "preLoad", "preRemove", "preSave", "primaryKey", "prototype", "save", "tableName", "type"]
+    "attr2field",
+    "attributeName",
+    "cancel",
+    "class",
+    "construct",
+    "constructor",
+    "defaultValue",
+    "fieldName",
+    "foreignKeys",
+    "load",
+    "modelName",
+    "name",
+    "postCommit",
+    "postLoad",
+    "postRemove",
+    "postSave",
+    "preCommit",
+    "preLoad",
+    "preRemove",
+    "preSave",
+    "primaryKey",
+    "prototype",
+    "remove",
+    "save",
+    "tableName",
+    "type",
+    "unique"
 ];
+/** Model and attribute names: ASCII letters, digits, underscore; cannot start with digit. */
+const reModelAttributeName = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+/** tableName and fieldName: ASCII lowercase letters, digits, underscore; cannot start with digit. */
+const reSqlName = /^[a-z_][a-z0-9_]*$/;
+/**
+ * Converts a JavaScript name to the default SQL name (snake_case).
+ * Uppercase letters become lowercase preceded by underscore, except the first character
+ * which is only lowercased without underscore.
+ */
+function toSqlName(name) {
+    if (typeof name !== "string" || name.length === 0)
+        throw new Error("toSqlName: 'name' must be a non-empty string");
+    let result = name[0].toLowerCase();
+    for (let i = 1; i < name.length; i++) {
+        const c = name[i];
+        result += c >= "A" && c <= "Z" ? `_${c.toLowerCase()}` : c;
+    }
+    return result;
+}
 class Sedentary {
     constructor(options) {
         this.doSync = true;
@@ -47,46 +92,56 @@ class Sedentary {
         this.log = log ? log : log === null ? () => { } : console.log;
         this.doSync = sync;
     }
-    Boolean() {
-        return new db_1.Type({ [db_1.base]: Boolean, type: "BOOLEAN" });
+    Boolean(options) {
+        return new db_1.Type({ ...options, [db_1.base]: Boolean, type: "BOOLEAN" });
     }
-    DateTime() {
-        return new db_1.Type({ [db_1.base]: Date, type: "DATETIME" });
+    DateTime(options) {
+        return new db_1.Type({ ...options, [db_1.base]: Date, type: "DATETIME" });
     }
     FKey(attribute, options) {
-        const { attributeName, fieldName, tableName, type, [db_1.base]: _base, [db_1.size]: _size } = attribute;
+        const { attributeName, fieldName, modelName, tableName, type, unique, [db_1.base]: _base, [db_1.size]: _size } = attribute;
+        if (!unique)
+            throw new Error(`Sedentary.FKey: '${modelName}' model: '${attributeName}' attribute: is not unique: can't be used as FKey target`);
         return new db_1.Type({ [db_1.base]: _base, foreignKey: { attributeName, fieldName, options, tableName }, [db_1.size]: _size, type });
     }
-    Float(_size) {
-        const message = "Sedentary.Float: 'size' argument: Wrong value, expected 4 or 8";
-        _size = _size ? this.checkSize(_size, message) : 8;
-        if (_size !== 4 && _size !== 8)
-            throw new Error(message);
-        return new db_1.Type({ [db_1.base]: Number, [db_1.size]: _size, type: "FLOAT" });
+    Float(options) {
+        const sizeFloat = "Sedentary.Float: 'size' argument: Wrong value, expected 4 or 8";
+        let storageSize;
+        let rest;
+        [storageSize, rest] = this.checkSize(sizeFloat, options);
+        if (storageSize === undefined)
+            storageSize = 8;
+        if (storageSize !== 4 && storageSize !== 8)
+            throw new Error(sizeFloat);
+        return new db_1.Type({ ...rest, [db_1.base]: Number, [db_1.size]: storageSize, type: "FLOAT" });
     }
-    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)
-            throw new Error(message);
-        return new db_1.Type({ [db_1.base]: Number, [db_1.size]: _size, type: "INT" });
+    Int(options) {
+        const sizeInt = "Sedentary.Int: 'size' argument: Wrong value, expected 2 or 4";
+        let storageSize;
+        let rest;
+        [storageSize, rest] = this.checkSize(sizeInt, options);
+        if (storageSize === undefined)
+            storageSize = 4;
+        if (storageSize !== 2 && storageSize !== 4)
+            throw new Error(sizeInt);
+        return new db_1.Type({ ...rest, [db_1.base]: Number, [db_1.size]: storageSize, type: "INT" });
     }
-    Int8() {
-        return new db_1.Type({ [db_1.base]: BigInt, [db_1.size]: 8, type: "INT8" });
+    Int8(options) {
+        return new db_1.Type({ ...options, [db_1.base]: BigInt, [db_1.size]: 8, type: "INT8" });
     }
-    JSON() {
-        return new db_1.Type({ [db_1.base]: Object, type: "JSON" });
+    JSON(options) {
+        return new db_1.Type({ ...options, [db_1.base]: Object, type: "JSON" });
     }
-    Number() {
-        return new db_1.Type({ [db_1.base]: Number, type: "NUMBER" });
+    Number(options) {
+        return new db_1.Type({ ...options, [db_1.base]: Number, type: "NUMBER" });
     }
-    None() {
-        return new db_1.Type({ [db_1.base]: undefined, type: "NONE" });
+    None(options) {
+        return new db_1.Type({ ...options, [db_1.base]: undefined, type: "NONE" });
     }
-    VarChar(_size) {
+    VarChar(options) {
         const message = "Sedentary.VarChar: 'size' argument: Wrong value, expected positive integer";
-        _size = _size ? this.checkSize(_size, message) : undefined;
-        return new db_1.Type({ [db_1.base]: String, [db_1.size]: _size, type: "VARCHAR" });
+        const [maxSize, rest] = this.checkSize(message, options);
+        return new db_1.Type({ ...rest, [db_1.base]: String, [db_1.size]: maxSize, type: "VARCHAR" });
     }
     checkDB() {
         if (!this.db)
@@ -115,12 +170,19 @@ class Sedentary {
         }
         return true;
     }
-    checkSize(size, message) {
-        const str = size.toString();
-        const parsed = parseInt(str, 10);
-        if (str !== parsed.toString())
+    checkSize(message, options) {
+        if (!options)
+            return [undefined, {}];
+        const { size, ...rest } = options;
+        if (size === undefined)
+            return [undefined, rest];
+        if (typeof size !== "number")
             throw new Error(message);
-        return parsed;
+        if (size !== parseInt(size.toString(), 10))
+            throw new Error(message);
+        if (size <= 0)
+            throw new Error(message);
+        return [size, rest];
     }
     createWhere(modelName, attributes, where) {
         if (typeof where === "string")
@@ -201,9 +263,9 @@ class Sedentary {
             if (this.autoSync || sync)
                 await this.sync();
         }
-        catch (e) {
-            this.log("Connecting: " + (e instanceof Error ? e.message : JSON.stringify(e)));
-            throw e;
+        catch (error) {
+            this.log(`Connecting: ${error instanceof Error ? error.message : JSON.stringify(error)}`);
+            throw error;
         }
     }
     async sync() {
@@ -227,6 +289,8 @@ class Sedentary {
         this.checkDB();
         if (typeof modelName !== "string")
             throw new Error("Sedentary.model: 'name' argument: Wrong type, expected 'string'");
+        if (!reModelAttributeName.test(modelName))
+            throw new Error(`Sedentary.model: '${modelName}' model: Invalid model name, expected ASCII letters, digits or underscore, cannot start with digit`);
         if (this.models[modelName])
             throw new Error(`Sedentary.model: '${modelName}' model: Model already defined`);
         if (!_attributes)
@@ -247,10 +311,12 @@ 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 } = { sync: this.doSync, tableName: modelName, ...options };
+        const { indexes, int8id, parent, primaryKey, sync, tableName } = { sync: this.doSync, tableName: toSqlName(modelName), ...options };
+        if (!reSqlName.test(tableName))
+            throw new Error(`Sedentary.model: '${modelName}' model: Invalid tableName '${tableName}', expected lowercase ASCII letters, digits or underscore, cannot start with digit`);
         let aArray = int8id
-            ? [new db_1.Attribute({ ...this.Int8(), attributeName: "id", fieldName: "id", modelName, notNull: true, tableName, unique: true })]
-            : [new db_1.Attribute({ ...this.Int(4), attributeName: "id", fieldName: "id", modelName, notNull: true, tableName, unique: true })];
+            ? [new db_1.Attribute({ ...this.Int8(), attributeName: "id", fieldName: toSqlName("id"), modelName, notNull: true, tableName, unique: true })]
+            : [new db_1.Attribute({ ...this.Int({ size: 4 }), attributeName: "id", fieldName: toSqlName("id"), modelName, notNull: true, tableName, unique: true })];
         let constraints = [{ attribute: aArray[0], constraintName: `${tableName}_id_unique`, type: "u" }];
         const iArray = [];
         let pk = aArray[0];
@@ -274,51 +340,37 @@ class Sedentary {
             constraints = [];
         }
         for (const attributeName of Object.keys(_attributes).sort()) {
+            if (!reModelAttributeName.test(attributeName))
+                throw new Error(`Sedentary.model: '${modelName}' model: '${attributeName}' attribute: Invalid attribute name, expected ASCII letters, digits or underscore, cannot start with digit`);
             if (reservedNames.includes(attributeName))
                 throw new Error(`Sedentary.model: '${modelName}' model: '${attributeName}' attribute: Reserved name`);
-            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.Float, 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() });
-            };
             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 });
-                    if (attributeDefinition instanceof Function)
-                        return call(undefined, attributeName, false, false, attributeDefinition, `Sedentary.model: '${modelName}' model: '${attributeName}' attribute:`, "Wrong type, expected 'Attribute'");
-                    if (!(attributeDefinition instanceof Object))
-                        throw new Error(`Sedentary.model: '${modelName}' model: '${attributeName}' attribute: Wrong attribute type, expected 'Attribute'`);
-                    const attributeDefaults = { defaultValue: undefined, fieldName: attributeName, notNull: false, unique: false, ...attributeDefinition };
-                    const { defaultValue, fieldName, notNull, unique, type } = attributeDefaults;
-                    if (defaultValue === null)
-                        throw new Error(`Sedentary.model: '${modelName}' model: '${attributeName}' attribute: 'defaultValue' option: Does 'null' default value really makes sense?`);
-                    if (typeof fieldName !== "string")
-                        throw new Error(`Sedentary.model: '${modelName}' model: '${attributeName}' attribute: 'fieldName' option: Wrong type, expected 'string'`);
-                    if (typeof notNull !== "boolean")
-                        throw new Error(`Sedentary.model: '${modelName}' model: '${attributeName}' attribute: 'notNull' option: Wrong type, expected 'boolean'`);
-                    if (typeof unique !== "boolean")
-                        throw new Error(`Sedentary.model: '${modelName}' model: '${attributeName}' attribute: 'unique' option: Wrong type, expected 'boolean'`);
-                    if (type === undefined)
-                        throw new Error(`Sedentary.model: '${modelName}' model: '${attributeName}' attribute: Missing 'type' option`);
-                    if (type instanceof db_1.Type)
-                        return new db_1.Attribute({ attributeName, defaultValue, fieldName, modelName, notNull, tableName, unique, ...type });
-                    if (type instanceof Function)
-                        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 { [db_1.base]: _base, defaultValue } = ret;
-                if (defaultValue !== undefined) {
-                    if (_base === BigInt && typeof defaultValue !== "bigint")
+                if (!(attributeDefinition instanceof db_1.Type))
+                    throw new Error(`Sedentary.model: '${modelName}' model: '${attributeName}' attribute: '${attributeName}': Wrong type, expected 'Type'`);
+                const ret = new db_1.Attribute({ attributeName, fieldName: toSqlName(attributeName), modelName, notNull: false, tableName, unique: false, ...attributeDefinition });
+                const { defaultValue, fieldName, notNull, unique } = ret;
+                if (defaultValue === null)
+                    throw new Error(`Sedentary.model: '${modelName}' model: '${attributeName}' attribute: 'defaultValue' option: Does 'null' default value really make sense?`);
+                if (typeof fieldName !== "string")
+                    throw new Error(`Sedentary.model: '${modelName}' model: '${attributeName}' attribute: 'fieldName' option: Wrong type, expected 'string'`);
+                if (!reSqlName.test(fieldName)) {
+                    throw new Error(`Sedentary.model: '${modelName}' model: '${attributeName}' attribute: Invalid fieldName '${fieldName}', ` +
+                        "expected lowercase ASCII letters, digits or underscore, cannot start with digit");
+                }
+                if (typeof notNull !== "boolean")
+                    throw new Error(`Sedentary.model: '${modelName}' model: '${attributeName}' attribute: 'notNull' option: Wrong type, expected 'boolean'`);
+                if (typeof unique !== "boolean")
+                    throw new Error(`Sedentary.model: '${modelName}' model: '${attributeName}' attribute: 'unique' option: Wrong type, expected 'boolean'`);
+                const { [db_1.base]: _base, defaultValue: _defaultValue } = ret;
+                if (_defaultValue !== undefined) {
+                    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;
@@ -417,9 +469,9 @@ 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)
@@ -434,20 +486,20 @@ class Sedentary {
                 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")
+                    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])
                     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)
+                    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);
@@ -464,7 +516,7 @@ class Sedentary {
         this.db.tables.push(table);
         const cancel_ = this.db.cancel(tableName);
         const cancel = (where, tx) => cancel_(this.createWhere(modelName, attr2field, where)[0], tx);
-        Object.defineProperty(cancel, "name", { value: modelName + ".cancel" });
+        Object.defineProperty(cancel, "name", { value: `${modelName}.cancel` });
         const load_ = this.db.load(tableName, attr2field, pk, ret, table);
         const load = (where, ...args) => {
             let order = undefined;
@@ -501,7 +553,7 @@ class Sedentary {
                 throw new Error(`${modelName}.load: 'tx' argument: Wrong type, expected 'Transaction'`);
             return load_(this.createWhere(modelName, attr2field, where)[0], order, limit, tx, lock);
         };
-        Object.defineProperty(load, "name", { value: modelName + ".load" });
+        Object.defineProperty(load, "name", { value: `${modelName}.load` });
         Object.defineProperty(ret, "cancel", { value: cancel });
         Object.defineProperty(ret, "name", { value: modelName });
         Object.defineProperty(ret, "load", { value: load });
@@ -526,7 +578,7 @@ class Sedentary {
                 ensureActions(this).push({ action: "remove", records });
             return records;
         };
-        Object.defineProperty(ret.prototype.remove, "name", { value: modelName + ".remove" });
+        Object.defineProperty(ret.prototype.remove, "name", { value: `${modelName}.remove` });
         const save = this.db.save(tableName, attr2field, pk);
         ret.prototype.save = async function () {
             this.preSave();
@@ -536,7 +588,7 @@ class Sedentary {
                 ensureActions(this).push({ action: "save", records });
             return records;
         };
-        Object.defineProperty(ret.prototype.save, "name", { value: modelName + ".save" });
+        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", db_1.base, "fieldName", "modelName", db_1.size, "tableName", "type", "unique"])

package/dist/cjs/package.json

@@ -0,0 +1 @@
+{\"type\":\"commonjs\"}