sedentary 0.0.22 → 0.0.23

package/{lib/db.d.ts → db.d.ts}

@@ -31,7 +31,7 @@ export declare class Type<N extends Natural, E> {
 }
 export interface Attribute<N extends Natural, E> extends Type<N, E> {
     attributeName: string;
-    defaultValue?: unknown;
+    defaultValue?: Natural;
     fieldName: string;
     modelName: string;
     notNull: boolean;
@@ -57,7 +57,7 @@ interface ITable {
     autoIncrement: boolean;
     constraints: Constraint[];
     indexes: Index[];
-    parent: any;
+    parent?: Attribute<Natural, unknown>;
     sync: boolean;
     tableName: string;
 }
@@ -78,6 +78,8 @@ export declare abstract class DB {
     protected indexesEq(a: Index, b: Index): boolean;
     syncDataBase(): Promise<void>;
     protected syncLog(message: string): void;
+    abstract escape(value: Natural): string;
+    abstract save(tableName: string, attributes: Attribute<Natural, unknown>[]): (this: Record<string, Natural>) => Promise<boolean>;
     abstract dropConstraints(table: Table): Promise<number[]>;
     abstract dropFields(table: Table): Promise<void>;
     abstract dropIndexes(table: Table, constraintIndexes: number[]): Promise<void>;
@@ -87,4 +89,6 @@ export declare abstract class DB {
     abstract syncSequence(table: Table): Promise<void>;
     abstract syncTable(table: Table): Promise<void>;
 }
+export declare class Transaction {
+}
 export {};

package/{lib/db.js → db.js}

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DB = exports.Table = exports.Attribute = exports.Type = exports.EntryBase = void 0;
+exports.Transaction = exports.DB = exports.Table = exports.Attribute = exports.Type = exports.EntryBase = void 0;
 class EntryBase {
     constructor(from) {
         if (from === "load")
@@ -85,3 +85,6 @@ class DB {
     }
 }
 exports.DB = DB;
+class Transaction {
+}
+exports.Transaction = Transaction;

package/index.d.ts

@@ -1,5 +1,5 @@
-import { Attribute, DB, EntryBase, ForeignKeyOptions, Natural, Type } from "./lib/db";
-export { EntryBase, ForeignKeyActions, ForeignKeyOptions, Natural, Type } from "./lib/db";
+import { Attribute, DB, EntryBase, ForeignKeyOptions, Natural, Type } from "./db";
+export { EntryBase, ForeignKeyActions, ForeignKeyOptions, Natural, 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;
@@ -36,10 +36,10 @@ interface BaseModelOptions {
 }
 export interface ModelOptions extends BaseModelOptions {
     int8id?: boolean;
-    parent?: Type<Natural, EntryBase>;
+    parent?: Attribute<Natural, EntryBase>;
     primaryKey?: string;
 }
-declare type ConditionAttribute<N extends Natural> = N | [">" | "<" | ">=" | "<=" | "<>", N] | ["LIKE", string] | ["IN", ...N[]];
+declare type ConditionAttribute<N extends Natural> = N | [">" | "<" | ">=" | "<=" | "<>", N] | ["IN", ...N[]] | ["IS NULL"] | ["LIKE", string];
 declare type ConditionBase<A extends AttributesDefinition> = string | {
     [a in keyof A]?: ConditionAttribute<Native<A[a]>>;
 };
@@ -83,24 +83,27 @@ export declare type Where<M> = M extends {
     load: (where: infer T) => void;
 } ? Exclude<T, undefined> : never;
 export interface SedentaryOptions {
+    autoSync?: boolean;
     log?: ((message: string) => void) | null;
-    serverless?: boolean;
     sync?: boolean;
 }
 export declare class Sedentary {
+    protected autoSync: boolean;
     protected db: DB;
     protected log: (...data: unknown[]) => void;
     protected sync: boolean;
     private models;
-    constructor(filename: string, options?: SedentaryOptions);
+    constructor(options?: SedentaryOptions);
     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<string, unknown>;
     VARCHAR(size?: number): Type<string, unknown>;
+    checkDB(): void;
     checkSize(size: number, message: string): number;
-    connect(): Promise<void>;
+    connect(sync?: boolean): Promise<void>;
     end(): Promise<void>;
+    escape(value: Natural): 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;
@@ -112,4 +115,3 @@ export declare class Sedentary {
         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>;
 }
-export declare const Package: typeof Sedentary;

package/index.js

@@ -1,37 +1,37 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Package = exports.Sedentary = exports.Type = exports.EntryBase = void 0;
-const db_1 = require("./lib/db");
-const minidb_1 = require("./lib/minidb");
-var db_2 = require("./lib/db");
+exports.Sedentary = exports.Type = exports.EntryBase = void 0;
+const db_1 = require("./db");
+var db_2 = require("./db");
 Object.defineProperty(exports, "EntryBase", { enumerable: true, get: function () { return db_2.EntryBase; } });
 Object.defineProperty(exports, "Type", { enumerable: true, get: function () { return db_2.Type; } });
 const allowedOption = ["indexes", "int8id", "parent", "primaryKey", "sync", "tableName"];
 const reservedNames = [
     ...["attributeName", "attributes", "base", "class", "construct", "constructor", "defaultValue", "entry", "fieldName", "foreignKeys", "load"],
-    ...["methods", "name", "postLoad", "postSave", "preLoad", "preSave", "primaryKey", "prototype", "save", "size", "tableName", "type"]
+    ...["loaded", "methods", "name", "postLoad", "postSave", "preLoad", "preSave", "primaryKey", "prototype", "save", "size", "tableName", "tx", "type"]
 ];
 class Sedentary {
-    constructor(filename, options) {
+    constructor(options) {
         this.sync = true;
         this.models = {};
-        if (typeof filename !== "string")
-            throw new Error("new Sedentary: 'filename' argument: Wrong type, expected 'string'");
         if (!options)
             options = {};
         if (!(options instanceof Object))
             throw new Error("new Sedentary: 'options' argument: Wrong type, expected 'Object'");
         for (const k in options)
-            if (!["log", "sync"].includes(k))
+            if (!["autoSync", "log", "sync"].includes(k))
                 throw new Error(`new Sedentary: 'options' argument: Unknown '${k}' option`);
-        const { log, sync } = Object.assign({ sync: true }, options);
+        const { autoSync, log, sync } = Object.assign({ autoSync: true, sync: true }, options);
+        if (typeof autoSync !== "boolean")
+            throw new Error("new Sedentary: 'autoSync' option: Wrong type, expected 'boolean'");
         if (log !== null && log !== undefined && !(log instanceof Function))
             throw new Error("new Sedentary: 'log' option: Wrong type, expected 'null' or 'Function'");
         if (typeof sync !== "boolean")
             throw new Error("new Sedentary: 'sync' option: Wrong type, expected 'boolean'");
+        this.autoSync = autoSync;
+        this.db = null;
         // eslint-disable-next-line no-console
         this.log = log ? log : log === null ? () => { } : console.log;
-        this.db = new minidb_1.MiniDB(filename, this.log);
         this.sync = sync;
     }
     DATETIME() {
@@ -56,6 +56,10 @@ class Sedentary {
         size = size ? this.checkSize(size, message) : undefined;
         return new db_1.Type({ base: String, size, type: "VARCHAR" });
     }
+    checkDB() {
+        if (!this.db)
+            throw new Error("Package sedentary can't be used directly. Please check: https://www.npmjs.com/package/sedentary#disclaimer");
+    }
     checkSize(size, message) {
         const str = size.toString();
         const parsed = parseInt(str, 10);
@@ -63,13 +67,17 @@ class Sedentary {
             throw new Error(message);
         return parsed;
     }
-    async connect() {
+    async connect(sync) {
         try {
+            this.checkDB();
             this.log("Connecting...");
             await this.db.connect();
-            this.log("Connected, syncing...");
-            await this.db.syncDataBase();
-            this.log("Synced");
+            this.log("Connected");
+            if (this.autoSync || sync) {
+                this.log("Syncing...");
+                await this.db.syncDataBase();
+                this.log("Synced");
+            }
         }
         catch (e) {
             this.log("Connecting: " + (e instanceof Error ? e.message : JSON.stringify(e)));
@@ -81,8 +89,12 @@ class Sedentary {
         await this.db.end();
         this.log("Connection closed");
     }
+    escape(value) {
+        return this.db.escape(value);
+    }
     /* eslint-enable @typescript-eslint/no-explicit-any */
     model(modelName, attributes, options, methods) {
+        this.checkDB();
         if (typeof modelName !== "string")
             throw new Error("Sedentary.model: 'name' argument: Wrong type, expected 'string'");
         if (this.models[modelName])
@@ -319,9 +331,8 @@ class Sedentary {
         Object.defineProperty(ret, "foreignKeys", { value: foreignKeys });
         Object.defineProperty(ret, "methods", { value: methods });
         Object.assign(ret.prototype, methods);
-        ret.prototype.save = function () {
-            return Promise.resolve(false);
-        };
+        ret.prototype.save = this.db.save(tableName, aarray);
+        Object.defineProperty(ret.prototype.save, "name", { value: modelName + ".save" });
         for (const attribute of aarray)
             Object.defineProperty(ret, attribute.attributeName, { value: attribute });
         for (const key of ["attributeName", "base", "fieldName", "modelName", "size", "tableName", "type", "unique"])
@@ -330,4 +341,3 @@ class Sedentary {
     }
 }
 exports.Sedentary = Sedentary;
-exports.Package = Sedentary;

package/package.json

@@ -78,5 +78,5 @@
     }
   },
   "types": "index.d.ts",
-  "version": "0.0.22"
+  "version": "0.0.23"
 }

package/lib/minidb.d.ts

@@ -1,17 +0,0 @@
-import { DB, Table } from "./db";
-export declare class MiniDB extends DB {
-    private body;
-    private file;
-    constructor(filename: string, log: (message: string) => void);
-    connect(): Promise<void>;
-    dropConstraints(table: Table): Promise<number[]>;
-    dropFields(table: Table): Promise<void>;
-    dropIndexes(table: Table, constraintIndexes: number[]): Promise<void>;
-    end(): Promise<void>;
-    save(): Promise<void>;
-    syncConstraints(table: Table): Promise<void>;
-    syncIndexes(table: Table): Promise<void>;
-    syncFields(table: Table): Promise<void>;
-    syncSequence(table: Table): Promise<void>;
-    syncTable(table: Table): Promise<void>;
-}

package/lib/minidb.js

@@ -1,191 +0,0 @@
-"use strict";
-/* eslint-disable @typescript-eslint/no-explicit-any */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MiniDB = void 0;
-const db_1 = require("./db");
-const fs_1 = require("fs");
-const { readFile, writeFile } = fs_1.promises;
-class MiniDB extends db_1.DB {
-    constructor(filename, log) {
-        super(log);
-        this.file = filename;
-    }
-    async connect() {
-        this.body = { next: {}, tables: {} };
-        try {
-            this.body = JSON.parse((await readFile(this.file)).toString());
-        }
-        catch (e) {
-            const err = e;
-            if (err.code !== "ENOENT")
-                throw e;
-        }
-    }
-    async dropConstraints(table) {
-        const { constraints } = this.body.tables[table.tableName] || { constraints: { f: {}, u: {} } };
-        for (const constraint of Object.keys(constraints.f).sort()) {
-            const arr = table.constraints.filter(({ constraintName, type }) => constraintName === constraint && type === "f");
-            const dbOptions = arr.length ? arr[0].attribute.foreignKey.options : { onDelete: "delete", onUpdate: "delete" };
-            const inOptions = constraints.f[constraint].options;
-            if (dbOptions.onDelete !== inOptions.onDelete || dbOptions.onUpdate !== inOptions.onUpdate) {
-                this.syncLog(`'${table.tableName}': Removing foreign key: '${constraint}'`);
-                if (this.sync)
-                    delete constraints.f[constraint];
-            }
-        }
-        for (const constraint of Object.keys(constraints.u).sort()) {
-            if (!table.constraints.filter(({ constraintName, type }) => constraintName === constraint && type === "u").length) {
-                this.syncLog(`'${table.tableName}': Removing unique constraint from field: '${constraints.u[constraint].on}'`);
-                if (this.sync)
-                    delete constraints.u[constraint];
-            }
-        }
-        await this.save();
-        return [];
-    }
-    async dropFields(table) {
-        const { fields } = this.body.tables[table.tableName] || { fields: {} };
-        for (const attribute of Object.keys(fields).sort()) {
-            if (!table.findField(attribute)) {
-                this.syncLog(`'${table.tableName}': Removing field: '${attribute}'`);
-                if (this.sync)
-                    delete fields[attribute];
-            }
-        }
-        await this.save();
-    }
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    async dropIndexes(table, constraintIndexes) {
-        const { indexes } = this.body.tables[table.tableName] || { indexes: {} };
-        for (const name of Object.keys(indexes).sort()) {
-            const index = table.indexes.filter(_ => _.indexName === name);
-            if (index.length === 0 || !this.indexesEq(indexes[name], index[0])) {
-                this.syncLog(`'${table.tableName}': Removing index: '${name}'`);
-                if (this.sync)
-                    delete indexes[name];
-            }
-        }
-        await this.save();
-    }
-    async end() { }
-    async save() {
-        await writeFile(this.file, JSON.stringify(this.body));
-    }
-    async syncConstraints(table) {
-        const { constraints } = this.body.tables[table.tableName] || { constraints: { f: {}, u: {} } };
-        for (const constraint of table.constraints) {
-            const { attribute, constraintName, type } = constraint;
-            if (!constraints[type][constraintName]) {
-                if (type === "f") {
-                    const { fieldName, options, tableName } = attribute.foreignKey;
-                    const onDelete = options.onDelete !== "no action" ? ` on delete ${options.onDelete}` : "";
-                    const onUpdate = options.onUpdate !== "no action" ? ` on update ${options.onUpdate}` : "";
-                    this.syncLog(`'${table.tableName}': Adding foreign key '${constraint.constraintName}' on field: '${attribute.fieldName}' references '${tableName}(${fieldName})'${onDelete}${onUpdate}`);
-                    if (this.sync)
-                        constraints[type][constraintName] = { on: attribute.fieldName, options, fieldName, tableName };
-                }
-                else {
-                    this.syncLog(`'${table.tableName}': Adding unique constraint on field: '${attribute.fieldName}'`);
-                    if (this.sync)
-                        constraints[type][constraintName] = { on: attribute.fieldName };
-                }
-            }
-        }
-        await this.save();
-    }
-    async syncIndexes(table) {
-        const { indexes } = this.body.tables[table.tableName] || { indexes: {} };
-        for (const index of table.indexes) {
-            const { indexName } = index;
-            if (!(indexName in indexes)) {
-                this.syncLog(`'${table.tableName}': Adding index: '${indexName}' on (${index.fields.map(_ => `'${_}'`).join(", ")}) type '${index.type}'${index.unique ? " unique" : ""}`);
-                if (this.sync)
-                    indexes[indexName] = index;
-            }
-        }
-        await this.save();
-    }
-    async syncFields(table) {
-        for (const attribute of table.attributes) {
-            const { fields } = this.body.tables[table.tableName] || { fields: {} };
-            const { defaultValue, fieldName, notNull, size, type } = attribute;
-            let field = fields[fieldName];
-            if (!field) {
-                this.syncLog(`'${table.tableName}': Adding field: '${fieldName}' '${type}' '${size || ""}'`);
-                if (this.sync)
-                    field = fields[fieldName] = { size, type };
-                else
-                    field = {};
-            }
-            if (field.size !== size || field.type !== type) {
-                this.syncLog(`'${table.tableName}': Changing field type: '${fieldName}' '${type}' '${size || ""}'`);
-                if (this.sync)
-                    field = fields[fieldName] = Object.assign(Object.assign({}, field), { size, type });
-            }
-            if (field.default) {
-                if (!defaultValue) {
-                    this.syncLog(`'${table.tableName}': Dropping default value for field: '${fieldName}'`);
-                    if (this.sync)
-                        delete field.default;
-                }
-                else if (field.default !== defaultValue) {
-                    this.syncLog(`'${table.tableName}': Changing default value to '${defaultValue}' for field: '${fieldName}'`);
-                    if (this.sync)
-                        field.default = defaultValue;
-                }
-            }
-            else if (defaultValue) {
-                this.syncLog(`'${table.tableName}': Setting default value '${defaultValue instanceof Date ? defaultValue.toISOString() : defaultValue}' for field: '${fieldName}'`);
-                if (this.sync)
-                    field.default = defaultValue;
-            }
-            if (field.notNull) {
-                if (!notNull) {
-                    this.syncLog(`'${table.tableName}': Dropping not null for field: '${fieldName}'`);
-                    if (this.sync)
-                        delete field.notNull;
-                }
-            }
-            else if (notNull) {
-                this.syncLog(`'${table.tableName}': Setting not null for field: '${fieldName}'`);
-                if (this.sync)
-                    field.notNull = true;
-            }
-        }
-        await this.save();
-    }
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    async syncSequence(table) { }
-    async syncTable(table) {
-        if (this.body.tables[table.tableName]) {
-            (() => {
-                if (table.parent) {
-                    if (this.body.tables[table.tableName].parent === table.parent.tableName)
-                        return;
-                }
-                else if (!this.body.tables[table.tableName].parent)
-                    return;
-                this.syncLog(`Removing table: '${table.tableName}'`);
-                if (this.sync)
-                    delete this.body.tables[table.tableName];
-            })();
-        }
-        if (!this.body.tables[table.tableName]) {
-            this.syncLog(`Adding table: '${table.tableName}'`);
-            if (this.sync)
-                this.body.tables[table.tableName] = { constraints: { f: {}, u: {} }, fields: {}, indexes: {} };
-            if (table.parent) {
-                this.syncLog(`Setting parent: '${table.parent.tableName}' - to table: '${table.tableName}'`);
-                if (this.sync)
-                    this.body.tables[table.tableName].parent = table.parent.tableName;
-            }
-            if (table.autoIncrement && !this.body.next[table.tableName]) {
-                this.syncLog(`Setting auto increment: '${table.tableName}'`);
-                if (this.sync)
-                    this.body.next[table.tableName] = 1;
-            }
-        }
-        await this.save();
-    }
-}
-exports.MiniDB = MiniDB;

package/lib/transaction.d.ts

@@ -1,2 +0,0 @@
-export declare class Transaction {
-}

package/lib/transaction.js

@@ -1,6 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Transaction = void 0;
-class Transaction {
-}
-exports.Transaction = Transaction;