@squiz/db-lib 1.2.1-alpha.98 → 1.2.1

package/src/assertions/assertIsDefined.spec.ts

@@ -1,19 +0,0 @@
-import { assertIsDefined } from './assertIsDefined';
-
-describe('assertIsDefined', () => {
-  it('should throw an assertion error if input is undefined', () => {
-    expect(() => assertIsDefined(undefined)).toThrowErrorMatchingInlineSnapshot(
-      `"Expected 'val' to be defined, but received undefined"`,
-    );
-  });
-
-  it('should throw an assertion error if input is null', () => {
-    expect(() => assertIsDefined(null)).toThrowErrorMatchingInlineSnapshot(
-      `"Expected 'val' to be defined, but received null"`,
-    );
-  });
-
-  it('should return "void" or undefined if valid', () => {
-    expect(assertIsDefined(123)).toBeUndefined();
-  });
-});

package/src/assertions/assertIsDefined.ts

@@ -1,7 +0,0 @@
-import { AssertionError } from 'assert';
-
-export function assertIsDefined<T>(value: T): asserts value is NonNullable<T> {
-  if (value === undefined || value === null) {
-    throw new AssertionError({ message: `Expected 'val' to be defined, but received ${value}` });
-  }
-}

package/src/assertions/assertIsMapOfStringString.spec.ts

@@ -1,23 +0,0 @@
-import { assertIsMapOfStringString } from './assertIsMapOfStringString';
-
-describe('assertIsMapOfStringString', () => {
-  it('should not throw if input is an object with only string values', () => {
-    expect(assertIsMapOfStringString({ prop: 'aa' })).toBeUndefined();
-  });
-  it('should not throw if input is an empty object', () => {
-    expect(assertIsMapOfStringString({})).toBeUndefined();
-  });
-
-  it("should throw if object property isn't a string", () => {
-    expect(() => assertIsMapOfStringString({ prop: 123 })).toThrowErrorMatchingInlineSnapshot(
-      `"property prop is not type of string"`,
-    );
-  });
-
-  it('should throw if input is not an object', () => {
-    expect(() => assertIsMapOfStringString(123)).toThrowErrorMatchingInlineSnapshot(`"value is not a string"`);
-    expect(() => assertIsMapOfStringString(undefined)).toThrowErrorMatchingInlineSnapshot(
-      `"value cannot be null or undefined"`,
-    );
-  });
-});

package/src/assertions/assertIsMapOfStringString.ts

@@ -1,29 +0,0 @@
-import { AssertionError } from 'assert';
-
-export function assertIsMapOfStringString(value: unknown): asserts value is { [key: string]: string } {
-  if (!value) {
-    throw new AssertionError({
-      actual: value,
-      expected: 'not null',
-      message: 'value cannot be null or undefined',
-    });
-  }
-
-  if (typeof value !== 'object') {
-    throw new AssertionError({
-      actual: value,
-      expected: 'string',
-      message: 'value is not a string',
-    });
-  }
-
-  for (const [key, propValue] of Object.entries(value)) {
-    if (typeof propValue !== 'string') {
-      throw new AssertionError({
-        actual: typeof propValue,
-        expected: 'string',
-        message: `property ${key} is not type of string`,
-      });
-    }
-  }
-}

package/src/assertions/assertIsNotAnEmptyString.spec.ts

@@ -1,25 +0,0 @@
-import { assertIsNotAnEmptyString } from './assertIsNotAnEmptyString';
-
-describe('assertIsNotAnEmptyString', () => {
-  it('should throw if input value is not a string', () => {
-    expect(() => assertIsNotAnEmptyString(null)).toThrowErrorMatchingInlineSnapshot(`"value is not a string"`);
-    expect(() => assertIsNotAnEmptyString(undefined)).toThrowErrorMatchingInlineSnapshot(`"value is not a string"`);
-    expect(() => assertIsNotAnEmptyString(132)).toThrowErrorMatchingInlineSnapshot(`"value is not a string"`);
-    expect(() => assertIsNotAnEmptyString({})).toThrowErrorMatchingInlineSnapshot(`"value is not a string"`);
-    expect(() => assertIsNotAnEmptyString(['aa'])).toThrowErrorMatchingInlineSnapshot(`"value is not a string"`);
-  });
-
-  it('should throw if input is empty string', () => {
-    expect(() => assertIsNotAnEmptyString('')).toThrowErrorMatchingInlineSnapshot(`"string cannot be empty"`);
-  });
-
-  it('should throw if input is whitespace string', () => {
-    expect(() => assertIsNotAnEmptyString(' ')).toThrowErrorMatchingInlineSnapshot(`"string cannot be empty"`);
-    expect(() => assertIsNotAnEmptyString('     ')).toThrowErrorMatchingInlineSnapshot(`"string cannot be empty"`);
-  });
-
-  it('should not throw if string of length >= 1 is passed in', () => {
-    expect(assertIsNotAnEmptyString('1')).toBeUndefined();
-    expect(assertIsNotAnEmptyString('11111')).toBeUndefined();
-  });
-});

package/src/assertions/assertIsNotAnEmptyString.ts

@@ -1,17 +0,0 @@
-import { AssertionError } from 'assert';
-
-export function assertIsNotAnEmptyString(val: any): asserts val is string {
-  if (typeof val !== 'string') {
-    throw new AssertionError({
-      actual: typeof val,
-      expected: 'string',
-      message: 'value is not a string',
-    });
-  }
-
-  if (val.trim().length === 0) {
-    throw new AssertionError({
-      message: 'string cannot be empty',
-    });
-  }
-}

package/src/assertions/assertIsObject.spec.ts

@@ -1,17 +0,0 @@
-import { assertIsObject } from './assertIsObject';
-
-describe('assertIsObject', () => {
-  it('should not throw if input is an object', () => {
-    expect(assertIsObject({ hello: 123 })).toBeUndefined();
-  });
-
-  it("should throw if input isn't an object", () => {
-    expect(() => assertIsObject(undefined)).toThrowErrorMatchingInlineSnapshot(`"value is not an object"`);
-    expect(() => assertIsObject(null)).toThrowErrorMatchingInlineSnapshot(`"value is not an object"`);
-    expect(() => assertIsObject('my string')).toThrowErrorMatchingInlineSnapshot(`"value is not an object"`);
-    expect(() => assertIsObject(123)).toThrowErrorMatchingInlineSnapshot(`"value is not an object"`);
-    expect(() => assertIsObject([])).toThrowErrorMatchingInlineSnapshot(`"value is not an object"`);
-    expect(() => assertIsObject(NaN)).toThrowErrorMatchingInlineSnapshot(`"value is not an object"`);
-    expect(() => assertIsObject(Infinity)).toThrowErrorMatchingInlineSnapshot(`"value is not an object"`);
-  });
-});

package/src/assertions/assertIsObject.ts

@@ -1,11 +0,0 @@
-import { AssertionError } from 'assert';
-
-export function assertIsObject(val: any): asserts val is object {
-  if (Object.prototype.toString.call(val) !== '[object Object]') {
-    throw new AssertionError({
-      actual: Object.prototype.toString.call(val),
-      expected: 'object',
-      message: 'value is not an object',
-    });
-  }
-}

package/src/assertions/assertIsString.spec.ts

@@ -1,16 +0,0 @@
-import { assertIsString } from './assertIsString';
-
-describe('assertIsString', () => {
-  it('should not throw if input is a string', () => {
-    expect(assertIsString('hello')).toBeUndefined();
-  });
-
-  it('should not throw if input is not a string', () => {
-    expect(() => assertIsString(undefined)).toThrowErrorMatchingInlineSnapshot(`"value is not a string"`);
-    expect(() => assertIsString(null)).toThrowErrorMatchingInlineSnapshot(`"value is not a string"`);
-    expect(() => assertIsString(123)).toThrowErrorMatchingInlineSnapshot(`"value is not a string"`);
-    expect(() => assertIsString([])).toThrowErrorMatchingInlineSnapshot(`"value is not a string"`);
-    expect(() => assertIsString(NaN)).toThrowErrorMatchingInlineSnapshot(`"value is not a string"`);
-    expect(() => assertIsString(Infinity)).toThrowErrorMatchingInlineSnapshot(`"value is not a string"`);
-  });
-});

package/src/assertions/assertIsString.ts

@@ -1,11 +0,0 @@
-import { AssertionError } from 'assert';
-
-export function assertIsString(val: any): asserts val is string {
-  if (typeof val !== 'string') {
-    throw new AssertionError({
-      actual: val,
-      expected: 'string',
-      message: 'value is not a string',
-    });
-  }
-}