sedentary 0.0.39 → 0.0.40

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

@@ -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

@@ -47,7 +47,8 @@ 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;
@@ -69,11 +70,13 @@ declare type ModelAttributes<A extends AttributesDefinition, B extends boolean,
     };
 }>;
 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?: Partial<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;
@@ -90,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;

package/jest.config.js

@@ -0,0 +1,8 @@
+/** @type {import('ts-jest/dist/types').InitialOptionsTsJest} */
+module.exports = {
+  collectCoverageFrom:    ["db.ts", "index.ts"],
+  preset:                 "ts-jest",
+  testEnvironment:        "jest-environment-node-single-context",
+  testPathIgnorePatterns: ["/node_modules/", "/sedentary-pg/"],
+  testSequencer:          "./testSequencer.js"
+};

package/package.json

@@ -8,15 +8,16 @@
   "dependencies": {},
   "description": "The ORM which never needs to migrate",
   "devDependencies": {
-    "@types/mocha": "9.1.1",
+    "@types/jest": "28.1.3",
     "@types/node": "18.0.0",
     "@types/yamljs": "0.2.31",
     "@typescript-eslint/eslint-plugin": "5.30.0",
     "@typescript-eslint/parser": "5.30.0",
     "eslint": "8.18.0",
-    "mocha": "10.0.0",
-    "nyc": "15.1.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",
@@ -53,11 +54,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 +80,5 @@
     }
   },
   "types": "./dist/types/index.d.ts",
-  "version": "0.0.39"
+  "version": "0.0.40"
 }

package/testSequencer.js

@@ -0,0 +1,20 @@
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const Sequencer = require("@jest/test-sequencer").default;
+
+class CustomSequencer extends Sequencer {
+  shard(tests, { shardIndex, shardCount }) {
+    const shardSize = Math.ceil(tests.length / shardCount);
+    const shardStart = shardSize * (shardIndex - 1);
+    const shardEnd = shardSize * shardIndex;
+
+    return [...tests].sort((a, b) => (a.path > b.path ? 1 : -1)).slice(shardStart, shardEnd);
+  }
+
+  sort(tests) {
+    const copyTests = Array.from(tests);
+
+    return copyTests.sort((testA, testB) => (testA.path > testB.path ? 1 : -1));
+  }
+}
+
+module.exports = CustomSequencer;