@ezez/utils 4.6.0 → 4.7.1

package/src/hasProps.spec.ts

@@ -0,0 +1,122 @@
+import must from "must"; // eslint-disable-line @typescript-eslint/no-shadow
+
+import { hasProps } from "./hasProps";
+
+describe("hasProps", () => {
+    it("should return true for object with valid string properties", () => {
+        const obj = { id: "123", name: "John" };
+        const result = hasProps(obj, { id: "string", name: "string" });
+        must(result).be.true();
+    });
+
+    it("should return true for object with valid number properties", () => {
+        const obj = { age: 25, count: 100 };
+        const result = hasProps(obj, { age: "number", count: "number" });
+        must(result).be.true();
+    });
+
+    it("should return true for object with valid boolean properties", () => {
+        const obj = { isActive: true, isDeleted: false };
+        const result = hasProps(obj, { isActive: "boolean", isDeleted: "boolean" });
+        must(result).be.true();
+    });
+
+    it("should return true for object with mixed property types", () => {
+        const obj = { id: "123", age: 30, isActive: true };
+        const result = hasProps(obj, { id: "string", age: "number", isActive: "boolean" });
+        must(result).be.true();
+    });
+
+    it("should return false for object with wrong property type", () => {
+        const obj = { id: 123, name: "John" };
+        const result = hasProps(obj, { id: "string", name: "string" });
+        must(result).be.false();
+    });
+
+    it("should return false for object missing required property", () => {
+        const obj = { id: "123" };
+        const result = hasProps(obj, { id: "string", name: "string" });
+        must(result).be.false();
+    });
+
+    it("should return false for null", () => {
+        const result = hasProps(null, { id: "string" });
+        must(result).be.false();
+    });
+
+    it("should return false for undefined", () => {
+        const result = hasProps(undefined, { id: "string" });
+        must(result).be.false();
+    });
+
+    it("should return false for array", () => {
+        const arr = [{ id: "123" }];
+        const result = hasProps(arr, { id: "string" });
+        must(result).be.false();
+    });
+
+    it("should return false for primitive string", () => {
+        const result = hasProps("test", { id: "string" });
+        must(result).be.false();
+    });
+
+    it("should return false for primitive number", () => {
+        const result = hasProps(123, { id: "string" });
+        must(result).be.false();
+    });
+
+    it("should return false for primitive boolean", () => {
+        const result = hasProps(true, { id: "string" });
+        must(result).be.false();
+    });
+
+    it("should return true for empty schema", () => {
+        const obj = { id: "123", name: "John" };
+        const result = hasProps(obj, {});
+        must(result).be.true();
+    });
+
+    it("should allow extra properties on the object", () => {
+        const obj = { id: "123", name: "John", extra: "value" };
+        const result = hasProps(obj, { id: "string", name: "string" });
+        must(result).be.true();
+    });
+
+    it("should handle objects with null property values", () => {
+        const obj = { id: null, name: "John" };
+        const result = hasProps(obj, { id: "string", name: "string" });
+        must(result).be.false();
+    });
+
+    it("should handle objects with undefined property values", () => {
+        const obj = { id: undefined, name: "John" };
+        const result = hasProps(obj, { id: "string", name: "string" });
+        must(result).be.false();
+    });
+
+    it("should correctly validate boolean false value", () => {
+        const obj = { isActive: false };
+        const result = hasProps(obj, { isActive: "boolean" });
+        must(result).be.true();
+    });
+
+    it("should correctly validate number zero value", () => {
+        const obj = { count: 0 };
+        const result = hasProps(obj, { count: "number" });
+        must(result).be.true();
+    });
+
+    it("should correctly validate empty string value", () => {
+        const obj = { name: "" };
+        const result = hasProps(obj, { name: "string" });
+        must(result).be.true();
+    });
+
+    it("should work with objects source only", async () => {
+        const source = () => null;
+        must(source).have.property("name", "source");
+
+        const result = hasProps(source, { name: "string" });
+        must(result).be.false();
+    });
+});

package/src/hasProps.ts

@@ -0,0 +1,36 @@
+/**
+ * Check if an object has the specified properties with the specified types. Ideal for quick runtime type checking of
+ * API responses if you don't need a full schema validation.
+ *
+ * @example
+ * ```typescript
+ * const validated = hasProps(obj, { id: "string", age: "number" });
+ * if (validated) {
+ *     // obj is runtime validated and type is now narrowed down to { id: string; age: number }
+ *     console.log(obj.id, obj.age);
+ * }
+ * ```
+ */
+const hasProps = <
+    T extends Record<string, "string" | "number" | "boolean">,
+>(
+    obj: unknown,
+    schema: T,
+): obj is {
+    [K in keyof T]:
+    T[K] extends "string" ? string
+        : T[K] extends "number" ? number
+            : T[K] extends "boolean" ? boolean
+                : never
+} => {
+    if (typeof obj !== "object" || obj === null || Array.isArray(obj)) { return false; }
+    for (const [key, type] of Object.entries(schema)) {
+        // eslint-disable-next-line valid-typeof
+        if (typeof (obj as { [key]: unknown })[key] !== type) { return false; }
+    }
+    return true;
+};
+
+export {
+    hasProps,
+};

package/src/index.ts

@@ -3,6 +3,7 @@ export * from "./serializeToBuffer/serializeToBuffer.js";
 export * from "./serializeToBuffer/unserializeFromBuffer.js";
 export * from "./ensurePrefix.js";
 export * from "./ensureSuffix.js";
+export * from "./assertProps.js";
 export * from "./cap.js";
 export * from "./capitalize.js";
 export * from "./coalesce.js";
@@ -17,6 +18,7 @@ export * from "./escapeRegExp.js";
 export * from "./formatDate.js";
 export * from "./get.js";
 export * from "./getMultiple.js";
+export * from "./hasProps.js";
 export * from "./ignore.js";
 export * from "./insertSeparator.js";
 export * from "./isEmpty.js";

package/src/match.ts

@@ -4,6 +4,7 @@ type MatchCallback<T> = (value: T) => boolean;
  * A `Array.prototype.filter`-like function that splits the results into two groups - matched and unmatched
  * @param {Array} list - original array
  * @param {function} fn - function matching elements
+ * @deprecated - use `Map.groupBy` instead for even more robustness
  */
 const match = <T>(list: T[], fn: MatchCallback<T>): { matched: T[]; unmatched: T[] } => {
     const matched: T[] = [];