sedentary 0.0.38 → 0.0.41

package/dist/cjs/index.js

@@ -72,12 +72,17 @@ class Sedentary {
             throw new Error("Package sedentary can't be used directly. Please check: https://www.npmjs.com/package/sedentary#disclaimer");
     }
     checkOrderBy(order, attributes, modelName) {
+        let array = [];
         if (!order)
             return true;
-        if (!(order instanceof Array))
+        if (typeof order === "string")
+            array = [order];
+        else if (order instanceof Array)
+            array = order;
+        else
             return false;
         const provided = {};
-        for (const attribute of order) {
+        for (const attribute of array) {
             if (typeof attribute !== "string")
                 return false;
             const attributeName = attribute.startsWith("-") ? attribute.substring(1) : attribute;
@@ -436,17 +441,41 @@ class Sedentary {
         const table = new db_1.Table({ autoIncrement, constraints, attributes: aarray, indexes: iarray, model: ret, parent, pk, sync, tableName });
         this.db.tables.push(table);
         const load_ = this.db.load(tableName, attr2field, pk, ret, table);
-        const load = async (where, order, tx, lock) => {
-            if (order instanceof db_1.Transaction) {
-                if (typeof tx === "boolean" && tx)
-                    lock = true;
-                tx = order;
-                order = undefined;
-            }
+        const load = async (where, ...args) => {
+            let order = undefined;
+            let limit = undefined;
+            let tx = undefined;
+            let lock = undefined;
+            const checkArgs = (first) => {
+                if (!args.length)
+                    return;
+                if (args[0] instanceof db_1.Transaction) {
+                    if (first)
+                        order = undefined;
+                    limit = undefined;
+                    [tx, lock] = args;
+                }
+                else if (typeof args[0] === "number") {
+                    if (first)
+                        order = undefined;
+                    [limit, tx, lock] = args;
+                }
+                else {
+                    if (first) {
+                        order = args.shift();
+                        checkArgs(false);
+                    }
+                    else
+                        throw new Error(`${modelName}.load: 'limit' argument: Wrong type, expected 'number'`);
+                }
+            };
+            checkArgs(true);
             if (!this.checkOrderBy(order, attr2field, modelName))
-                throw new Error(`${modelName}.load: 'order' argument: Wrong type, expected 'string[]'`);
+                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, tx, lock);
+            const ret = await load_(str, order, limit, tx, lock);
             return ret;
         };
         Object.defineProperty(load, "name", { value: modelName + ".load" });

package/dist/es/index.js

@@ -66,12 +66,17 @@ export class Sedentary {
             throw new Error("Package sedentary can't be used directly. Please check: https://www.npmjs.com/package/sedentary#disclaimer");
     }
     checkOrderBy(order, attributes, modelName) {
+        let array = [];
         if (!order)
             return true;
-        if (!(order instanceof Array))
+        if (typeof order === "string")
+            array = [order];
+        else if (order instanceof Array)
+            array = order;
+        else
             return false;
         const provided = {};
-        for (const attribute of order) {
+        for (const attribute of array) {
             if (typeof attribute !== "string")
                 return false;
             const attributeName = attribute.startsWith("-") ? attribute.substring(1) : attribute;
@@ -430,17 +435,41 @@ export class Sedentary {
         const table = new Table({ autoIncrement, constraints, attributes: aarray, indexes: iarray, model: ret, parent, pk, sync, tableName });
         this.db.tables.push(table);
         const load_ = this.db.load(tableName, attr2field, pk, ret, table);
-        const load = async (where, order, tx, lock) => {
-            if (order instanceof Transaction) {
-                if (typeof tx === "boolean" && tx)
-                    lock = true;
-                tx = order;
-                order = undefined;
-            }
+        const load = async (where, ...args) => {
+            let order = undefined;
+            let limit = undefined;
+            let tx = undefined;
+            let lock = undefined;
+            const checkArgs = (first) => {
+                if (!args.length)
+                    return;
+                if (args[0] instanceof Transaction) {
+                    if (first)
+                        order = undefined;
+                    limit = undefined;
+                    [tx, lock] = args;
+                }
+                else if (typeof args[0] === "number") {
+                    if (first)
+                        order = undefined;
+                    [limit, tx, lock] = args;
+                }
+                else {
+                    if (first) {
+                        order = args.shift();
+                        checkArgs(false);
+                    }
+                    else
+                        throw new Error(`${modelName}.load: 'limit' argument: Wrong type, expected 'number'`);
+                }
+            };
+            checkArgs(true);
             if (!this.checkOrderBy(order, attr2field, modelName))
-                throw new Error(`${modelName}.load: 'order' argument: Wrong type, expected 'string[]'`);
+                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, tx, lock);
+            const ret = await load_(str, order, limit, tx, lock);
             return ret;
         };
         Object.defineProperty(load, "name", { value: modelName + ".load" });

package/dist/types/db.d.ts

@@ -1,4 +1,4 @@
-export declare type Natural = BigInt | Date | Record<string, unknown> | boolean | number | string | null;
+export declare type Natural = Date | Record<string, unknown> | bigint | boolean | number | string | null;
 export declare class EntryBase {
     constructor(from?: Partial<EntryBase>);
     construct(): void;
@@ -87,7 +87,7 @@ export declare abstract class DB<T extends Transaction> {
     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[], tx?: Transaction, lock?: boolean) => Promise<EntryBase[]>;
+    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 dropConstraints(table: Table): Promise<number[]>;

package/dist/types/index.d.ts

@@ -16,9 +16,12 @@ declare type ForeignKeysAttributes<T, k> = T extends AttributeDefinition<Natural
 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 | null : never;
-declare type Native_<T> = T extends () => Type<infer N, infer E> ? Native__<Type<N, E>> : Native__<T>;
-declare type Native<T> = T extends AttributeOptions<infer N, infer E> ? Native__<Type<N, E>> : Native_<T>;
+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 {
+    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;
@@ -44,14 +47,15 @@ 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> = 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<Natural, infer E> ? () => Promise<E> : never;
 declare type EntryBaseAttributes<A extends AttributesDefinition> = {
-    [a in keyof A]?: Native<A[a]>;
+    [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> = {
@@ -60,14 +64,19 @@ declare type EntryMethodsFK<A extends AttributesDefinition> = {
 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: Type<BaseKeyType<B>, unknown>;
+    id: {
+        notNull: true;
+        type: Type<BaseKeyType<B>, unknown>;
+    };
 }>;
 export interface ModelLoad<A extends AttributesDefinition, E extends EntryBase> {
-    attributes: A;
+    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[]>;
 }
-declare type ModelBase<N extends Natural, A extends AttributesDefinition, EA extends Record<string, Natural | undefined>, EM extends EntryBase, E extends EntryBase> = (new (from?: EA, tx?: Transaction) => E) & Attribute<N, E> & {
+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> & {
+    attributes: A;
     foreignKeys: Record<string, boolean>;
     methods: EM;
     parent?: ModelStd;
@@ -84,12 +93,12 @@ declare type ModelStd = Attribute<Natural, EntryBase> & {
 };
 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, tx?: Transaction): void;
+    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, order?: unknown, tx?: Transaction): void;
-    load(where: unknown, tx?: Transaction): void;
+    load(where: infer T): void;
 } ? T : never;
 export interface SedentaryOptions {
     autoSync?: boolean;
@@ -107,7 +116,7 @@ export declare class Sedentary<D extends DB<T>, T extends Transaction> {
     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>;
+    INT8(): Type<bigint, unknown>;
     NUMBER(): Type<number, unknown>;
     VARCHAR(size?: number): Type<string, unknown>;
     private checkDB;

package/package.json

@@ -8,18 +8,19 @@
   "dependencies": {},
   "description": "The ORM which never needs to migrate",
   "devDependencies": {
-    "@types/mocha": "9.1.0",
-    "@types/node": "17.0.24",
+    "@types/jest": "28.1.3",
+    "@types/node": "18.0.0",
     "@types/yamljs": "0.2.31",
-    "@typescript-eslint/eslint-plugin": "5.19.0",
-    "@typescript-eslint/parser": "5.19.0",
-    "eslint": "8.13.0",
-    "mocha": "9.2.2",
-    "nyc": "15.1.0",
-    "prettier": "2.6.2",
-    "ts-node": "10.7.0",
-    "tsd": "0.20.0",
-    "typescript": "4.6.3",
+    "@typescript-eslint/eslint-plugin": "5.30.0",
+    "@typescript-eslint/parser": "5.30.0",
+    "eslint": "8.18.0",
+    "jest": "28.1.1",
+    "jest-environment-node-single-context": "28.0.0",
+    "prettier": "2.7.1",
+    "ts-jest": "28.0.5",
+    "ts-node": "10.8.1",
+    "tsd": "0.21.0",
+    "typescript": "4.7.4",
     "yamljs": "0.3.0"
   },
   "engines": {
@@ -42,6 +43,9 @@
   "main": "./dist/cjs/index.js",
   "module": "./dist/es/index.js",
   "name": "sedentary",
+  "optionalDependencies": {
+    "fsevents": "2.3.2"
+  },
   "prettier": {
     "arrowParens": "avoid",
     "endOfLine": "lf",
@@ -53,11 +57,11 @@
   "readmeFilename": "README.md",
   "repository": "https://github.com/iccicci/sedentary",
   "scripts": {
-    "coverage": "nyc -r lcov -r text -r text-summary -r html mocha -r ts-node/register test/*ts",
+    "coverage": "jest --coverage  --runInBand",
     "gitignore": "node -r ts-node/register utils.ts gitignore",
     "npmignore": "node -r ts-node/register utils.ts npmignore",
     "packagejson": "node -r ts-node/register utils.ts packagejson",
-    "test": "mocha -r ts-node/register test/*ts",
+    "test": "jest --runInBand --verbose",
     "travis": "node -r ts-node/register utils.ts travis",
     "tsc": "tsc -p tsconfig.cjs.json && tsc -p tsconfig.es.json && tsc -p tsconfig.types.json",
     "version": "node -r ts-node/register utils.ts version"
@@ -79,5 +83,5 @@
     }
   },
   "types": "./dist/types/index.d.ts",
-  "version": "0.0.38"
+  "version": "0.0.41"
 }