sedentary 0.0.21 → 0.0.22

package/README.md

@@ -81,10 +81,9 @@ $ npm install --save sedentary
 
 # Disclaimer
 
-**Do not use this package itself in production! This package uses a simple self made JSON-DB engine just for testing
-purposes.**
+**Do not use this package itself! It does not support any DB engine.**
 
-For a real environment a _DB engine dedicated extension_ must be used:
+A _DB engine dedicated extension_ must be used:
 
 - MySQL: planned
 - PostgreSQL: [sedentary-pg](https://github.com/iccicci/sedentary-pg#readme)

package/index.js

@@ -112,13 +112,13 @@ class Sedentary {
         let constraints = [{ attribute: aarray[0], constraintName: `${tableName}_id_unique`, type: "u" }];
         const iarray = [];
         const pk = aarray[0];
-        if (methods && !(methods instanceof Object))
+        if (!methods)
+            methods = {};
+        if (!(methods instanceof Object))
             throw new Error(`Sedentary.model: '${modelName}' model: 'methods' option: Wrong type, expected 'Object'`);
-        const originalMethods = methods;
         if (parent)
             if (!parent.attributes)
                 throw new Error(`Sedentary.model: '${modelName}' model: 'parent' option: Wrong type, expected 'Model'`);
-        //methods = (methods ? { ...(parent.methods || {}), ...methods } : parent.methods) as never;
         if (primaryKey && typeof primaryKey !== "string")
             throw new Error(`Sedentary.model: '${modelName}' model: 'primaryKey' option: Wrong type, expected 'string'`);
         if (primaryKey && !Object.keys(attributes).includes(primaryKey))
@@ -269,13 +269,12 @@ class Sedentary {
         for (const foreignKey in foreignKeys) {
             if (foreignKey + "Load" in attributes)
                 throw new Error(`Sedentary.model: '${modelName}' model: '${foreignKey}' attribute: '${foreignKey}Load' inferred methods conflicts with an attribute`);
-            if (originalMethods && foreignKey + "Load" in originalMethods)
+            if (foreignKey + "Load" in methods)
                 throw new Error(`Sedentary.model: '${modelName}' model: '${foreignKey}' attribute: '${foreignKey}Load' inferred methods conflicts with a method`);
         }
-        if (originalMethods)
-            for (const method in originalMethods)
-                if (method in attributes)
-                    throw new Error(`Sedentary.model: '${modelName}' model: '${method}' method: conflicts with an attribute`);
+        for (const method in methods)
+            if (method in attributes)
+                throw new Error(`Sedentary.model: '${modelName}' model: '${method}' method: conflicts with an attribute`);
         const checkParent = (parent) => {
             if (!parent)
                 return;
@@ -294,21 +293,20 @@ class Sedentary {
                 if (foreignKey + "Load" in parent.methods)
                     throw new Error(`Sedentary.model: '${modelName}' model: '${foreignKey}' attribute: '${foreignKey}Load' inferred methods conflicts with a method of '${parent.modelName}' model`);
             }
-            if (originalMethods) {
-                for (const method in originalMethods) {
-                    if (method in parent.attributes)
-                        throw new Error(`Sedentary.model: '${modelName}' model: '${method}' method: conflicts with an attribute of '${parent.modelName}' model`);
-                    for (const foreignKey in parent.foreignKeys)
-                        if (foreignKey + "Load" === method)
-                            throw new Error(`Sedentary.model: '${modelName}' model: '${method}' method: conflicts with an inferred methods of '${parent.modelName}' model`);
-                    if (method in parent.methods)
-                        throw new Error(`Sedentary.model: '${modelName}' model: '${method}' method: conflicts with a method of '${parent.modelName}' model`);
-                }
+            for (const method in methods) {
+                if (method in parent.attributes)
+                    throw new Error(`Sedentary.model: '${modelName}' model: '${method}' method: conflicts with an attribute of '${parent.modelName}' model`);
+                for (const foreignKey in parent.foreignKeys)
+                    if (foreignKey + "Load" === method)
+                        throw new Error(`Sedentary.model: '${modelName}' model: '${method}' method: conflicts with an inferred methods of '${parent.modelName}' model`);
+                if (method in parent.methods)
+                    throw new Error(`Sedentary.model: '${modelName}' model: '${method}' method: conflicts with a method of '${parent.modelName}' model`);
             }
             checkParent(parent.parent);
         };
         checkParent(parent);
-        const ret = function () { };
+        const ret = class extends (parent || db_1.EntryBase) {
+        };
         const load = (boh) => new Promise((resolve, reject) => setTimeout(() => {
             if (boh)
                 return resolve([new ret()]);
@@ -319,9 +317,8 @@ class Sedentary {
         Object.defineProperty(ret, "load", { value: load });
         Object.defineProperty(ret, "attributes", { value: attributes });
         Object.defineProperty(ret, "foreignKeys", { value: foreignKeys });
-        Object.defineProperty(ret, "methods", { value: methods || {} });
-        if (methods)
-            Object.assign(ret.prototype, methods);
+        Object.defineProperty(ret, "methods", { value: methods });
+        Object.assign(ret.prototype, methods);
         ret.prototype.save = function () {
             return Promise.resolve(false);
         };

package/lib/db.d.ts

@@ -1,7 +1,9 @@
 export declare type Natural = Date | Record<string, unknown> | boolean | number | string;
 export declare class EntryBase {
+    constructor(from?: Partial<EntryBase> | "load");
     construct(): void;
     postLoad(): void;
+    postSave(): void;
     preLoad(): void;
     preSave(): void;
     save(): Promise<boolean>;

package/lib/db.js

@@ -2,8 +2,18 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DB = exports.Table = exports.Attribute = exports.Type = exports.EntryBase = void 0;
 class EntryBase {
+    constructor(from) {
+        if (from === "load")
+            this.preLoad();
+        else {
+            if (from)
+                Object.assign(this, from);
+            this.construct();
+        }
+    }
     construct() { }
     postLoad() { }
+    postSave() { }
     preLoad() { }
     preSave() { }
     async save() {

package/package.json

@@ -1,6 +1,10 @@
 {
   "author": "Daniele Ricci <daniele.icc@gmail.com> (https://github.com/iccicci)",
   "bugs": "https://github.com/iccicci/sedentary/issues",
+  "contributors": [
+    "Daniele Ricci <daniele.icc@gmail.com> (https://github.com/iccicci)",
+    "yossarian <sergiybiluk@gmail.com> (https://github.com/captain-yossarian)"
+  ],
   "dependencies": {},
   "description": "The ORM which never needs to migrate",
   "devDependencies": {
@@ -74,5 +78,5 @@
     }
   },
   "types": "index.d.ts",
-  "version": "0.0.21"
+  "version": "0.0.22"
 }