sedentary 0.0.45 → 0.0.48

package/dist/cjs/db.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Transaction = exports.DB = exports.Table = exports.Attribute = exports.Type = exports.EntryBase = void 0;
+exports.differ = exports.Transaction = exports.DB = exports.Table = exports.Attribute = exports.Type = exports.EntryBase = exports.transaction = exports.loaded = exports.actions = void 0;
+exports.actions = Symbol("actions");
+exports.loaded = Symbol("loaded");
+exports.transaction = Symbol("transaction");
 class EntryBase {
     constructor(from) {
         if (from === "load")
@@ -12,9 +15,15 @@ class EntryBase {
         }
     }
     construct() { }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    postCommit(actions) { }
     postLoad() { }
-    postRemove() { }
-    postSave() { }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    postRemove(deletedRecords) { }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    postSave(savedRecords) { }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    preCommit(actions) { }
     preLoad() { }
     preRemove() { }
     preSave() { }
@@ -96,20 +105,60 @@ class Transaction {
         this.log = log;
     }
     addEntry(entry) {
-        Object.defineProperty(entry, "tx", { configurable: true, value: this });
+        Object.defineProperty(entry, exports.transaction, { configurable: true, value: this });
         this.entries.push(entry);
     }
     clean() {
         const { entries } = this;
-        for (const entry of entries)
-            Object.defineProperty(entry, "tx", { configurable: true, value: null });
+        for (const entry of entries) {
+            Object.defineProperty(entry, exports.actions, { configurable: true, value: undefined });
+            Object.defineProperty(entry, exports.transaction, { configurable: true, value: undefined });
+        }
         this.entries = [];
     }
     async commit() {
+        const { entries } = this;
+        for (const entry of entries)
+            if (entry[exports.actions])
+                entry.postCommit(entry[exports.actions]);
         this.clean();
     }
+    preCommit() {
+        const { entries } = this;
+        for (const entry of entries)
+            if (entry[exports.actions])
+                entry.preCommit(entry[exports.actions]);
+    }
     async rollback() {
         this.clean();
     }
 }
 exports.Transaction = Transaction;
+const sortedEntries = (obj) => Object.entries(obj).sort((entryA, entryB) => (entryA[0] > entryB[0] ? -1 : 1));
+function differ(a, b) {
+    if (typeof a !== "object")
+        return a !== b;
+    if (typeof b !== "object")
+        return true;
+    if (a === null)
+        return b !== null;
+    if (b === null)
+        return true;
+    if (a instanceof Array) {
+        if (!(b instanceof Array))
+            return true;
+        for (const [i, value] of a.entries())
+            if (differ(value, b[i]))
+                return true;
+        return false;
+    }
+    const entriesA = sortedEntries(a);
+    const entriesB = sortedEntries(b);
+    if (entriesA.length !== entriesB.length)
+        return true;
+    for (const [i, [key, value]] of entriesA.entries())
+        if (key !== entriesB[i][0] || differ(value, entriesB[i][1]))
+            return true;
+    return false;
+}
+exports.differ = differ;

package/dist/cjs/index.js

@@ -1,10 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Sedentary = exports.Type = exports.Transaction = exports.Table = exports.EntryBase = exports.DB = exports.Attribute = void 0;
+exports.Sedentary = exports.Type = exports.Transaction = exports.Table = exports.EntryBase = exports.differ = exports.DB = exports.Attribute = void 0;
 const db_1 = require("./db");
 var db_2 = require("./db");
 Object.defineProperty(exports, "Attribute", { enumerable: true, get: function () { return db_2.Attribute; } });
 Object.defineProperty(exports, "DB", { enumerable: true, get: function () { return db_2.DB; } });
+Object.defineProperty(exports, "differ", { enumerable: true, get: function () { return db_2.differ; } });
 Object.defineProperty(exports, "EntryBase", { enumerable: true, get: function () { return db_2.EntryBase; } });
 Object.defineProperty(exports, "Table", { enumerable: true, get: function () { return db_2.Table; } });
 Object.defineProperty(exports, "Transaction", { enumerable: true, get: function () { return db_2.Transaction; } });
@@ -13,7 +14,7 @@ const operators = ["=", ">", "<", ">=", "<=", "<>", "IN", "IS NULL", "LIKE", "NO
 const allowedOption = ["indexes", "int8id", "parent", "primaryKey", "sync", "tableName"];
 const reservedNames = [
     ...["attr2field", "attributeName", "attributes", "base", "class", "construct", "constructor", "defaultValue", "entry", "fieldName", "foreignKeys", "load"],
-    ...["loaded", "methods", "name", "postLoad", "postSave", "preLoad", "preSave", "primaryKey", "prototype", "save", "size", "tableName", "tx", "type"]
+    ...["methods", "name", "postCommit", "postLoad", "postRemove", "postSave", "preCommit", "preLoad", "preRemove", "preSave", "primaryKey", "prototype", "save", "size", "tableName", "type"]
 ];
 class Sedentary {
     constructor(options) {
@@ -65,6 +66,9 @@ class Sedentary {
     Number() {
         return new db_1.Type({ base: Number, type: "NUMBER" });
     }
+    None() {
+        return new db_1.Type({ base: undefined, type: "NONE" });
+    }
     VarChar(size) {
         const message = "Sedentary.VARCHAR: 'size' argument: Wrong value, expected positive integer";
         size = size ? this.checkSize(size, message) : undefined;
@@ -261,7 +265,7 @@ class Sedentary {
             const call = (defaultValue, fieldName, notNull, unique, func, message1, message2) => {
                 if (func === this.FKey)
                     throw new Error(`${message1} 'this.FKey' can't be used directly`);
-                if (![this.Boolean, this.DateTime, this.Int, this.JSON, this.Int8, this.Number, this.VarChar].includes(func))
+                if (![this.Boolean, this.DateTime, this.Int, this.JSON, this.Int8, this.None, this.Number, this.VarChar].includes(func))
                     throw new Error(`${message1} ${message2}`);
                 return new db_1.Attribute({ attributeName, defaultValue, fieldName, modelName, notNull, tableName, unique, ...func() });
             };
@@ -491,24 +495,31 @@ class Sedentary {
         Object.defineProperty(ret, "foreignKeys", { value: foreignKeys });
         Object.defineProperty(ret, "methods", { value: methods });
         Object.assign(ret.prototype, methods);
+        const ensureActions = (entry) => {
+            if (!entry[db_1.actions])
+                Object.defineProperty(entry, db_1.actions, { configurable: true, value: [] });
+            return entry[db_1.actions];
+        };
         const remove = this.db.remove(tableName, pk);
         ret.prototype.remove = async function () {
-            if (!this.loaded)
+            if (!this[db_1.loaded])
                 throw new Error(`${modelName}.remove: Can't remove a never saved Entry`);
             this.preRemove();
-            const ret = await remove.call(this);
-            if (ret)
-                this.postRemove();
-            return ret;
+            const records = await remove.call(this);
+            this.postRemove(records);
+            if (this[db_1.transaction])
+                ensureActions(this).push({ action: "remove", records });
+            return records;
         };
         Object.defineProperty(ret.prototype.remove, "name", { value: modelName + ".remove" });
         const save = this.db.save(tableName, attr2field, pk);
         ret.prototype.save = async function () {
             this.preSave();
-            const ret = await save.call(this);
-            if (ret)
-                this.postSave();
-            return ret;
+            const records = await save.call(this);
+            this.postSave(records);
+            if (this[db_1.transaction])
+                ensureActions(this).push({ action: "save", records });
+            return records;
         };
         Object.defineProperty(ret.prototype.save, "name", { value: modelName + ".save" });
         for (const attribute of aArray)

package/dist/es/db.js

@@ -1,3 +1,6 @@
+export const actions = Symbol("actions");
+export const loaded = Symbol("loaded");
+export const transaction = Symbol("transaction");
 export class EntryBase {
     constructor(from) {
         if (from === "load")
@@ -9,9 +12,15 @@ export class EntryBase {
         }
     }
     construct() { }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    postCommit(actions) { }
     postLoad() { }
-    postRemove() { }
-    postSave() { }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    postRemove(deletedRecords) { }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    postSave(savedRecords) { }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    preCommit(actions) { }
     preLoad() { }
     preRemove() { }
     preSave() { }
@@ -92,19 +101,58 @@ export class Transaction {
         this.log = log;
     }
     addEntry(entry) {
-        Object.defineProperty(entry, "tx", { configurable: true, value: this });
+        Object.defineProperty(entry, transaction, { configurable: true, value: this });
         this.entries.push(entry);
     }
     clean() {
         const { entries } = this;
-        for (const entry of entries)
-            Object.defineProperty(entry, "tx", { configurable: true, value: null });
+        for (const entry of entries) {
+            Object.defineProperty(entry, actions, { configurable: true, value: undefined });
+            Object.defineProperty(entry, transaction, { configurable: true, value: undefined });
+        }
         this.entries = [];
     }
     async commit() {
+        const { entries } = this;
+        for (const entry of entries)
+            if (entry[actions])
+                entry.postCommit(entry[actions]);
         this.clean();
     }
+    preCommit() {
+        const { entries } = this;
+        for (const entry of entries)
+            if (entry[actions])
+                entry.preCommit(entry[actions]);
+    }
     async rollback() {
         this.clean();
     }
 }
+const sortedEntries = (obj) => Object.entries(obj).sort((entryA, entryB) => (entryA[0] > entryB[0] ? -1 : 1));
+export function differ(a, b) {
+    if (typeof a !== "object")
+        return a !== b;
+    if (typeof b !== "object")
+        return true;
+    if (a === null)
+        return b !== null;
+    if (b === null)
+        return true;
+    if (a instanceof Array) {
+        if (!(b instanceof Array))
+            return true;
+        for (const [i, value] of a.entries())
+            if (differ(value, b[i]))
+                return true;
+        return false;
+    }
+    const entriesA = sortedEntries(a);
+    const entriesB = sortedEntries(b);
+    if (entriesA.length !== entriesB.length)
+        return true;
+    for (const [i, [key, value]] of entriesA.entries())
+        if (key !== entriesB[i][0] || differ(value, entriesB[i][1]))
+            return true;
+    return false;
+}

package/dist/es/index.js

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

package/dist/types/db.d.ts

@@ -1,9 +1,18 @@
+export declare const actions: unique symbol;
+export declare const loaded: unique symbol;
+export declare const transaction: unique symbol;
+export interface Action {
+    action: "remove" | "save";
+    records: number | false;
+}
 export declare class EntryBase {
     constructor(from?: Partial<EntryBase>);
     construct(): void;
+    postCommit(actions: Action[]): void;
     postLoad(): void;
-    postRemove(): void;
-    postSave(): void;
+    postRemove(deletedRecords: number): void;
+    postSave(savedRecords: number | false): void;
+    preCommit(actions: Action[]): void;
     preLoad(): void;
     preRemove(): void;
     preSave(): void;
@@ -88,8 +97,8 @@ export declare abstract class DB<T extends Transaction> {
     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 remove(tableName: string, pk: Attribute<unknown, unknown>): (this: EntryBase & Record<string, unknown>) => Promise<number>;
+    abstract save(tableName: string, attributes: Record<string, string>, pk: Attribute<unknown, unknown>): (this: EntryBase & Record<string, unknown>) => Promise<number | false>;
     abstract dropConstraints(table: Table): Promise<number[]>;
     abstract dropFields(table: Table): Promise<void>;
     abstract dropIndexes(table: Table, constraintIndexes: number[]): Promise<void>;
@@ -106,6 +115,8 @@ export declare class Transaction {
     addEntry(entry: EntryBase): void;
     clean(): void;
     commit(): Promise<void>;
+    protected preCommit(): void;
     rollback(): Promise<void>;
 }
+export declare function differ(a: unknown, b: unknown): boolean;
 export {};

package/dist/types/index.d.ts

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

package/package.json

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

package/dist/cjs/db.d.ts

@@ -1,111 +0,0 @@
-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

@@ -1,143 +0,0 @@
-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/db.d.ts

@@ -1,111 +0,0 @@
-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

@@ -1,143 +0,0 @@
-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>;
-}