sedentary 0.0.42 → 0.0.45

package/README.md

@@ -52,7 +52,7 @@ const db = new Sedentary("file.db");
 
 class Items extends db.model("Item", {
   num: db.INT,
-  str: db.VARCHAR(30)
+  str: db.VarChar(30)
 });
 
 (async function () {

package/dist/cjs/db.d.ts

@@ -0,0 +1,111 @@
+export declare class EntryBase {
+    constructor(from?: Partial<EntryBase>);
+    construct(): void;
+    postLoad(): void;
+    postRemove(): void;
+    postSave(): void;
+    preLoad(): void;
+    preRemove(): void;
+    preSave(): void;
+    remove(): Promise<boolean>;
+    save(): Promise<boolean>;
+}
+export declare type ForeignKeyActions = "cascade" | "no action" | "restrict" | "set default" | "set null";
+export interface ForeignKeyOptions {
+    onDelete?: ForeignKeyActions;
+    onUpdate?: ForeignKeyActions;
+}
+export interface Type<T, E> {
+    base: unknown;
+    entry?: E;
+    native?: T;
+    size?: number;
+    type: string;
+    foreignKey?: {
+        attributeName: string;
+        fieldName: string;
+        options?: ForeignKeyOptions;
+        tableName: string;
+    };
+}
+export declare class Type<T, E> {
+    constructor(from: Type<T, E>);
+}
+export interface Attribute<T, E> extends Type<T, E> {
+    attributeName: string;
+    defaultValue?: unknown;
+    fieldName: string;
+    modelName: string;
+    notNull: boolean;
+    tableName: string;
+    unique?: boolean;
+}
+export declare class Attribute<T, E> extends Type<T, E> {
+    constructor(from: Attribute<T, E>);
+}
+export interface Constraint {
+    attribute: Attribute<unknown, unknown>;
+    constraintName: string;
+    type: "f" | "u";
+}
+export interface Index {
+    fields: string[];
+    indexName: string;
+    type: "btree" | "hash";
+    unique: boolean;
+}
+interface ITable {
+    attributes: Attribute<unknown, unknown>[];
+    autoIncrement: boolean;
+    constraints: Constraint[];
+    indexes: Index[];
+    model: {
+        load: (where: any, order?: string[], tx?: Transaction) => Promise<EntryBase[]>;
+    };
+    parent?: Attribute<unknown, unknown>;
+    pk: Attribute<unknown, unknown>;
+    sync: boolean;
+    tableName: string;
+}
+declare const Table_base: new (defaults?: ITable | undefined) => ITable;
+export declare class Table extends Table_base {
+    autoIncrementOwn?: boolean;
+    oid?: number;
+    findField(name: string): Attribute<unknown, unknown>;
+}
+export declare abstract class DB<T extends Transaction> {
+    tables: Table[];
+    protected log: (message: string) => void;
+    protected sync: boolean;
+    abstract connect(): Promise<void>;
+    abstract end(): Promise<void>;
+    constructor(log: (message: string) => void);
+    findTable(name: string): Table;
+    protected indexesEq(a: Index, b: Index): boolean;
+    syncDataBase(): Promise<void>;
+    protected syncLog(message: string): void;
+    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<boolean>;
+    abstract save(tableName: string, attributes: Record<string, string>, pk: Attribute<unknown, unknown>): (this: EntryBase & Record<string, unknown>) => Promise<boolean>;
+    abstract dropConstraints(table: Table): Promise<number[]>;
+    abstract dropFields(table: Table): Promise<void>;
+    abstract dropIndexes(table: Table, constraintIndexes: number[]): Promise<void>;
+    abstract syncConstraints(table: Table): Promise<void>;
+    abstract syncFields(table: Table): Promise<void>;
+    abstract syncIndexes(table: Table): Promise<void>;
+    abstract syncSequence(table: Table): Promise<void>;
+    abstract syncTable(table: Table): Promise<void>;
+}
+export declare class Transaction {
+    private entries;
+    protected log: (message: string) => void;
+    constructor(log: (message: string) => void);
+    addEntry(entry: EntryBase): void;
+    clean(): void;
+    commit(): Promise<void>;
+    rollback(): Promise<void>;
+}
+export {};

package/dist/cjs/index.d.ts

@@ -0,0 +1,143 @@
+import { Attribute, DB, EntryBase, ForeignKeyOptions, Transaction, Type } from "./db";
+export { Attribute, DB, EntryBase, ForeignKeyActions, ForeignKeyOptions, Index, Table, Transaction, Type } from "./db";
+export declare type TypeDefinition<T, E> = (() => Type<T, E>) | Type<T, E>;
+export interface AttributeOptions<T, E> {
+    defaultValue?: T;
+    fieldName?: string;
+    notNull?: boolean;
+    type: TypeDefinition<T, E>;
+    unique?: boolean;
+}
+export declare type AttributeDefinition<T, E> = TypeDefinition<T, E> | AttributeOptions<T, E>;
+export declare type AttributesDefinition = {
+    [key: string]: AttributeDefinition<unknown, unknown>;
+};
+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>;
+}[keyof A];
+declare type Native___<T> = T extends Type<infer N, unknown> ? N : never;
+declare type Native__<T> = T extends () => Type<infer N, infer E> ? Native___<Type<N, E>> : Native___<T>;
+declare type Native_<T, N, E> = T extends {
+    notNull: true;
+} ? Native___<Type<N, E>> : Native___<Type<N, E>> | null;
+declare type Native<T> = T extends AttributeOptions<infer N, infer E> ? Native_<T, N, E> : Native__<T> | null;
+export declare type IndexAttributes = string[] | string;
+export interface IndexOptions {
+    attributes: IndexAttributes;
+    type?: "btree" | "hash";
+    unique?: boolean;
+}
+export declare type IndexDefinition = IndexAttributes | IndexOptions;
+export declare type IndexesDefinition = {
+    [key: string]: IndexDefinition;
+};
+interface BaseModelOptions {
+    indexes?: IndexesDefinition;
+    sync?: boolean;
+    tableName?: string;
+}
+export interface ModelOptions extends BaseModelOptions {
+    int8id?: boolean;
+    parent?: Attribute<unknown, EntryBase>;
+    primaryKey?: string;
+}
+declare type ConditionAttribute<T> = T | ["=" | ">" | "<" | ">=" | "<=" | "<>", T] | ["IN", T[]] | ["IS NULL"] | ["LIKE", string] | ["NOT"];
+declare type ConditionBase<A extends AttributesDefinition> = string | {
+    [a in keyof A]?: ConditionAttribute<Native<A[a]>>;
+};
+declare type Condition<A extends AttributesDefinition> = ConditionBase<A> | ["NOT", Condition<A>] | ["AND", ...Condition<A>[]] | ["OR", ...Condition<A>[]];
+declare type Order_<A extends AttributesDefinition> = keyof A | `-${string & keyof A}`;
+declare type Order<A extends AttributesDefinition> = Order_<A> | Order_<A>[];
+declare type UnionToIntersection<U> = (U extends unknown ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+declare type IsUnion<T> = [T] extends [UnionToIntersection<T>] ? false : true;
+declare type BaseKeyType<B extends boolean> = IsUnion<B> extends true ? number : B extends true ? string : number;
+declare type KeyType<B extends boolean, P extends ModelStd> = P extends new () => EntryBase ? (P extends Attribute<infer T, EntryBase> ? T : never) : BaseKeyType<B>;
+declare type ForeignKey<A> = A extends AttributeDefinition<unknown, infer E> ? () => Promise<E> : never;
+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 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"] : {
+    id: {
+        notNull: true;
+        type: Type<BaseKeyType<B>, unknown>;
+    };
+}>;
+export interface ModelLoad<A extends AttributesDefinition, E extends EntryBase> {
+    load(where: Condition<A>, order?: Order<A>, limit?: number, tx?: Transaction, lock?: boolean): Promise<E[]>;
+    load(where: Condition<A>, order?: Order<A>, tx?: Transaction, lock?: boolean): Promise<E[]>;
+    load(where: Condition<A>, limit?: number, tx?: Transaction, lock?: boolean): Promise<E[]>;
+    load(where: Condition<A>, tx: Transaction, lock?: boolean): Promise<E[]>;
+    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;
+    foreignKeys: Record<string, boolean>;
+    methods: EM;
+    parent?: ModelStd;
+    tableName: string;
+} & {
+    [a in keyof A]: Attribute<Native<A[a]>, E>;
+} & 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;
+    foreignKeys: Record<string, boolean>;
+    methods: EntryBase;
+    parent?: ModelStd;
+};
+export declare type Entry<M> = M extends new () => infer E ? E : never;
+export declare type OrderBy<M> = M extends {
+    load(where: unknown, order?: infer T): void;
+    load(where: unknown, limit?: number): void;
+    load(where: unknown, tx?: Transaction): void;
+} ? Exclude<T, undefined> : never;
+export declare type Where<M> = M extends {
+    load(where: infer T): void;
+} ? T : never;
+export interface SedentaryOptions {
+    autoSync?: boolean;
+    log?: ((message: string) => void) | null;
+    sync?: boolean;
+}
+export declare class Sedentary<D extends DB<T>, T extends Transaction> {
+    protected autoSync: boolean;
+    protected db: D;
+    protected doSync: boolean;
+    protected log: (message: string) => void;
+    private models;
+    constructor(options?: SedentaryOptions);
+    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>;
+    Int8(): Type<bigint, unknown>;
+    JSON<T>(): Type<T, unknown>;
+    Number(): Type<number, unknown>;
+    VarChar<S extends string>(size?: number): Type<S, unknown>;
+    private checkDB;
+    private checkOrderBy;
+    private checkSize;
+    private createWhere;
+    connect(sync?: boolean): Promise<void>;
+    sync(): Promise<void>;
+    end(): Promise<void>;
+    begin(): Promise<T>;
+    escape(value: unknown): string;
+    model<A extends AttributesDefinition, B extends boolean, K extends string, P extends ModelStd, EM extends EntryMethods<A, P>>(modelName: string, attributes: A, options?: BaseModelOptions & {
+        int8id?: B;
+        parent?: P;
+        primaryKey?: K | keyof A;
+    }): Model<K extends keyof A ? Native<A[K]> : KeyType<B, P>, ModelAttributes<A, B, K, P>, EM>;
+    model<A extends AttributesDefinition, B extends boolean, K extends string, P extends ModelStd, EA extends EntryBaseAttributes<ModelAttributes<A, B, K, P>>, EM extends EntryMethods<A, P>, M extends Record<string, <S extends M>(this: EA & EM & S, ...args: any[]) => void>>(modelName: string, attributes: A, options: BaseModelOptions & {
+        int8id?: B;
+        parent?: P;
+        primaryKey?: K | keyof A;
+    }, methods: M & Record<keyof M, (this: EA & EM & M, ...args: any[]) => void>): Model<K extends keyof A ? Native<A[K]> : KeyType<B, P>, ModelAttributes<A, B, K, P>, EM & M>;
+}

package/dist/cjs/index.js

@@ -39,30 +39,33 @@ class Sedentary {
         this.log = log ? log : log === null ? () => { } : console.log;
         this.doSync = sync;
     }
-    BOOLEAN() {
+    Boolean() {
         return new db_1.Type({ base: Boolean, type: "BOOLEAN" });
     }
-    DATETIME() {
+    DateTime() {
         return new db_1.Type({ base: Date, type: "DATETIME" });
     }
-    FKEY(attribute, options) {
+    FKey(attribute, options) {
         const { attributeName, base, fieldName, size, tableName, type } = attribute;
         return new db_1.Type({ base, foreignKey: { attributeName, fieldName, options, tableName }, 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)
             throw new Error(message);
         return new db_1.Type({ base: Number, size, type: "INT" });
     }
-    INT8() {
+    Int8() {
         return new db_1.Type({ base: BigInt, size: 8, type: "INT8" });
     }
-    NUMBER() {
+    JSON() {
+        return new db_1.Type({ base: Object, type: "JSON" });
+    }
+    Number() {
         return new db_1.Type({ base: Number, type: "NUMBER" });
     }
-    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" });
@@ -195,7 +198,7 @@ class Sedentary {
         await this.db.end();
         this.log("Connection closed");
     }
-    async begin() {
+    begin() {
         return this.db.begin();
     }
     escape(value) {
@@ -227,12 +230,12 @@ class Sedentary {
             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 };
-        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 })];
-        let constraints = [{ attribute: aarray[0], constraintName: `${tableName}_id_unique`, type: "u" }];
-        const iarray = [];
-        let pk = aarray[0];
+        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 })];
+        let constraints = [{ attribute: aArray[0], constraintName: `${tableName}_id_unique`, type: "u" }];
+        const iArray = [];
+        let pk = aArray[0];
         let attr2field = { id: "id" };
         if (!methods)
             methods = {};
@@ -249,16 +252,16 @@ class Sedentary {
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
             attr2field = parent ? { ...parent.attr2field } : {};
             autoIncrement = false;
-            aarray = [];
+            aArray = [];
             constraints = [];
         }
         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) => {
-                if (func === this.FKEY)
-                    throw new Error(`${message1} 'this.FKEY' can't be used directly`);
-                if (![this.BOOLEAN, this.DATETIME, this.NUMBER, this.INT, this.INT8, this.VARCHAR].includes(func))
+                if (func === this.FKey)
+                    throw new Error(`${message1} 'this.FKey' can't be used directly`);
+                if (![this.Boolean, this.DateTime, this.Int, this.JSON, this.Int8, this.Number, this.VarChar].includes(func))
                     throw new Error(`${message1} ${message2}`);
                 return new db_1.Attribute({ attributeName, defaultValue, fieldName, modelName, notNull, tableName, unique, ...func() });
             };
@@ -305,17 +308,17 @@ class Sedentary {
             if (foreignKey) {
                 const options = foreignKey.options || {};
                 if (foreignKey.options !== undefined && !(foreignKey.options instanceof Object))
-                    throw new Error(`Sedentary.FKEY: '${modelName}' model: '${attributeName}' attribute: Wrong options type, expected 'Object'`);
+                    throw new Error(`Sedentary.FKey: '${modelName}' model: '${attributeName}' attribute: Wrong options type, expected 'Object'`);
                 for (const k in options)
                     if (!["onDelete", "onUpdate"].includes(k))
-                        throw new Error(`Sedentary.FKEY: '${modelName}' model: '${attributeName}' attribute: Unknown option '${k}'`);
+                        throw new Error(`Sedentary.FKey: '${modelName}' model: '${attributeName}' attribute: Unknown option '${k}'`);
                 for (const onChange of ["onDelete", "onUpdate"]) {
                     const actions = ["cascade", "no action", "restrict", "set default", "set null"];
                     let action = options[onChange];
                     if (!action)
                         action = options[onChange] = "no action";
                     if (action && !actions.includes(action))
-                        throw new Error(`Sedentary.FKEY: '${modelName}' model: '${attributeName}' attribute: '${onChange}' option: Wrong value, expected ${actions.map(_ => `'${_}'`).join(" | ")}`);
+                        throw new Error(`Sedentary.FKey: '${modelName}' model: '${attributeName}' attribute: '${onChange}' option: Wrong value, expected ${actions.map(_ => `'${_}'`).join(" | ")}`);
                 }
                 foreignKey.options = options;
             }
@@ -328,7 +331,7 @@ class Sedentary {
             const attribute = new db_1.Attribute({ attributeName, base, defaultValue, fieldName, foreignKey, modelName, notNull, size, tableName, type, unique });
             if (primaryKey === attributeName)
                 pk = attribute;
-            aarray.push(attribute);
+            aArray.push(attribute);
             attr2field[attributeName] = fieldName;
             if (foreignKey)
                 constraints.push({ attribute, constraintName: `fkey_${fieldName}_${foreignKey.tableName}_${foreignKey.fieldName}`, type: "f" });
@@ -336,17 +339,17 @@ class Sedentary {
                 constraints.push({ attribute, constraintName: `${tableName}_${fieldName}_unique`, type: "u" });
         }
         if (indexes) {
-            const flds = 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) {
-                if (aarray.filter(({ fieldName, unique }) => unique && `${tableName}_${fieldName}_unique` === indexName).length !== 0)
+                if (aArray.some(({ fieldName, unique }) => unique && `${tableName}_${fieldName}_unique` === indexName))
                     throw new Error(`Sedentary.model: '${modelName}' model: '${indexName}' index: index name already inferred by the unique constraint on an attribute`);
                 const idx = indexes[indexName];
                 const checkAttribute = (attribute, l) => {
                     if (typeof attribute !== "string")
                         throw new Error(`Sedentary.model: '${modelName}' model: '${indexName}' index: #${l + 1} attribute: Wrong type, expected 'string'`);
-                    if (!(attribute in flds))
+                    if (!(attribute in originalAttributes))
                         throw new Error(`Sedentary.model: '${modelName}' model: '${indexName}' index: #${l + 1} attribute: Unknown attribute '${attribute}'`);
                 };
                 let attributes;
@@ -384,11 +387,11 @@ class Sedentary {
                 }
                 else
                     throw new Error(`Sedentary.model: '${modelName}' model: '${indexName}' index: Wrong type, expected 'Object'`);
-                iarray.push({ fields: attributes, indexName, type, unique });
+                iArray.push({ fields: attributes, indexName, type, unique });
             }
         }
         this.models[modelName] = true;
-        const foreignKeys = aarray
+        const foreignKeys = aArray
             .filter(_ => _.foreignKey)
             .reduce((ret, curr) => {
             ret[curr.attributeName] = true;
@@ -438,10 +441,13 @@ class Sedentary {
                     tx.addEntry(this);
             }
         };
-        const table = new db_1.Table({ autoIncrement, constraints, attributes: aarray, indexes: iarray, model: ret, parent, pk, sync, tableName });
+        const table = new db_1.Table({ attributes: aArray, autoIncrement, constraints, indexes: iArray, model: ret, parent, pk, sync, tableName });
         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" });
         const load_ = this.db.load(tableName, attr2field, pk, ret, table);
-        const load = async (where, ...args) => {
+        const load = (where, ...args) => {
             let order = undefined;
             let limit = undefined;
             let tx = undefined;
@@ -474,11 +480,10 @@ class Sedentary {
                 throw new Error(`${modelName}.load: 'order' argument: Wrong type, expected 'string | string[]'`);
             if (tx && !(tx instanceof db_1.Transaction))
                 throw new Error(`${modelName}.load: 'tx' argument: Wrong type, expected 'Transaction'`);
-            const [str] = this.createWhere(modelName, attr2field, where);
-            const ret = await load_(str, order, limit, tx, lock);
-            return ret;
+            return load_(this.createWhere(modelName, attr2field, where)[0], order, limit, tx, lock);
         };
         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 });
         Object.defineProperty(ret, "attr2field", { value: attr2field });
@@ -506,7 +511,7 @@ class Sedentary {
             return ret;
         };
         Object.defineProperty(ret.prototype.save, "name", { value: modelName + ".save" });
-        for (const attribute of aarray)
+        for (const attribute of aArray)
             Object.defineProperty(ret, attribute.attributeName, { value: attribute });
         for (const key of ["attributeName", "base", "fieldName", "modelName", "size", "tableName", "type", "unique"])
             Object.defineProperty(ret, key, { value: pk[key] });

package/dist/es/db.d.ts

@@ -0,0 +1,111 @@
+export declare class EntryBase {
+    constructor(from?: Partial<EntryBase>);
+    construct(): void;
+    postLoad(): void;
+    postRemove(): void;
+    postSave(): void;
+    preLoad(): void;
+    preRemove(): void;
+    preSave(): void;
+    remove(): Promise<boolean>;
+    save(): Promise<boolean>;
+}
+export declare type ForeignKeyActions = "cascade" | "no action" | "restrict" | "set default" | "set null";
+export interface ForeignKeyOptions {
+    onDelete?: ForeignKeyActions;
+    onUpdate?: ForeignKeyActions;
+}
+export interface Type<T, E> {
+    base: unknown;
+    entry?: E;
+    native?: T;
+    size?: number;
+    type: string;
+    foreignKey?: {
+        attributeName: string;
+        fieldName: string;
+        options?: ForeignKeyOptions;
+        tableName: string;
+    };
+}
+export declare class Type<T, E> {
+    constructor(from: Type<T, E>);
+}
+export interface Attribute<T, E> extends Type<T, E> {
+    attributeName: string;
+    defaultValue?: unknown;
+    fieldName: string;
+    modelName: string;
+    notNull: boolean;
+    tableName: string;
+    unique?: boolean;
+}
+export declare class Attribute<T, E> extends Type<T, E> {
+    constructor(from: Attribute<T, E>);
+}
+export interface Constraint {
+    attribute: Attribute<unknown, unknown>;
+    constraintName: string;
+    type: "f" | "u";
+}
+export interface Index {
+    fields: string[];
+    indexName: string;
+    type: "btree" | "hash";
+    unique: boolean;
+}
+interface ITable {
+    attributes: Attribute<unknown, unknown>[];
+    autoIncrement: boolean;
+    constraints: Constraint[];
+    indexes: Index[];
+    model: {
+        load: (where: any, order?: string[], tx?: Transaction) => Promise<EntryBase[]>;
+    };
+    parent?: Attribute<unknown, unknown>;
+    pk: Attribute<unknown, unknown>;
+    sync: boolean;
+    tableName: string;
+}
+declare const Table_base: new (defaults?: ITable | undefined) => ITable;
+export declare class Table extends Table_base {
+    autoIncrementOwn?: boolean;
+    oid?: number;
+    findField(name: string): Attribute<unknown, unknown>;
+}
+export declare abstract class DB<T extends Transaction> {
+    tables: Table[];
+    protected log: (message: string) => void;
+    protected sync: boolean;
+    abstract connect(): Promise<void>;
+    abstract end(): Promise<void>;
+    constructor(log: (message: string) => void);
+    findTable(name: string): Table;
+    protected indexesEq(a: Index, b: Index): boolean;
+    syncDataBase(): Promise<void>;
+    protected syncLog(message: string): void;
+    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<boolean>;
+    abstract save(tableName: string, attributes: Record<string, string>, pk: Attribute<unknown, unknown>): (this: EntryBase & Record<string, unknown>) => Promise<boolean>;
+    abstract dropConstraints(table: Table): Promise<number[]>;
+    abstract dropFields(table: Table): Promise<void>;
+    abstract dropIndexes(table: Table, constraintIndexes: number[]): Promise<void>;
+    abstract syncConstraints(table: Table): Promise<void>;
+    abstract syncFields(table: Table): Promise<void>;
+    abstract syncIndexes(table: Table): Promise<void>;
+    abstract syncSequence(table: Table): Promise<void>;
+    abstract syncTable(table: Table): Promise<void>;
+}
+export declare class Transaction {
+    private entries;
+    protected log: (message: string) => void;
+    constructor(log: (message: string) => void);
+    addEntry(entry: EntryBase): void;
+    clean(): void;
+    commit(): Promise<void>;
+    rollback(): Promise<void>;
+}
+export {};

package/dist/es/index.d.ts

@@ -0,0 +1,143 @@
+import { Attribute, DB, EntryBase, ForeignKeyOptions, Transaction, Type } from "./db";
+export { Attribute, DB, EntryBase, ForeignKeyActions, ForeignKeyOptions, Index, Table, Transaction, Type } from "./db";
+export declare type TypeDefinition<T, E> = (() => Type<T, E>) | Type<T, E>;
+export interface AttributeOptions<T, E> {
+    defaultValue?: T;
+    fieldName?: string;
+    notNull?: boolean;
+    type: TypeDefinition<T, E>;
+    unique?: boolean;
+}
+export declare type AttributeDefinition<T, E> = TypeDefinition<T, E> | AttributeOptions<T, E>;
+export declare type AttributesDefinition = {
+    [key: string]: AttributeDefinition<unknown, unknown>;
+};
+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>;
+}[keyof A];
+declare type Native___<T> = T extends Type<infer N, unknown> ? N : never;
+declare type Native__<T> = T extends () => Type<infer N, infer E> ? Native___<Type<N, E>> : Native___<T>;
+declare type Native_<T, N, E> = T extends {
+    notNull: true;
+} ? Native___<Type<N, E>> : Native___<Type<N, E>> | null;
+declare type Native<T> = T extends AttributeOptions<infer N, infer E> ? Native_<T, N, E> : Native__<T> | null;
+export declare type IndexAttributes = string[] | string;
+export interface IndexOptions {
+    attributes: IndexAttributes;
+    type?: "btree" | "hash";
+    unique?: boolean;
+}
+export declare type IndexDefinition = IndexAttributes | IndexOptions;
+export declare type IndexesDefinition = {
+    [key: string]: IndexDefinition;
+};
+interface BaseModelOptions {
+    indexes?: IndexesDefinition;
+    sync?: boolean;
+    tableName?: string;
+}
+export interface ModelOptions extends BaseModelOptions {
+    int8id?: boolean;
+    parent?: Attribute<unknown, EntryBase>;
+    primaryKey?: string;
+}
+declare type ConditionAttribute<T> = T | ["=" | ">" | "<" | ">=" | "<=" | "<>", T] | ["IN", T[]] | ["IS NULL"] | ["LIKE", string] | ["NOT"];
+declare type ConditionBase<A extends AttributesDefinition> = string | {
+    [a in keyof A]?: ConditionAttribute<Native<A[a]>>;
+};
+declare type Condition<A extends AttributesDefinition> = ConditionBase<A> | ["NOT", Condition<A>] | ["AND", ...Condition<A>[]] | ["OR", ...Condition<A>[]];
+declare type Order_<A extends AttributesDefinition> = keyof A | `-${string & keyof A}`;
+declare type Order<A extends AttributesDefinition> = Order_<A> | Order_<A>[];
+declare type UnionToIntersection<U> = (U extends unknown ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+declare type IsUnion<T> = [T] extends [UnionToIntersection<T>] ? false : true;
+declare type BaseKeyType<B extends boolean> = IsUnion<B> extends true ? number : B extends true ? string : number;
+declare type KeyType<B extends boolean, P extends ModelStd> = P extends new () => EntryBase ? (P extends Attribute<infer T, EntryBase> ? T : never) : BaseKeyType<B>;
+declare type ForeignKey<A> = A extends AttributeDefinition<unknown, infer E> ? () => Promise<E> : never;
+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 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"] : {
+    id: {
+        notNull: true;
+        type: Type<BaseKeyType<B>, unknown>;
+    };
+}>;
+export interface ModelLoad<A extends AttributesDefinition, E extends EntryBase> {
+    load(where: Condition<A>, order?: Order<A>, limit?: number, tx?: Transaction, lock?: boolean): Promise<E[]>;
+    load(where: Condition<A>, order?: Order<A>, tx?: Transaction, lock?: boolean): Promise<E[]>;
+    load(where: Condition<A>, limit?: number, tx?: Transaction, lock?: boolean): Promise<E[]>;
+    load(where: Condition<A>, tx: Transaction, lock?: boolean): Promise<E[]>;
+    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;
+    foreignKeys: Record<string, boolean>;
+    methods: EM;
+    parent?: ModelStd;
+    tableName: string;
+} & {
+    [a in keyof A]: Attribute<Native<A[a]>, E>;
+} & 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;
+    foreignKeys: Record<string, boolean>;
+    methods: EntryBase;
+    parent?: ModelStd;
+};
+export declare type Entry<M> = M extends new () => infer E ? E : never;
+export declare type OrderBy<M> = M extends {
+    load(where: unknown, order?: infer T): void;
+    load(where: unknown, limit?: number): void;
+    load(where: unknown, tx?: Transaction): void;
+} ? Exclude<T, undefined> : never;
+export declare type Where<M> = M extends {
+    load(where: infer T): void;
+} ? T : never;
+export interface SedentaryOptions {
+    autoSync?: boolean;
+    log?: ((message: string) => void) | null;
+    sync?: boolean;
+}
+export declare class Sedentary<D extends DB<T>, T extends Transaction> {
+    protected autoSync: boolean;
+    protected db: D;
+    protected doSync: boolean;
+    protected log: (message: string) => void;
+    private models;
+    constructor(options?: SedentaryOptions);
+    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>;
+    Int8(): Type<bigint, unknown>;
+    JSON<T>(): Type<T, unknown>;
+    Number(): Type<number, unknown>;
+    VarChar<S extends string>(size?: number): Type<S, unknown>;
+    private checkDB;
+    private checkOrderBy;
+    private checkSize;
+    private createWhere;
+    connect(sync?: boolean): Promise<void>;
+    sync(): Promise<void>;
+    end(): Promise<void>;
+    begin(): Promise<T>;
+    escape(value: unknown): string;
+    model<A extends AttributesDefinition, B extends boolean, K extends string, P extends ModelStd, EM extends EntryMethods<A, P>>(modelName: string, attributes: A, options?: BaseModelOptions & {
+        int8id?: B;
+        parent?: P;
+        primaryKey?: K | keyof A;
+    }): Model<K extends keyof A ? Native<A[K]> : KeyType<B, P>, ModelAttributes<A, B, K, P>, EM>;
+    model<A extends AttributesDefinition, B extends boolean, K extends string, P extends ModelStd, EA extends EntryBaseAttributes<ModelAttributes<A, B, K, P>>, EM extends EntryMethods<A, P>, M extends Record<string, <S extends M>(this: EA & EM & S, ...args: any[]) => void>>(modelName: string, attributes: A, options: BaseModelOptions & {
+        int8id?: B;
+        parent?: P;
+        primaryKey?: K | keyof A;
+    }, methods: M & Record<keyof M, (this: EA & EM & M, ...args: any[]) => void>): Model<K extends keyof A ? Native<A[K]> : KeyType<B, P>, ModelAttributes<A, B, K, P>, EM & M>;
+}

package/dist/es/index.js

@@ -33,30 +33,33 @@ export class Sedentary {
         this.log = log ? log : log === null ? () => { } : console.log;
         this.doSync = sync;
     }
-    BOOLEAN() {
+    Boolean() {
         return new Type({ base: Boolean, type: "BOOLEAN" });
     }
-    DATETIME() {
+    DateTime() {
         return new Type({ base: Date, type: "DATETIME" });
     }
-    FKEY(attribute, options) {
+    FKey(attribute, options) {
         const { attributeName, base, fieldName, size, tableName, type } = attribute;
         return new Type({ base, foreignKey: { attributeName, fieldName, options, tableName }, 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)
             throw new Error(message);
         return new Type({ base: Number, size, type: "INT" });
     }
-    INT8() {
+    Int8() {
         return new Type({ base: BigInt, size: 8, type: "INT8" });
     }
-    NUMBER() {
+    JSON() {
+        return new Type({ base: Object, type: "JSON" });
+    }
+    Number() {
         return new Type({ base: Number, type: "NUMBER" });
     }
-    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" });
@@ -189,7 +192,7 @@ export class Sedentary {
         await this.db.end();
         this.log("Connection closed");
     }
-    async begin() {
+    begin() {
         return this.db.begin();
     }
     escape(value) {
@@ -221,12 +224,12 @@ export class Sedentary {
             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 };
-        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 })];
-        let constraints = [{ attribute: aarray[0], constraintName: `${tableName}_id_unique`, type: "u" }];
-        const iarray = [];
-        let pk = aarray[0];
+        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 })];
+        let constraints = [{ attribute: aArray[0], constraintName: `${tableName}_id_unique`, type: "u" }];
+        const iArray = [];
+        let pk = aArray[0];
         let attr2field = { id: "id" };
         if (!methods)
             methods = {};
@@ -243,16 +246,16 @@ export class Sedentary {
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
             attr2field = parent ? { ...parent.attr2field } : {};
             autoIncrement = false;
-            aarray = [];
+            aArray = [];
             constraints = [];
         }
         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) => {
-                if (func === this.FKEY)
-                    throw new Error(`${message1} 'this.FKEY' can't be used directly`);
-                if (![this.BOOLEAN, this.DATETIME, this.NUMBER, this.INT, this.INT8, this.VARCHAR].includes(func))
+                if (func === this.FKey)
+                    throw new Error(`${message1} 'this.FKey' can't be used directly`);
+                if (![this.Boolean, this.DateTime, this.Int, this.JSON, this.Int8, this.Number, this.VarChar].includes(func))
                     throw new Error(`${message1} ${message2}`);
                 return new Attribute({ attributeName, defaultValue, fieldName, modelName, notNull, tableName, unique, ...func() });
             };
@@ -299,17 +302,17 @@ export class Sedentary {
             if (foreignKey) {
                 const options = foreignKey.options || {};
                 if (foreignKey.options !== undefined && !(foreignKey.options instanceof Object))
-                    throw new Error(`Sedentary.FKEY: '${modelName}' model: '${attributeName}' attribute: Wrong options type, expected 'Object'`);
+                    throw new Error(`Sedentary.FKey: '${modelName}' model: '${attributeName}' attribute: Wrong options type, expected 'Object'`);
                 for (const k in options)
                     if (!["onDelete", "onUpdate"].includes(k))
-                        throw new Error(`Sedentary.FKEY: '${modelName}' model: '${attributeName}' attribute: Unknown option '${k}'`);
+                        throw new Error(`Sedentary.FKey: '${modelName}' model: '${attributeName}' attribute: Unknown option '${k}'`);
                 for (const onChange of ["onDelete", "onUpdate"]) {
                     const actions = ["cascade", "no action", "restrict", "set default", "set null"];
                     let action = options[onChange];
                     if (!action)
                         action = options[onChange] = "no action";
                     if (action && !actions.includes(action))
-                        throw new Error(`Sedentary.FKEY: '${modelName}' model: '${attributeName}' attribute: '${onChange}' option: Wrong value, expected ${actions.map(_ => `'${_}'`).join(" | ")}`);
+                        throw new Error(`Sedentary.FKey: '${modelName}' model: '${attributeName}' attribute: '${onChange}' option: Wrong value, expected ${actions.map(_ => `'${_}'`).join(" | ")}`);
                 }
                 foreignKey.options = options;
             }
@@ -322,7 +325,7 @@ export class Sedentary {
             const attribute = new Attribute({ attributeName, base, defaultValue, fieldName, foreignKey, modelName, notNull, size, tableName, type, unique });
             if (primaryKey === attributeName)
                 pk = attribute;
-            aarray.push(attribute);
+            aArray.push(attribute);
             attr2field[attributeName] = fieldName;
             if (foreignKey)
                 constraints.push({ attribute, constraintName: `fkey_${fieldName}_${foreignKey.tableName}_${foreignKey.fieldName}`, type: "f" });
@@ -330,17 +333,17 @@ export class Sedentary {
                 constraints.push({ attribute, constraintName: `${tableName}_${fieldName}_unique`, type: "u" });
         }
         if (indexes) {
-            const flds = 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) {
-                if (aarray.filter(({ fieldName, unique }) => unique && `${tableName}_${fieldName}_unique` === indexName).length !== 0)
+                if (aArray.some(({ fieldName, unique }) => unique && `${tableName}_${fieldName}_unique` === indexName))
                     throw new Error(`Sedentary.model: '${modelName}' model: '${indexName}' index: index name already inferred by the unique constraint on an attribute`);
                 const idx = indexes[indexName];
                 const checkAttribute = (attribute, l) => {
                     if (typeof attribute !== "string")
                         throw new Error(`Sedentary.model: '${modelName}' model: '${indexName}' index: #${l + 1} attribute: Wrong type, expected 'string'`);
-                    if (!(attribute in flds))
+                    if (!(attribute in originalAttributes))
                         throw new Error(`Sedentary.model: '${modelName}' model: '${indexName}' index: #${l + 1} attribute: Unknown attribute '${attribute}'`);
                 };
                 let attributes;
@@ -378,11 +381,11 @@ export class Sedentary {
                 }
                 else
                     throw new Error(`Sedentary.model: '${modelName}' model: '${indexName}' index: Wrong type, expected 'Object'`);
-                iarray.push({ fields: attributes, indexName, type, unique });
+                iArray.push({ fields: attributes, indexName, type, unique });
             }
         }
         this.models[modelName] = true;
-        const foreignKeys = aarray
+        const foreignKeys = aArray
             .filter(_ => _.foreignKey)
             .reduce((ret, curr) => {
             ret[curr.attributeName] = true;
@@ -432,10 +435,13 @@ export class Sedentary {
                     tx.addEntry(this);
             }
         };
-        const table = new Table({ autoIncrement, constraints, attributes: aarray, indexes: iarray, model: ret, parent, pk, sync, tableName });
+        const table = new Table({ attributes: aArray, autoIncrement, constraints, indexes: iArray, model: ret, parent, pk, sync, tableName });
         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" });
         const load_ = this.db.load(tableName, attr2field, pk, ret, table);
-        const load = async (where, ...args) => {
+        const load = (where, ...args) => {
             let order = undefined;
             let limit = undefined;
             let tx = undefined;
@@ -468,11 +474,10 @@ export class Sedentary {
                 throw new Error(`${modelName}.load: 'order' argument: Wrong type, expected 'string | string[]'`);
             if (tx && !(tx instanceof Transaction))
                 throw new Error(`${modelName}.load: 'tx' argument: Wrong type, expected 'Transaction'`);
-            const [str] = this.createWhere(modelName, attr2field, where);
-            const ret = await load_(str, order, limit, tx, lock);
-            return ret;
+            return load_(this.createWhere(modelName, attr2field, where)[0], order, limit, tx, lock);
         };
         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 });
         Object.defineProperty(ret, "attr2field", { value: attr2field });
@@ -500,7 +505,7 @@ export class Sedentary {
             return ret;
         };
         Object.defineProperty(ret.prototype.save, "name", { value: modelName + ".save" });
-        for (const attribute of aarray)
+        for (const attribute of aArray)
             Object.defineProperty(ret, attribute.attributeName, { value: attribute });
         for (const key of ["attributeName", "base", "fieldName", "modelName", "size", "tableName", "type", "unique"])
             Object.defineProperty(ret, key, { value: pk[key] });

package/dist/types/db.d.ts

@@ -1,4 +1,3 @@
-export declare type Natural = Date | Record<string, unknown> | bigint | boolean | number | string | null;
 export declare class EntryBase {
     constructor(from?: Partial<EntryBase>);
     construct(): void;
@@ -16,10 +15,10 @@ export interface ForeignKeyOptions {
     onDelete?: ForeignKeyActions;
     onUpdate?: ForeignKeyActions;
 }
-export interface Type<N extends Natural, E> {
+export interface Type<T, E> {
     base: unknown;
     entry?: E;
-    native?: N;
+    native?: T;
     size?: number;
     type: string;
     foreignKey?: {
@@ -29,23 +28,23 @@ export interface Type<N extends Natural, E> {
         tableName: string;
     };
 }
-export declare class Type<N extends Natural, E> {
-    constructor(from: Type<N, E>);
+export declare class Type<T, E> {
+    constructor(from: Type<T, E>);
 }
-export interface Attribute<N extends Natural, E> extends Type<N, E> {
+export interface Attribute<T, E> extends Type<T, E> {
     attributeName: string;
-    defaultValue?: Natural;
+    defaultValue?: unknown;
     fieldName: string;
     modelName: string;
     notNull: boolean;
     tableName: string;
     unique?: boolean;
 }
-export declare class Attribute<N extends Natural, E> extends Type<N, E> {
-    constructor(from: Attribute<N, E>);
+export declare class Attribute<T, E> extends Type<T, E> {
+    constructor(from: Attribute<T, E>);
 }
 export interface Constraint {
-    attribute: Attribute<Natural, unknown>;
+    attribute: Attribute<unknown, unknown>;
     constraintName: string;
     type: "f" | "u";
 }
@@ -56,15 +55,15 @@ export interface Index {
     unique: boolean;
 }
 interface ITable {
-    attributes: Attribute<Natural, unknown>[];
+    attributes: Attribute<unknown, unknown>[];
     autoIncrement: boolean;
     constraints: Constraint[];
     indexes: Index[];
     model: {
         load: (where: any, order?: string[], tx?: Transaction) => Promise<EntryBase[]>;
     };
-    parent?: Attribute<Natural, unknown>;
-    pk: Attribute<Natural, unknown>;
+    parent?: Attribute<unknown, unknown>;
+    pk: Attribute<unknown, unknown>;
     sync: boolean;
     tableName: string;
 }
@@ -72,7 +71,7 @@ declare const Table_base: new (defaults?: ITable | undefined) => ITable;
 export declare class Table extends Table_base {
     autoIncrementOwn?: boolean;
     oid?: number;
-    findField(name: string): Attribute<Natural, unknown>;
+    findField(name: string): Attribute<unknown, unknown>;
 }
 export declare abstract class DB<T extends Transaction> {
     tables: Table[];
@@ -86,10 +85,11 @@ export declare abstract class DB<T extends Transaction> {
     syncDataBase(): Promise<void>;
     protected syncLog(message: string): void;
     abstract begin(): Promise<T>;
-    abstract escape(value: Natural): string;
-    abstract load(tableName: string, attributes: Record<string, string>, pk: Attribute<Natural, unknown>, model: new () => EntryBase, table: Table): (where: string, order?: string | string[], limit?: number, tx?: Transaction, lock?: boolean) => Promise<EntryBase[]>;
-    abstract remove(tableName: string, pk: Attribute<Natural, unknown>): (this: EntryBase & Record<string, Natural>) => Promise<boolean>;
-    abstract save(tableName: string, attributes: Record<string, string>, pk: Attribute<Natural, unknown>): (this: EntryBase & Record<string, Natural>) => Promise<boolean>;
+    abstract 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<boolean>;
+    abstract save(tableName: string, attributes: Record<string, string>, pk: Attribute<unknown, unknown>): (this: EntryBase & Record<string, unknown>) => Promise<boolean>;
     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,24 +1,24 @@
-import { Attribute, DB, EntryBase, ForeignKeyOptions, Natural, Transaction, Type } from "./db";
-export { Attribute, DB, EntryBase, ForeignKeyActions, ForeignKeyOptions, Index, Natural, Table, Transaction, Type } from "./db";
-export declare type TypeDefinition<N extends Natural, E> = (() => Type<N, E>) | Type<N, E>;
-export interface AttributeOptions<N extends Natural, E> {
-    defaultValue?: N;
+import { Attribute, DB, EntryBase, ForeignKeyOptions, Transaction, Type } from "./db";
+export { Attribute, DB, EntryBase, ForeignKeyActions, ForeignKeyOptions, Index, Table, Transaction, Type } from "./db";
+export declare type TypeDefinition<T, E> = (() => Type<T, E>) | Type<T, E>;
+export interface AttributeOptions<T, E> {
+    defaultValue?: T;
     fieldName?: string;
     notNull?: boolean;
-    type: TypeDefinition<N, E>;
+    type: TypeDefinition<T, E>;
     unique?: boolean;
 }
-export declare type AttributeDefinition<N extends Natural, E> = TypeDefinition<N, E> | AttributeOptions<N, E>;
+export declare type AttributeDefinition<T, E> = TypeDefinition<T, E> | AttributeOptions<T, E>;
 export declare type AttributesDefinition = {
-    [key: string]: AttributeDefinition<Natural, unknown>;
+    [key: string]: AttributeDefinition<unknown, unknown>;
 };
-declare type ForeignKeysAttributes<T, k> = T extends AttributeDefinition<Natural, infer E> ? (E extends EntryBase ? k : never) : never;
+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>;
 }[keyof A];
 declare type Native___<T> = T extends Type<infer N, unknown> ? N : never;
 declare type Native__<T> = T extends () => Type<infer N, infer E> ? Native___<Type<N, E>> : Native___<T>;
-declare type Native_<T, N extends Natural, E> = T extends {
+declare type Native_<T, N, E> = T extends {
     notNull: true;
 } ? Native___<Type<N, E>> : Native___<Type<N, E>> | null;
 declare type Native<T> = T extends AttributeOptions<infer N, infer E> ? Native_<T, N, E> : Native__<T> | null;
@@ -39,10 +39,10 @@ interface BaseModelOptions {
 }
 export interface ModelOptions extends BaseModelOptions {
     int8id?: boolean;
-    parent?: Attribute<Natural, EntryBase>;
+    parent?: Attribute<unknown, EntryBase>;
     primaryKey?: string;
 }
-declare type ConditionAttribute<N extends Natural> = N | ["=" | ">" | "<" | ">=" | "<=" | "<>", N] | ["IN", N[]] | ["IS NULL"] | ["LIKE", string] | ["NOT"];
+declare type ConditionAttribute<T> = T | ["=" | ">" | "<" | ">=" | "<=" | "<>", T] | ["IN", T[]] | ["IS NULL"] | ["LIKE", string] | ["NOT"];
 declare type ConditionBase<A extends AttributesDefinition> = string | {
     [a in keyof A]?: ConditionAttribute<Native<A[a]>>;
 };
@@ -53,7 +53,7 @@ declare type UnionToIntersection<U> = (U extends unknown ? (k: U) => void : neve
 declare type IsUnion<T> = [T] extends [UnionToIntersection<T>] ? false : true;
 declare type BaseKeyType<B extends boolean> = IsUnion<B> extends true ? number : B extends true ? string : number;
 declare type KeyType<B extends boolean, P extends ModelStd> = P extends new () => EntryBase ? (P extends Attribute<infer T, EntryBase> ? T : never) : BaseKeyType<B>;
-declare type ForeignKey<A> = A extends AttributeDefinition<Natural, infer E> ? () => Promise<E> : never;
+declare type ForeignKey<A> = A extends AttributeDefinition<unknown, infer E> ? () => Promise<E> : never;
 declare type EntryBaseAttributes<A extends AttributesDefinition> = {
     [a in keyof A]: Native<A[a]>;
 };
@@ -74,8 +74,9 @@ export interface ModelLoad<A extends AttributesDefinition, E extends EntryBase>
     load(where: Condition<A>, order?: Order<A>, tx?: Transaction, lock?: boolean): Promise<E[]>;
     load(where: Condition<A>, limit?: number, tx?: Transaction, lock?: boolean): Promise<E[]>;
     load(where: Condition<A>, tx: Transaction, lock?: boolean): Promise<E[]>;
+    cancel(where: Condition<A>, tx?: Transaction): Promise<number>;
 }
-declare type ModelBase<N extends Natural, A extends AttributesDefinition, EA extends Record<string, Natural>, EM extends EntryBase, E extends EntryBase> = (new (from?: Partial<EA>, tx?: Transaction) => E) & Attribute<N, E> & {
+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;
     foreignKeys: Record<string, boolean>;
     methods: EM;
@@ -84,8 +85,8 @@ declare type ModelBase<N extends Natural, A extends AttributesDefinition, EA ext
 } & {
     [a in keyof A]: Attribute<Native<A[a]>, E>;
 } & ModelLoad<A, E>;
-declare type Model<N extends Natural, A extends AttributesDefinition, EM extends EntryBase> = ModelBase<N, A, EntryBaseAttributes<A>, EM, EntryBaseAttributes<A> & EM>;
-declare type ModelStd = Attribute<Natural, EntryBase> & {
+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;
     foreignKeys: Record<string, boolean>;
     methods: EntryBase;
@@ -112,13 +113,14 @@ export declare class Sedentary<D extends DB<T>, T extends Transaction> {
     protected log: (message: string) => void;
     private models;
     constructor(options?: SedentaryOptions);
-    BOOLEAN(): Type<boolean, unknown>;
-    DATETIME(): Type<Date, unknown>;
-    FKEY<N extends Natural, E extends EntryBase>(attribute: Attribute<N, E>, options?: ForeignKeyOptions): Type<N, E>;
-    INT(size?: number): Type<number, unknown>;
-    INT8(): Type<bigint, unknown>;
-    NUMBER(): Type<number, unknown>;
-    VARCHAR(size?: number): Type<string, unknown>;
+    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>;
+    Int8(): Type<bigint, unknown>;
+    JSON<T>(): Type<T, unknown>;
+    Number(): Type<number, unknown>;
+    VarChar<S extends string>(size?: number): Type<S, unknown>;
     private checkDB;
     private checkOrderBy;
     private checkSize;
@@ -127,7 +129,7 @@ export declare class Sedentary<D extends DB<T>, T extends Transaction> {
     sync(): Promise<void>;
     end(): Promise<void>;
     begin(): Promise<T>;
-    escape(value: Natural): string;
+    escape(value: unknown): string;
     model<A extends AttributesDefinition, B extends boolean, K extends string, P extends ModelStd, EM extends EntryMethods<A, P>>(modelName: string, attributes: A, options?: BaseModelOptions & {
         int8id?: B;
         parent?: P;

package/package.json

@@ -33,16 +33,17 @@
   "repository": "https://github.com/iccicci/sedentary",
   "scripts": {
     "build": "make build",
-    "coverage": "jest --coverage --runInBand",
-    "deploy": "npm_config_registry=\"registry.npmjs.org\" npm publish",
+    "coverage": "jest --coverage --no-cache --runInBand",
+    "deploy": "make deploy",
     "precoverage": "make pretest",
     "preinstall": "if [ -f Makefile ] ; then make ; fi",
     "pretest": "make pretest",
-    "test": "jest --runInBand"
+    "test": "jest --no-cache --runInBand"
   },
   "tsd": {
     "compilerOptions": {
       "alwaysStrict": true,
+      "composite": false,
       "esModuleInterop": true,
       "moduleResolution": "Node",
       "noImplicitAny": true,
@@ -57,5 +58,5 @@
     }
   },
   "types": "./dist/types/index.d.ts",
-  "version": "0.0.42"
+  "version": "0.0.45"
 }