sedentary 0.1.1 → 0.1.3

package/dist/cjs/db.js

@@ -109,9 +109,11 @@ class DB {
     }
 }
 exports.DB = DB;
+const cleanProperties = { configurable: true, value: undefined };
 class Transaction {
     constructor(log) {
         this.entries = [];
+        this.closed = false;
         this.log = log;
     }
     addEntry(entry) {
@@ -121,8 +123,8 @@ class Transaction {
     clean() {
         const { entries } = this;
         for (const entry of entries) {
-            Object.defineProperty(entry, exports.actions, { configurable: true, value: undefined });
-            Object.defineProperty(entry, exports.transaction, { configurable: true, value: undefined });
+            Object.defineProperty(entry, exports.actions, cleanProperties);
+            Object.defineProperty(entry, exports.transaction, cleanProperties);
         }
         this.entries = [];
     }
@@ -135,12 +137,18 @@ class Transaction {
         return Promise.resolve();
     }
     preCommit() {
+        if (this.closed)
+            throw new Error("Transaction already closed");
+        this.closed = true;
         const { entries } = this;
         for (const entry of entries)
             if (entry[exports.actions])
                 entry.preCommit(entry[exports.actions]);
     }
     rollback() {
+        if (this.closed)
+            throw new Error("Transaction already closed");
+        this.closed = true;
         this.clean();
         return Promise.resolve();
     }

package/dist/cjs/index.js

@@ -19,7 +19,10 @@ Object.defineProperty(exports, "Type", { enumerable: true, get: function () { re
 const attributes = Symbol("attributes");
 const methods = Symbol("methods");
 const operators = ["=", ">", "<", ">=", "<=", "<>", "IN", "IS NULL", "LIKE", "NOT"];
-const allowedOption = ["indexes", "int8id", "parent", "primaryKey", "sync", "tableName"];
+const allowedAttributeOptions = ["defaultValue", "fieldName", "notNull", "unique"];
+const allowedAttributeOptionsSize = ["size", ...allowedAttributeOptions];
+const allowedForeignKeyOptions = ["onDelete", "onUpdate", ...allowedAttributeOptions];
+const allowedModelOptions = ["indexes", "int8id", "parent", "primaryKey", "sync", "tableName"];
 const reservedNames = [
     "attr2field",
     "attributeName",
@@ -49,6 +52,7 @@ const reservedNames = [
     "type",
     "unique"
 ];
+const attributesWithSize = new Set(["VarChar", "Int", "Float"]);
 /** Model and attribute names: ASCII letters, digits, underscore; cannot start with digit. */
 const reModelAttributeName = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
 /** tableName and fieldName: ASCII lowercase letters, digits, underscore; cannot start with digit. */
@@ -93,18 +97,22 @@ class Sedentary {
         this.doSync = sync;
     }
     Boolean(options) {
+        this.checkOptions("Boolean", options);
         return new db_1.Type({ ...options, [db_1.base]: Boolean, type: "BOOLEAN" });
     }
     DateTime(options) {
+        this.checkOptions("DateTime", options);
         return new db_1.Type({ ...options, [db_1.base]: Date, type: "DATETIME" });
     }
     FKey(attribute, options) {
+        this.checkOptions("FKey", options);
         const { attributeName, fieldName, modelName, tableName, type, unique, [db_1.base]: _base, [db_1.size]: _size } = attribute;
         if (!unique)
             throw new Error(`Sedentary.FKey: '${modelName}' model: '${attributeName}' attribute: is not unique: can't be used as FKey target`);
-        return new db_1.Type({ [db_1.base]: _base, foreignKey: { attributeName, fieldName, options, tableName }, [db_1.size]: _size, type });
+        return new db_1.Type({ ...options, [db_1.base]: _base, foreignKey: { attributeName, fieldName, options, tableName }, [db_1.size]: _size, type });
     }
     Float(options) {
+        this.checkOptions("Float", options);
         const sizeFloat = "Sedentary.Float: 'size' argument: Wrong value, expected 4 or 8";
         let storageSize;
         let rest;
@@ -116,6 +124,7 @@ class Sedentary {
         return new db_1.Type({ ...rest, [db_1.base]: Number, [db_1.size]: storageSize, type: "FLOAT" });
     }
     Int(options) {
+        this.checkOptions("Int", options);
         const sizeInt = "Sedentary.Int: 'size' argument: Wrong value, expected 2 or 4";
         let storageSize;
         let rest;
@@ -127,18 +136,23 @@ class Sedentary {
         return new db_1.Type({ ...rest, [db_1.base]: Number, [db_1.size]: storageSize, type: "INT" });
     }
     Int8(options) {
+        this.checkOptions("Int8", options);
         return new db_1.Type({ ...options, [db_1.base]: BigInt, [db_1.size]: 8, type: "INT8" });
     }
     JSON(options) {
+        this.checkOptions("JSON", options);
         return new db_1.Type({ ...options, [db_1.base]: Object, type: "JSON" });
     }
     Number(options) {
+        this.checkOptions("Number", options);
         return new db_1.Type({ ...options, [db_1.base]: Number, type: "NUMBER" });
     }
     None(options) {
+        this.checkOptions("None", options);
         return new db_1.Type({ ...options, [db_1.base]: undefined, type: "NONE" });
     }
     VarChar(options) {
+        this.checkOptions("VarChar", options);
         const message = "Sedentary.VarChar: 'size' argument: Wrong value, expected positive integer";
         const [maxSize, rest] = this.checkSize(message, options);
         return new db_1.Type({ ...rest, [db_1.base]: String, [db_1.size]: maxSize, type: "VARCHAR" });
@@ -147,6 +161,16 @@ class Sedentary {
         if (!this.db)
             throw new Error("Package sedentary can't be used directly. Please check: https://www.npmjs.com/package/sedentary#disclaimer");
     }
+    checkOptions(name, options) {
+        if (options === undefined)
+            return;
+        if (typeof options !== "object" || options === null)
+            throw new Error(`Sedentary.'${name}': Wrong options type, expected 'Object`);
+        const allowedOptions = name === "FKey" ? allowedForeignKeyOptions : attributesWithSize.has(name) ? allowedAttributeOptionsSize : allowedAttributeOptions;
+        for (const key in options)
+            if (!allowedOptions.includes(key))
+                throw new Error(`Sedentary.'${name}': Unknown option '${key}'`);
+    }
     checkOrderBy(order, attributes, modelName) {
         let array = [];
         if (!order)
@@ -302,7 +326,7 @@ class Sedentary {
         if (!(options instanceof Object))
             throw new Error(`Sedentary.model: '${modelName}' model: 'options' argument: Wrong type, expected 'Object'`);
         for (const k in options)
-            if (!allowedOption.includes(k))
+            if (!allowedModelOptions.includes(k))
                 throw new Error(`Sedentary.model: '${modelName}' model: 'options' argument: Unknown '${k}' option`);
         if (options.int8id && options.parent)
             throw new Error(`Sedentary.model: '${modelName}' model: 'int8id' and 'parent' options conflict each other`);
@@ -377,11 +401,6 @@ 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'`);
-                for (const k in options)
-                    if (!["onDelete", "onUpdate"].includes(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];

package/dist/cjs/package.json

@@ -1 +1 @@
-{\"type\":\"commonjs\"}
+{"type":"commonjs"}

package/dist/es/db.js

@@ -102,8 +102,10 @@ export class DB {
         this.log(this.sync ? message : `NOT SYNCING: ${message}`);
     }
 }
+const cleanProperties = { configurable: true, value: undefined };
 export class Transaction {
     entries = [];
+    closed = false;
     log;
     constructor(log) {
         this.log = log;
@@ -115,8 +117,8 @@ export class Transaction {
     clean() {
         const { entries } = this;
         for (const entry of entries) {
-            Object.defineProperty(entry, actions, { configurable: true, value: undefined });
-            Object.defineProperty(entry, transaction, { configurable: true, value: undefined });
+            Object.defineProperty(entry, actions, cleanProperties);
+            Object.defineProperty(entry, transaction, cleanProperties);
         }
         this.entries = [];
     }
@@ -129,12 +131,18 @@ export class Transaction {
         return Promise.resolve();
     }
     preCommit() {
+        if (this.closed)
+            throw new Error("Transaction already closed");
+        this.closed = true;
         const { entries } = this;
         for (const entry of entries)
             if (entry[actions])
                 entry.preCommit(entry[actions]);
     }
     rollback() {
+        if (this.closed)
+            throw new Error("Transaction already closed");
+        this.closed = true;
         this.clean();
         return Promise.resolve();
     }

package/dist/es/index.js

@@ -3,7 +3,10 @@ export { Attribute, base, DB, deepCopy, deepDiff, EntryBase, loaded, size, Table
 const attributes = Symbol("attributes");
 const methods = Symbol("methods");
 const operators = ["=", ">", "<", ">=", "<=", "<>", "IN", "IS NULL", "LIKE", "NOT"];
-const allowedOption = ["indexes", "int8id", "parent", "primaryKey", "sync", "tableName"];
+const allowedAttributeOptions = ["defaultValue", "fieldName", "notNull", "unique"];
+const allowedAttributeOptionsSize = ["size", ...allowedAttributeOptions];
+const allowedForeignKeyOptions = ["onDelete", "onUpdate", ...allowedAttributeOptions];
+const allowedModelOptions = ["indexes", "int8id", "parent", "primaryKey", "sync", "tableName"];
 const reservedNames = [
     "attr2field",
     "attributeName",
@@ -33,6 +36,7 @@ const reservedNames = [
     "type",
     "unique"
 ];
+const attributesWithSize = new Set(["VarChar", "Int", "Float"]);
 /** Model and attribute names: ASCII letters, digits, underscore; cannot start with digit. */
 const reModelAttributeName = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
 /** tableName and fieldName: ASCII lowercase letters, digits, underscore; cannot start with digit. */
@@ -80,18 +84,22 @@ export class Sedentary {
         this.doSync = sync;
     }
     Boolean(options) {
+        this.checkOptions("Boolean", options);
         return new Type({ ...options, [base]: Boolean, type: "BOOLEAN" });
     }
     DateTime(options) {
+        this.checkOptions("DateTime", options);
         return new Type({ ...options, [base]: Date, type: "DATETIME" });
     }
     FKey(attribute, options) {
+        this.checkOptions("FKey", options);
         const { attributeName, fieldName, modelName, tableName, type, unique, [base]: _base, [size]: _size } = attribute;
         if (!unique)
             throw new Error(`Sedentary.FKey: '${modelName}' model: '${attributeName}' attribute: is not unique: can't be used as FKey target`);
-        return new Type({ [base]: _base, foreignKey: { attributeName, fieldName, options, tableName }, [size]: _size, type });
+        return new Type({ ...options, [base]: _base, foreignKey: { attributeName, fieldName, options, tableName }, [size]: _size, type });
     }
     Float(options) {
+        this.checkOptions("Float", options);
         const sizeFloat = "Sedentary.Float: 'size' argument: Wrong value, expected 4 or 8";
         let storageSize;
         let rest;
@@ -103,6 +111,7 @@ export class Sedentary {
         return new Type({ ...rest, [base]: Number, [size]: storageSize, type: "FLOAT" });
     }
     Int(options) {
+        this.checkOptions("Int", options);
         const sizeInt = "Sedentary.Int: 'size' argument: Wrong value, expected 2 or 4";
         let storageSize;
         let rest;
@@ -114,18 +123,23 @@ export class Sedentary {
         return new Type({ ...rest, [base]: Number, [size]: storageSize, type: "INT" });
     }
     Int8(options) {
+        this.checkOptions("Int8", options);
         return new Type({ ...options, [base]: BigInt, [size]: 8, type: "INT8" });
     }
     JSON(options) {
+        this.checkOptions("JSON", options);
         return new Type({ ...options, [base]: Object, type: "JSON" });
     }
     Number(options) {
+        this.checkOptions("Number", options);
         return new Type({ ...options, [base]: Number, type: "NUMBER" });
     }
     None(options) {
+        this.checkOptions("None", options);
         return new Type({ ...options, [base]: undefined, type: "NONE" });
     }
     VarChar(options) {
+        this.checkOptions("VarChar", options);
         const message = "Sedentary.VarChar: 'size' argument: Wrong value, expected positive integer";
         const [maxSize, rest] = this.checkSize(message, options);
         return new Type({ ...rest, [base]: String, [size]: maxSize, type: "VARCHAR" });
@@ -134,6 +148,16 @@ export class Sedentary {
         if (!this.db)
             throw new Error("Package sedentary can't be used directly. Please check: https://www.npmjs.com/package/sedentary#disclaimer");
     }
+    checkOptions(name, options) {
+        if (options === undefined)
+            return;
+        if (typeof options !== "object" || options === null)
+            throw new Error(`Sedentary.'${name}': Wrong options type, expected 'Object`);
+        const allowedOptions = name === "FKey" ? allowedForeignKeyOptions : attributesWithSize.has(name) ? allowedAttributeOptionsSize : allowedAttributeOptions;
+        for (const key in options)
+            if (!allowedOptions.includes(key))
+                throw new Error(`Sedentary.'${name}': Unknown option '${key}'`);
+    }
     checkOrderBy(order, attributes, modelName) {
         let array = [];
         if (!order)
@@ -289,7 +313,7 @@ export class Sedentary {
         if (!(options instanceof Object))
             throw new Error(`Sedentary.model: '${modelName}' model: 'options' argument: Wrong type, expected 'Object'`);
         for (const k in options)
-            if (!allowedOption.includes(k))
+            if (!allowedModelOptions.includes(k))
                 throw new Error(`Sedentary.model: '${modelName}' model: 'options' argument: Unknown '${k}' option`);
         if (options.int8id && options.parent)
             throw new Error(`Sedentary.model: '${modelName}' model: 'int8id' and 'parent' options conflict each other`);
@@ -364,11 +388,6 @@ 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'`);
-                for (const k in options)
-                    if (!["onDelete", "onUpdate"].includes(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];

package/dist/types/db.d.ts

@@ -117,6 +117,7 @@ export declare abstract class DB<T extends Transaction> {
 }
 export declare class Transaction {
     private entries;
+    private closed;
     protected log: (message: string) => void;
     constructor(log: (message: string) => void);
     addEntry(entry: EntryBase): void;

package/dist/types/index.d.ts

@@ -6,6 +6,7 @@ export interface AttributeOptions<T, N extends boolean> {
     notNull?: N;
     unique?: boolean;
 }
+export type AttributeOptionsFKey<T, N extends boolean> = ForeignKeyOptions & AttributeOptions<T, N>;
 export interface AttributeOptionsSize<T, N extends boolean> extends AttributeOptions<T, N> {
     size?: number;
 }
@@ -123,7 +124,11 @@ export declare class Sedentary<D extends DB<T>, T extends Transaction> {
     constructor(options?: SedentaryOptions);
     Boolean<O extends AttributeOptions<boolean, boolean> | undefined = undefined>(options?: O): Type<boolean, NotNull<O>, unknown>;
     DateTime<O extends AttributeOptions<Date, boolean> | undefined = undefined>(options?: O): Type<Date, NotNull<O>, unknown>;
-    FKey<T, E extends EntryBase>(attribute: Attribute<T, boolean, E>, options?: ForeignKeyOptions): Type<T, boolean, E>;
+    FKey<T, E extends EntryBase>(attribute: Attribute<T, boolean, E>): Type<T, false, E>;
+    FKey<T, E extends EntryBase>(attribute: Attribute<T, boolean, E>, options: {
+        notNull: true;
+    } & AttributeOptionsFKey<T, boolean>): Type<T, true, E>;
+    FKey<T, E extends EntryBase>(attribute: Attribute<T, boolean, E>, options: AttributeOptionsFKey<T, boolean>): Type<T, boolean, E>;
     Float<O extends AttributeOptionsSize<number, boolean> | undefined = undefined>(options?: O): Type<number, NotNull<O>, unknown>;
     Int<O extends AttributeOptionsSize<number, boolean> | undefined = undefined>(options?: O): Type<number, NotNull<O>, unknown>;
     Int8<O extends AttributeOptions<bigint, boolean> | undefined = undefined>(options?: O): Type<bigint, NotNull<O>, unknown>;
@@ -144,6 +149,7 @@ export declare class Sedentary<D extends DB<T>, T extends Transaction> {
     } & AttributeOptionsSize<S, boolean>): Type<S, true, unknown>;
     VarChar<S extends string = string>(options: AttributeOptionsSize<S, boolean>): Type<S, boolean, unknown>;
     private checkDB;
+    private checkOptions;
     private checkOrderBy;
     private checkSize;
     private createWhere;

package/package.json

@@ -38,5 +38,5 @@
     "preinstall": "if [ -f Makefile ] ; then make ; fi"
   },
   "types": "./dist/types/index.d.ts",
-  "version": "0.1.1"
+  "version": "0.1.3"
 }