chore: add expectation utilities for parsing

This adds a few methods to assert that a type is the expected type
before returning it. This is useful to make sure that we aren't
blindly returning json that is invalid.

Author: JordonPhillips

packages/smithy-client/src/index.ts

@@ -6,6 +6,7 @@ export * from "./extended-encode-uri-component";
 export * from "./get-array-if-single-item";
 export * from "./get-value-from-text-node";
 export * from "./lazy-json";
+export * from "./parse-utils";
 export * from "./date-utils";
 export * from "./split-every";
 export * from "./constants";

packages/smithy-client/src/parse-utils.spec.ts

@@ -0,0 +1,66 @@
+import { expectBoolean, expectNumber, expectString } from "./parse-utils";
+
+describe("expectBoolean", () => {
+  it("accepts booleans", () => {
+    expect(expectBoolean(true)).toEqual(true);
+    expect(expectBoolean(false)).toEqual(false);
+  });
+
+  it("rejects non-booleans", () => {
+    expect(() => expectBoolean("true")).toThrowError();
+    expect(() => expectBoolean("false")).toThrowError();
+    expect(() => expectBoolean(0)).toThrowError();
+    expect(() => expectBoolean(1)).toThrowError();
+    expect(() => expectBoolean(1.1)).toThrowError();
+    expect(() => expectBoolean(Infinity)).toThrowError();
+    expect(() => expectBoolean(-Infinity)).toThrowError();
+    expect(() => expectBoolean(NaN)).toThrowError();
+    expect(() => expectBoolean({})).toThrowError();
+    expect(() => expectBoolean([])).toThrowError();
+    expect(() => expectBoolean(null)).toThrowError();
+    expect(() => expectBoolean(undefined)).toThrowError();
+  });
+});
+
+describe("expectNumber", () => {
+  it("accepts numbers", () => {
+    expect(expectNumber(1)).toEqual(1);
+    expect(expectNumber(1.1)).toEqual(1.1);
+    expect(expectNumber(Infinity)).toEqual(Infinity);
+    expect(expectNumber(-Infinity)).toEqual(-Infinity);
+    expect(expectNumber(NaN)).toEqual(NaN);
+  });
+
+  it("rejects non-numbers", () => {
+    expect(() => expectNumber("1")).toThrowError();
+    expect(() => expectNumber("1.1")).toThrowError();
+    expect(() => expectNumber("Infinity")).toThrowError();
+    expect(() => expectNumber("-Infinity")).toThrowError();
+    expect(() => expectNumber("NaN")).toThrowError();
+    expect(() => expectNumber(true)).toThrowError();
+    expect(() => expectNumber(false)).toThrowError();
+    expect(() => expectNumber([])).toThrowError();
+    expect(() => expectNumber({})).toThrowError();
+    expect(() => expectNumber(null)).toThrowError();
+    expect(() => expectNumber(undefined)).toThrowError();
+  });
+});
+
+describe("expectString", () => {
+  it("accepts strings", () => {
+    expect(expectString("foo")).toEqual("foo");
+  });
+
+  it("rejects non-strings", () => {
+    expect(() => expectString(1)).toThrowError();
+    expect(() => expectString(NaN)).toThrowError();
+    expect(() => expectString(Infinity)).toThrowError();
+    expect(() => expectString(-Infinity)).toThrowError();
+    expect(() => expectString(true)).toThrowError();
+    expect(() => expectString(false)).toThrowError();
+    expect(() => expectString([])).toThrowError();
+    expect(() => expectString({})).toThrowError();
+    expect(() => expectString(null)).toThrowError();
+    expect(() => expectString(undefined)).toThrowError();
+  });
+});

packages/smithy-client/src/parse-utils.ts

@@ -0,0 +1,38 @@
+/**
+ * Asserts a value is a boolean and returns it.
+ *
+ * @param value A value that is expected to be a boolean.
+ * @returns The value if it is a boolean, otherwise an error is thrown.
+ */
+export function expectBoolean(value: any): boolean {
+  if (typeof value === "boolean") {
+    return value;
+  }
+  throw new TypeError(`Expected boolean, got ${typeof value}`);
+}
+
+/**
+ * Asserts a value is a number and returns it.
+ *
+ * @param value A value that is expected to be a number.
+ * @returns The value if it is a number, otherwise an error is thrown.
+ */
+export function expectNumber(value: any): number {
+  if (typeof value === "number") {
+    return value;
+  }
+  throw new TypeError(`Expected number, got ${typeof value}`);
+}
+
+/**
+ * Asserts a value is a string and returns it.
+ *
+ * @param value A value that is expected to be a string.
+ * @returns The value if it is a string, otherwise an error is thrown.
+ */
+export function expectString(value: any): string {
+  if (typeof value === "string") {
+    return value;
+  }
+  throw new TypeError(`Expected string, got ${typeof value}`);
+}