Merge pull request #169 from gregolsky/v4.0

RDBC-247: add singleOrNull() and firstOrNull(), verify single() and f…

Author: gregolsky

src/Documents/Session/AbstractDocumentQuery.ts

@@ -64,6 +64,7 @@ import { SuggestToken } from "./Tokens/SuggestToken";
 import { SuggestionWithTerm } from "../Queries/Suggestions/SuggestionWithTerm";
 import { SuggestionWithTerms } from "../Queries/Suggestions/SuggestionWithTerms";
 import { QueryData } from "../Queries/QueryData";
+import { passResultToCallback } from "../../Utility/PromiseUtil";
 
 /**
  * A query against a Raven index
@@ -1800,28 +1801,51 @@ export abstract class AbstractDocumentQuery<T extends object, TSelf extends Abst
 
     public async first(callback?: AbstractCallback<T>): Promise<T> {
         callback = callback || TypeUtil.NOOP;
-        const result = BluebirdPromise.resolve()
-            .then(() => this._executeQueryOperation(2))
-            .then(entries => entries[0] || null)
-            .tap(x => callback(null, x))
-            .tapCatch(err => callback(err));
-        return Promise.resolve(result);
+        const resultPromise = this._executeQueryOperation(2)
+            .then(entries => {
+                if (entries.length === 0) {
+                    throwError("InvalidOperationException", "Expected at least one result.");
+                }
+                
+                return entries[0];
+            });
+
+        passResultToCallback(resultPromise, callback);
+        return resultPromise;
+    }
+
+    public async firstOrNull(callback?: AbstractCallback<T>): Promise<T> {
+        callback = callback || TypeUtil.NOOP;
+        const resultPromise = this._executeQueryOperation(1)
+            .then(entries => entries[0] || null);
+
+        passResultToCallback(resultPromise, callback);
+        return resultPromise;
     }
 
     public async single(callback?: AbstractCallback<T>): Promise<T> {
         callback = callback || TypeUtil.NOOP;
-        const result = BluebirdPromise.resolve()
-            .then(() => this._executeQueryOperation(2))
+        const resultPromise = this._executeQueryOperation(2)
             .then(entries => {
-                if (entries.length > 1) {
-                    throw getError("InvalidOperationException", "Expected single result, got: " + entries.length);
+                if (entries.length !== 1) {
+                    throwError("InvalidOperationException", 
+                        `Expected single result, but got ${ entries.length ? "more than that" : 0 }.`);
                 }
+                
+                return entries[0];
+            });
 
-                return entries[0] || null;
-            })
-            .tap(x => callback(null, x))
-            .tapCatch(err => callback(err));
-        return Promise.resolve(result);
+        passResultToCallback(resultPromise, callback);
+        return resultPromise;
+    }
+
+    public async singleOrNull(callback?: AbstractCallback<T>): Promise<T> {
+        callback = callback || TypeUtil.NOOP;
+        const resultPromise = this._executeQueryOperation(2)
+            .then(entries => entries.length === 1 ? entries[0] : null);
+
+        passResultToCallback(resultPromise, callback);
+        return resultPromise;
     }
 
     public async count(callback?: AbstractCallback<number>): Promise<number> {

src/Documents/Session/IDocumentQueryBaseSingle.ts

@@ -10,10 +10,20 @@ export interface IDocumentQueryBaseSingle<T extends object> {
     first(callback?: AbstractCallback<T>): Promise<T>;
 
     /**
-     * Returns first element or throws if sequence is empty or contains more than one element.
+     * Returns first element if there's any or null otherwise.
+     */
+    firstOrNull(callback?: AbstractCallback<T>): Promise<T>;
+
+    /**
+     * Returns single element or throws if sequence is empty or contains more than one element.
      */
     single(callback?: AbstractCallback<T>): Promise<T>;
 
+    /**
+     * Returns single element if there's any or null otherwise.
+     */
+    singleOrNull(callback?: AbstractCallback<T>): Promise<T>;
+
     /**
      * Gets the total count of records for this query
      */

test/Issues/RDBC_247.ts

@@ -0,0 +1,148 @@
+import * as mocha from "mocha";
+import * as assert from "assert";
+import { User, Company, Order } from "../Assets/Entities";
+import { assertThrows } from "../Utils/AssertExtensions";
+import { testContext, disposeTestDocumentStore } from "../Utils/TestUtil";
+
+import {
+    RavenErrorType,
+    IDocumentStore,
+    IDocumentSession,
+} from "../../src";
+
+describe("RDBC-247", function () {
+
+    let store: IDocumentStore;
+
+    beforeEach(async function () {
+        store = await testContext.getDocumentStore();
+    });
+
+    afterEach(async () => 
+        await disposeTestDocumentStore(store));
+
+    beforeEach(async () => {
+        const session = store.openSession();
+        await session.store(Object.assign(new User(), { name: "John" }));
+        await session.store(Object.assign(new User(), { name: "John2" }));
+        await session.store(Object.assign(new User(), { name: "John3" }));
+        await session.store(Object.assign(new User(), { name: "John4" }));
+        await session.saveChanges();
+    });
+
+    let session: IDocumentSession;
+
+    beforeEach(() => session = store.openSession());
+
+    describe("single()", function () {
+
+        it("should throw if 0 results", async function () {
+            await assertThrows(
+                async () => await session.query({ collection: "users" })
+                    .whereEquals("name", "Merry")
+                    .single(),
+                err => {
+                    assert.strictEqual(err.name, "InvalidOperationException");
+                    assert.strictEqual(err.message, "Expected single result, but got 0.");
+                });
+        });
+
+        it("should throw if more than 1 result", async function() {
+            await assertThrows(
+                async () => await session.query({ collection: "users" }).single(),
+                err => {
+                    assert.strictEqual(err.name, "InvalidOperationException");
+                    assert.strictEqual(err.message, "Expected single result, but got more than that.");
+                });
+        
+        });
+
+        it("should return exactly 1 result", async function() {
+            const result = await session.query<User>({ collection: "users" })
+                .whereEquals("name", "John")
+                .single();
+
+            assert.ok(result);
+            assert.ok(result instanceof User);
+            assert.strictEqual(result.name, "John");
+        });
+
+    });
+
+    describe("singleOrNull()", function () {
+
+        it("should return null if 0 results", async function () {
+            const result = await session.query<User>({ collection: "users" })
+                .whereEquals("name", "Merry")
+                .singleOrNull();
+            assert.strictEqual(result, null);
+        });
+
+        it("should return null if more than 1 result", async function() {
+            const result = await session.query<User>({ collection: "users" })
+                .singleOrNull();
+            assert.strictEqual(result, null);
+        });
+
+        it("should return exactly 1 result", async function() {
+            const result = await session.query<User>({ collection: "users" })
+                .whereEquals("name", "John")
+                .singleOrNull();
+
+            assert.ok(result);
+            assert.ok(result instanceof User);
+            assert.strictEqual(result.name, "John");
+        });
+
+    });
+
+    describe("first()", function () {
+
+        it("should return first result", async function() {
+            const result = await session.query<User>({ collection: "users" })
+                .whereStartsWith("name", "John")
+                .orderBy("name")
+                .first();
+
+            assert.ok(result);
+            assert.ok(result instanceof User);
+            assert.strictEqual(result.name, "John");
+        });
+
+        it("should throw for no results", async function() {
+            await assertThrows(
+                async () => await session.query({ collection: "users" })
+                    .whereEquals("name", "Merry")
+                    .first(),
+                err => {
+                    assert.strictEqual(err.name, "InvalidOperationException");
+                    assert.strictEqual(err.message, "Expected at least one result.");
+                });
+        });
+
+    });
+
+    describe("firstOrNull()", function () {
+
+        it("should return first result", async function() {
+            const result = await session.query<User>({ collection: "users" })
+                .whereStartsWith("name", "John")
+                .orderBy("name")
+                .firstOrNull();
+
+            assert.ok(result);
+            assert.ok(result instanceof User);
+            assert.strictEqual(result.name, "John");
+        });
+
+        it("should return null for no results", async function() {
+            const result = await session.query<User>({ collection: "users" })
+                .whereStartsWith("name", "Merry")
+                .firstOrNull();
+
+            assert.strictEqual(result, null);
+        });
+
+    });
+
+});

test/Utils/AssertExtensions.ts

@@ -1,16 +1,14 @@
 import * as assert from "assert";
 
-export async function throwsAsync(fn, regExp) {
-    // tslint:disable-next-line:no-empty
-    let f = () => {
-    };
+export async function assertThrows(func: Function, errAssert?: (err: Error) => void) {
     try {
-        await fn();
-    } catch (e) {
-        f = () => {
-            throw e;
-        };
-    } finally {
-        assert.throws(f, regExp);
+        await func();
+        assert.fail(`Function '${func.name || func.toString()}' should have thrown.`);
+    } catch (err) {
+        if (errAssert) {
+            errAssert(err);
+        }
+
+        return err;
     }
 }

tslint.json

@@ -32,10 +32,11 @@
         "adjacent-overload-signatures": false,
         "ban-types": false,
         "no-unused-variable": false,
-        "space-before-function-paren": ["warn", "always"],
+        "space-before-function-paren": [ "warn", "always"],
         "object-curly-spacing": [true, "always"],
         "comment-format": false,
-        "no-shadowed-variable": false
+        "no-shadowed-variable": false,
+        "mocha-avoid-only": true
     },
     "rulesDirectory": [
         "node_modules/tslint-microsoft-contrib"