feat(sql): add sql standard interfaces

README.md

@@ -44,8 +44,14 @@ console.log(dump(buffer));
 
 ## Packages
 
+- [assert](https://jsr.io/@stdext/assert): The assert package, contains
+  validators and assertions
+- [collections](https://jsr.io/@stdext/collections): The collections package
+  contains commonly used utilities and structures
 - [crypto](https://jsr.io/@stdext/crypto): The crypto package contains utility
   for crypto and hashing
+- [database](https://jsr.io/@stdext/database): The database package contains
+  interfaces and helpers for interracting with databases
 - [encoding](https://jsr.io/@stdext/encoding): The encoding package contains
   utility for text encoding.
 - [http](https://jsr.io/@stdext/http): The http package contains utility for

assert/is_number.ts

@@ -10,8 +10,13 @@ export function isNumber(value: unknown): value is number {
 /**
  * Asserts that a value is a number
  */
-export function assertIsNumber(value: unknown): asserts value is number {
+export function assertIsNumber(
+  value: unknown,
+  msg?: string,
+): asserts value is number {
   if (!isNumber(value)) {
-    throw new AssertionError(`Value is not a number, was '${value}'`);
+    const msgSuffix = msg ? `: ${msg}` : ".";
+    const message = `Value is not a number, was '${value}'${msgSuffix}`;
+    throw new AssertionError(message);
   }
 }

assert/is_numeric.ts

@@ -11,8 +11,13 @@ export function isNumeric(value: unknown): value is number {
 /**
  * Asserts that a value is a number and not NaN
  */
-export function assertIsNumeric(value: unknown): asserts value is number {
+export function assertIsNumeric(
+  value: unknown,
+  msg?: string,
+): asserts value is number {
   if (!isNumeric(value)) {
-    throw new AssertionError(`Value is not a numeric, was '${value}'`);
+    const msgSuffix = msg ? `: ${msg}` : ".";
+    const message = `Value is not a numeric, was '${value}'${msgSuffix}`;
+    throw new AssertionError(message);
   }
 }

assert/is_object.test.ts

@@ -0,0 +1,42 @@
+import { assert, assertFalse, AssertionError, assertThrows } from "@std/assert";
+import { assertIsObject, isObject } from "./is_object.ts";
+
+const VALID = [
+  {},
+  { a: 1 },
+  { 1: "a" },
+  { [Symbol.dispose]: "" },
+];
+
+const INVALID = [
+  "",
+  1,
+  undefined,
+  null,
+  [],
+  [""],
+  new Map(),
+];
+
+Deno.test("isObject > can detect records", () => {
+  for (const v of VALID) {
+    assert(isObject(v), `Value of '${v}' is not valid`);
+  }
+  for (const v of INVALID) {
+    assertFalse(isObject(v), `Value of '${v}' is not invalid`);
+  }
+});
+
+Deno.test("assertIsObject > can detect records", () => {
+  for (const v of VALID) {
+    assertIsObject(v);
+  }
+  for (const v of INVALID) {
+    assertThrows(
+      () => assertIsObject(v),
+      AssertionError,
+      undefined,
+      `Value of '${v}' did not throw`,
+    );
+  }
+});

assert/is_object.ts

@@ -0,0 +1,27 @@
+import { AssertionError } from "@std/assert";
+import { objectToStringEquals } from "./utils.ts";
+
+/**
+ * Checks if a value is an object
+ */
+export function isObject(value: unknown): value is object {
+  if (!objectToStringEquals("Object", value)) {
+    return false;
+  }
+
+  return true;
+}
+
+/**
+ * Asserts that a value is an object
+ */
+export function assertIsObject(
+  value: unknown,
+  msg?: string,
+): asserts value is object {
+  if (!isObject(value)) {
+    const msgSuffix = msg ? `: ${msg}` : ".";
+    const message = `Value is not a object, was '${value}'${msgSuffix}`;
+    throw new AssertionError(message);
+  }
+}

assert/is_record.ts

@@ -1,15 +1,11 @@
 import { AssertionError } from "@std/assert";
-import { objectToStringEquals } from "./utils.ts";
+import { isObject } from "./is_object.ts";
 
 /**
  * Checks if a value is a Record<string, unknown>
  */
 export function isRecord(value: unknown): value is Record<string, unknown> {
-  if (!objectToStringEquals("Object", value)) {
-    return false;
-  }
-
-  if (typeof value !== "object") {
+  if (!isObject(value)) {
     return false;
   }
 
@@ -29,8 +25,11 @@ export function isRecord(value: unknown): value is Record<string, unknown> {
  */
 export function assertIsRecord(
   value: unknown,
+  msg?: string,
 ): asserts value is Record<string, unknown> {
   if (!isRecord(value)) {
-    throw new AssertionError(`Value is not a Record, was '${value}'`);
+    const msgSuffix = msg ? `: ${msg}` : ".";
+    const message = `Value is not a Record, was '${value}'${msgSuffix}`;
+    throw new AssertionError(message);
   }
 }

assert/is_string.ts

@@ -10,8 +10,13 @@ export function isString(value: unknown): value is string {
 /**
  * Asserts that a value is a string
  */
-export function assertIsString(value: unknown): asserts value is string {
+export function assertIsString(
+  value: unknown,
+  msg?: string,
+): asserts value is string {
   if (!isString(value)) {
-    throw new AssertionError(`Value is not a string, was '${value}'`);
+    const msgSuffix = msg ? `: ${msg}` : ".";
+    const message = `Value is not a string, was '${value}'${msgSuffix}`;
+    throw new AssertionError(message);
   }
 }

assert/mod.ts

@@ -1,4 +1,6 @@
 export * from "./is_number.ts";
 export * from "./is_numeric.ts";
+export * from "./is_object.ts";
 export * from "./is_record.ts";
 export * from "./is_string.ts";
+export * from "./object_has_properties.ts";

assert/object_has_properties.test.ts

@@ -0,0 +1,93 @@
+import { assert, assertFalse, AssertionError, assertThrows } from "@std/assert";
+import {
+  assertObjectHasProperties,
+  assertObjectHasPropertiesDeep,
+  objectHasProperties,
+  objectHasPropertiesDeep,
+} from "./object_has_properties.ts";
+
+const VALID: Array<[object, Array<PropertyKey>]> = [
+  [{ [Symbol.for("test")]: 0 }, [Symbol.for("test")]],
+  [{ 1: 0 }, [1]],
+  [{ 0: 0 }, [0]],
+  [{ "": 0 }, [""]],
+  [{ "test": 0 }, ["test"]],
+];
+
+const INVALID: Array<[object, Array<PropertyKey>]> = [
+  [{}, [Symbol.for("test")]],
+  [{ [Symbol.for("test2")]: 0 }, [Symbol.for("test")]],
+  [{}, [1]],
+  [{}, [""]],
+  [{}, ["test"]],
+];
+
+class NestedClass extends (class {
+  get test() {
+    return "test";
+  }
+}) {}
+const nestedClass = new NestedClass();
+
+const INVALID_NOT_DEEP: Array<[object, Array<PropertyKey>]> = [
+  ...INVALID,
+  [nestedClass, ["test"]],
+];
+const VALID_DEEP: Array<[object, Array<PropertyKey>]> = [
+  ...VALID,
+  [nestedClass, ["test"]],
+];
+
+Deno.test("objectHasProperties > can detect all property keys", () => {
+  for (const v of VALID) {
+    assert(
+      objectHasProperties(v[0], v[1]),
+      `Value of '${JSON.stringify(v)}' is not valid`,
+    );
+  }
+  for (const v of INVALID_NOT_DEEP) {
+    assertFalse(
+      objectHasProperties(v[0], v[1]),
+      `Value of '${JSON.stringify(v)}' is not invalid`,
+    );
+  }
+});
+
+Deno.test("assertObjectHasProperties > can detect all property keys", () => {
+  for (const v of VALID) {
+    assertObjectHasProperties(v[0], v[1]);
+  }
+  for (const v of INVALID) {
+    assertThrows(
+      () => assertObjectHasProperties(v[0], v[1]),
+      AssertionError,
+    );
+  }
+});
+
+Deno.test("objectHasPropertiesDeep > can detect all property keys", () => {
+  for (const v of VALID_DEEP) {
+    assert(
+      objectHasPropertiesDeep(v[0], v[1]),
+      `Value of '${JSON.stringify(v)}' is not valid`,
+    );
+  }
+  for (const v of INVALID) {
+    assertFalse(
+      objectHasPropertiesDeep(v[0], v[1]),
+      `Value of '${JSON.stringify(v)}' is not invalid`,
+    );
+  }
+});
+
+Deno.test("assertObjectHasPropertiesDeep > can detect all property keys", () => {
+  for (const v of VALID) {
+    assertObjectHasPropertiesDeep(v[0], v[1]);
+  }
+  for (const v of INVALID) {
+    assertThrows(
+      () => assertObjectHasPropertiesDeep(v[0], v[1]),
+      AssertionError,
+    );
+  }
+});

assert/object_has_properties.ts

@@ -0,0 +1,130 @@
+import { AssertionError } from "@std/assert";
+import { assertIsObject, isObject } from "./is_object.ts";
+
+/**
+ * Check if an object has a property
+ */
+function hasProperty<T>(
+  obj: T,
+  property: PropertyKey,
+  deep: boolean,
+): boolean {
+  let currentProto = obj;
+
+  while (currentProto !== null && currentProto !== undefined) {
+    if (Object.hasOwn(currentProto, property)) {
+      return true;
+    }
+    const descriptor = Object.getOwnPropertyDescriptor(
+      currentProto,
+      property,
+    );
+    if (descriptor !== undefined) {
+      return true;
+    }
+    if (!deep) {
+      return false;
+    }
+    currentProto = Object.getPrototypeOf(currentProto);
+  }
+
+  return false;
+}
+
+export function getKeyDiff(
+  value: object,
+  keys: Array<PropertyKey>,
+  deep: boolean,
+): Array<PropertyKey> {
+  const diff: PropertyKey[] = [];
+
+  for (const key of keys) {
+    if (!hasProperty(value, key, deep)) {
+      diff.push(key);
+    }
+  }
+
+  return diff;
+}
+
+/**
+ * Checks if an object has given property keys
+ */
+export function objectHasProperties<T extends PropertyKey = PropertyKey>(
+  value: unknown,
+  keys: Array<T>,
+): value is Record<T, unknown> {
+  if (!isObject(value)) {
+    return false;
+  }
+
+  const diff = getKeyDiff(value, keys, false);
+
+  return diff.length < 1;
+}
+
+/**
+ * Asserts that an object has given property keys
+ */
+export function assertObjectHasProperties<T extends PropertyKey = PropertyKey>(
+  value: unknown,
+  keys: Array<T>,
+  msg?: string,
+): asserts value is Record<T, unknown> {
+  assertIsObject(value);
+
+  const diff = getKeyDiff(value, keys, false);
+
+  if (diff.length > 0) {
+    const msgSuffix = msg ? `: ${msg}` : ".";
+    const message = `The object is missing the following keys: [${
+      keys.map(String).join(",")
+    }]${msgSuffix}`;
+    throw new AssertionError(message);
+  }
+}
+
+/**
+ * Checks deeply if an object has given property keys
+ *
+ * Use when wanting to check for getters and other prototype
+ * properties on multilevel inheritance
+ */
+export function objectHasPropertiesDeep<T extends PropertyKey = PropertyKey>(
+  value: unknown,
+  keys: Array<T>,
+): value is Record<T, unknown> {
+  if (!isObject(value)) {
+    return false;
+  }
+
+  const diff = getKeyDiff(value, keys, true);
+
+  return diff.length < 1;
+}
+
+/**
+ * Asserts that an object has given property keys
+ *
+ * Use when wanting to check for getters and other prototype
+ * properties on multilevel inheritance
+ */
+export function assertObjectHasPropertiesDeep<
+  T extends PropertyKey = PropertyKey,
+>(
+  value: unknown,
+  keys: Array<T>,
+  msg?: string,
+): asserts value is Record<T, unknown> {
+  assertIsObject(value);
+
+  const diff = getKeyDiff(value, keys, true);
+
+  if (diff.length > 0) {
+    const msgSuffix = msg ? `: ${msg}` : ".";
+    const message = `The object is missing the following keys: [${
+      keys.map(String).join(",")
+    }]${msgSuffix}`;
+    throw new AssertionError(message);
+  }
+}