sedentary 0.0.54 → 0.1.1

package/dist/es/db.js

@@ -26,19 +26,22 @@ export class EntryBase {
     preLoad() { }
     preRemove() { }
     preSave() { }
-    async remove() {
-        return false;
+    remove() {
+        return Promise.resolve(false);
     }
-    async save() {
-        return false;
+    save() {
+        return Promise.resolve(false);
     }
 }
+// eslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging
 export class Type {
     constructor(from) {
         Object.assign(this, from);
     }
 }
+// eslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging
 export class Attribute extends Type {
+    // eslint-disable-next-line @typescript-eslint/no-useless-constructor
     constructor(from) {
         super(from);
     }
@@ -54,10 +57,10 @@ export class Table extends autoImplement() {
     autoIncrementOwn;
     oid;
     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);
     }
 }
 export class DB {
@@ -68,12 +71,12 @@ export 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)
@@ -96,7 +99,7 @@ export class DB {
         }
     }
     syncLog(message) {
-        this.log(this.sync ? message : "NOT SYNCING: " + message);
+        this.log(this.sync ? message : `NOT SYNCING: ${message}`);
     }
 }
 export class Transaction {
@@ -117,12 +120,13 @@ export class Transaction {
         }
         this.entries = [];
     }
-    async commit() {
+    commit() {
         const { entries } = this;
         for (const entry of entries)
             if (entry[actions])
                 entry.postCommit(entry[actions]);
         this.clean();
+        return Promise.resolve();
     }
     preCommit() {
         const { entries } = this;
@@ -130,8 +134,9 @@ export class Transaction {
             if (entry[actions])
                 entry.preCommit(entry[actions]);
     }
-    async rollback() {
+    rollback() {
         this.clean();
+        return Promise.resolve();
     }
 }
 const sortedEntries = (obj) => Object.entries(obj).sort((entryA, entryB) => (entryA[0] > entryB[0] ? -1 : 1));

package/dist/es/index.js

@@ -5,9 +5,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.
+ */
+export 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;
+}
 export class Sedentary {
     autoSync;
     db;
@@ -35,46 +79,56 @@ export class Sedentary {
         this.log = log ? log : log === null ? () => { } : console.log;
         this.doSync = sync;
     }
-    Boolean() {
-        return new Type({ [base]: Boolean, type: "BOOLEAN" });
+    Boolean(options) {
+        return new Type({ ...options, [base]: Boolean, type: "BOOLEAN" });
     }
-    DateTime() {
-        return new Type({ [base]: Date, type: "DATETIME" });
+    DateTime(options) {
+        return new Type({ ...options, [base]: Date, type: "DATETIME" });
     }
     FKey(attribute, options) {
-        const { attributeName, fieldName, tableName, type, [base]: _base, [size]: _size } = attribute;
+        const { attributeName, fieldName, modelName, tableName, type, unique, [base]: _base, [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 Type({ [base]: _base, foreignKey: { attributeName, fieldName, options, tableName }, [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 Type({ [base]: Number, [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 Type({ ...rest, [base]: Number, [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 Type({ [base]: Number, [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 Type({ ...rest, [base]: Number, [size]: storageSize, type: "INT" });
     }
-    Int8() {
-        return new Type({ [base]: BigInt, [size]: 8, type: "INT8" });
+    Int8(options) {
+        return new Type({ ...options, [base]: BigInt, [size]: 8, type: "INT8" });
     }
-    JSON() {
-        return new Type({ [base]: Object, type: "JSON" });
+    JSON(options) {
+        return new Type({ ...options, [base]: Object, type: "JSON" });
     }
-    Number() {
-        return new Type({ [base]: Number, type: "NUMBER" });
+    Number(options) {
+        return new Type({ ...options, [base]: Number, type: "NUMBER" });
     }
-    None() {
-        return new Type({ [base]: undefined, type: "NONE" });
+    None(options) {
+        return new Type({ ...options, [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 Type({ [base]: String, [size]: _size, type: "VARCHAR" });
+        const [maxSize, rest] = this.checkSize(message, options);
+        return new Type({ ...rest, [base]: String, [size]: maxSize, type: "VARCHAR" });
     }
     checkDB() {
         if (!this.db)
@@ -103,12 +157,19 @@ export 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")
@@ -189,9 +250,9 @@ export 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() {
@@ -215,6 +276,8 @@ export 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)
@@ -235,10 +298,12 @@ export 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 Attribute({ ...this.Int8(), attributeName: "id", fieldName: "id", modelName, notNull: true, tableName, unique: true })]
-            : [new Attribute({ ...this.Int(4), attributeName: "id", fieldName: "id", modelName, notNull: true, tableName, unique: true })];
+            ? [new Attribute({ ...this.Int8(), attributeName: "id", fieldName: toSqlName("id"), modelName, notNull: true, tableName, unique: true })]
+            : [new 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];
@@ -262,51 +327,37 @@ export 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 Attribute({ attributeName, defaultValue, fieldName, modelName, notNull, tableName, unique, ...func() });
-            };
             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 });
-                    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 Type)
-                        return new 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 { [base]: _base, defaultValue } = ret;
-                if (defaultValue !== undefined) {
-                    if (_base === BigInt && typeof defaultValue !== "bigint")
+                if (!(attributeDefinition instanceof Type))
+                    throw new Error(`Sedentary.model: '${modelName}' model: '${attributeName}' attribute: '${attributeName}': Wrong type, expected 'Type'`);
+                const ret = new 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 { [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;
@@ -405,9 +456,9 @@ 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)
@@ -422,20 +473,20 @@ export 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);
@@ -452,7 +503,7 @@ export 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;
@@ -489,7 +540,7 @@ export 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 });
@@ -514,7 +565,7 @@ export 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();
@@ -524,7 +575,7 @@ export 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", base, "fieldName", "modelName", size, "tableName", "type", "unique"])

package/dist/types/db.d.ts

@@ -3,33 +3,37 @@ 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";
+export type TxAction = {
+    action: "remove";
+    records: number;
+} | {
+    action: "save";
     records: number | false;
-}
+};
 export declare class EntryBase {
     constructor(from?: Partial<EntryBase>);
     construct(): void;
-    postCommit(actions: Action[]): void;
+    postCommit(actions: TxAction[]): void;
     postLoad(): void;
     postRemove(deletedRecords: number): void;
     postSave(savedRecords: number | false): void;
-    preCommit(actions: Action[]): void;
+    preCommit(actions: TxAction[]): void;
     preLoad(): void;
     preRemove(): void;
     preSave(): void;
     remove(): Promise<boolean>;
-    save(): Promise<boolean>;
+    save(): Promise<number | false>;
 }
 export type ForeignKeyActions = "cascade" | "no action" | "restrict" | "set default" | "set null";
 export interface ForeignKeyOptions {
     onDelete?: ForeignKeyActions;
     onUpdate?: ForeignKeyActions;
 }
-export interface Type<T, E> {
+export interface Type<T, N extends boolean, E> {
     [base]: unknown;
     entry?: E;
     native?: T;
+    notNull?: N;
     [size]?: number;
     type: string;
     foreignKey?: {
@@ -39,23 +43,23 @@ export interface Type<T, E> {
         tableName: string;
     };
 }
-export declare class Type<T, E> {
-    constructor(from: Type<T, E>);
+export declare class Type<T, N extends boolean, E> {
+    constructor(from: Type<T, N, E>);
 }
-export interface Attribute<T, E> extends Type<T, E> {
+export interface Attribute<T, N extends boolean, E> extends Type<T, N, E> {
     attributeName: string;
     defaultValue?: unknown;
     fieldName: string;
     modelName: string;
-    notNull: boolean;
+    notNull: N;
     tableName: string;
     unique?: boolean;
 }
-export declare class Attribute<T, E> extends Type<T, E> {
-    constructor(from: Attribute<T, E>);
+export declare class Attribute<T, N extends boolean, E> extends Type<T, N, E> {
+    constructor(from: Attribute<T, N, E>);
 }
 export interface Constraint {
-    attribute: Attribute<unknown, unknown>;
+    attribute: Attribute<unknown, boolean, unknown>;
     constraintName: string;
     type: "f" | "u";
 }
@@ -66,15 +70,15 @@ export interface Index {
     unique: boolean;
 }
 interface ITable {
-    attributes: Attribute<unknown, unknown>[];
+    attributes: Attribute<unknown, boolean, unknown>[];
     autoIncrement: boolean;
     constraints: Constraint[];
     indexes: Index[];
     model: {
-        load: (where: any, order?: string[], tx?: Transaction) => Promise<EntryBase[]>;
+        load: (where: any, order?: any, tx?: Transaction) => Promise<EntryBase[]>;
     };
-    parent?: Attribute<unknown, unknown>;
-    pk: Attribute<unknown, unknown>;
+    parent?: Attribute<unknown, boolean, unknown>;
+    pk: Attribute<unknown, boolean, unknown>;
     sync: boolean;
     tableName: string;
 }
@@ -82,8 +86,8 @@ declare const Table_base: new (defaults?: ITable | undefined) => ITable;
 export declare class Table extends Table_base {
     autoIncrementOwn?: boolean;
     oid?: number;
-    findAttribute(name: string): Attribute<unknown, unknown>;
-    findField(name: string): Attribute<unknown, unknown>;
+    findAttribute(name: string): Attribute<unknown, boolean, unknown>;
+    findField(name: string): Attribute<unknown, boolean, unknown>;
 }
 export declare abstract class DB<T extends Transaction> {
     tables: Table[];
@@ -99,9 +103,9 @@ export declare abstract class DB<T extends Transaction> {
     abstract begin(): Promise<T>;
     abstract cancel(tableName: string): (where: string, tx?: Transaction) => Promise<number>;
     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, attr2field: Record<string, string>, pk: Attribute<unknown, unknown>): (this: EntryBase & Record<string, unknown>) => Promise<number | false>;
+    abstract load(tableName: string, attributes: Record<string, string>, pk: Attribute<unknown, boolean, 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, boolean, unknown>): (this: EntryBase & Record<string, unknown>) => Promise<number>;
+    abstract save(tableName: string, attr2field: Record<string, string>, pk: Attribute<unknown, boolean, 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>;