typeshi 2.1.1 → 2.1.3

package/dist/utils/index.d.ts

@@ -5,3 +5,4 @@ export * from "./io";
 export * from "./regex";
 export * from "./argumentValidation";
 export * from "./typeValidation";
+export * from "./object";

package/dist/utils/index.js

@@ -21,3 +21,4 @@ __exportStar(require("./io"), exports);
 __exportStar(require("./regex"), exports);
 __exportStar(require("./argumentValidation"), exports);
 __exportStar(require("./typeValidation"), exports);
+__exportStar(require("./object"), exports);

package/dist/utils/object.d.ts

@@ -0,0 +1,48 @@
+/**
+ * @file src/utils/object.ts
+ * @TODO just use zod instead
+ */
+/**
+ * @returns `boolean`
+ * - `true` if all keys in obj are also in validKeys
+ * - `false` if there exists a key in obj that is not in validKeys
+ */
+export declare function hasValidKeysOnly<T extends object>(obj: object, validKeys: readonly (keyof T)[]): obj is T;
+/**
+ * @returns a new object containing only the specified keys.
+ */
+export declare function picked<T extends object, K extends keyof T>(obj: T, keys: K[]): Pick<T, K>;
+export declare class Restrict {
+    /**
+     * `hasValidKeysOnly`
+     * @returns `boolean` - `true` if `obj` contains ONLY keys found in `validKeys`
+     */
+    static keys: typeof hasValidKeysOnly;
+    /**
+     * @returns a new object containing only the specified keys.
+     */
+    static toPicked: typeof picked;
+}
+/**
+ * **`values`** are either:
+ * - a `function` where only need to pass in single value to get the transformed value `T[K]`
+ * - an object with two props: `transform` & `args` where `args` is the array of arguments
+ * passed into `transform` using the spread operator.
+ */
+export type TransformationSchema<T> = {
+    [K in keyof T]?: ((val: any) => T[K]) | {
+        transform: (val: any, ...args: any[]) => T[K];
+        args: any[];
+    };
+};
+/**
+ * @param obj `any` - source object (e.g., Request Body)
+ * @param schema {@link TransformationSchema}`<T>` - map of keys to transformation functions
+ * @param passThroughKeys `(keyof T)[]` - keys to move over without transformation (Identity mapping)
+ * @returns **`data`** `T` - new object with keys/values from generated from `schema` & `passThroughKeys`
+ */
+export declare function sanitizeAndMap<T extends object>(obj: any, schema: TransformationSchema<T>, passThroughKeys?: (keyof T)[]): T;
+/**
+ * @returns `Object.prototype.hasOwnProperty.call(obj, key) && obj[key] !== undefined;`
+ */
+export declare function hasDefinedEntry<T extends object>(obj: any, key: keyof T): boolean;

package/dist/utils/object.js

@@ -0,0 +1,76 @@
+"use strict";
+/**
+ * @file src/utils/object.ts
+ * @TODO just use zod instead
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Restrict = void 0;
+exports.hasValidKeysOnly = hasValidKeysOnly;
+exports.picked = picked;
+exports.sanitizeAndMap = sanitizeAndMap;
+exports.hasDefinedEntry = hasDefinedEntry;
+const typeValidation_1 = require("./typeValidation");
+/**
+ * @returns `boolean`
+ * - `true` if all keys in obj are also in validKeys
+ * - `false` if there exists a key in obj that is not in validKeys
+ */
+function hasValidKeysOnly(obj, validKeys) {
+    return Object.keys(obj).every(key => validKeys.includes(key));
+}
+/**
+ * @returns a new object containing only the specified keys.
+ */
+function picked(obj, keys) {
+    const result = {};
+    for (const key of keys) {
+        if (key in obj && obj[key] !== undefined)
+            result[key] = obj[key];
+    }
+    return result;
+}
+class Restrict {
+}
+exports.Restrict = Restrict;
+/**
+ * `hasValidKeysOnly`
+ * @returns `boolean` - `true` if `obj` contains ONLY keys found in `validKeys`
+ */
+Restrict.keys = hasValidKeysOnly;
+/**
+ * @returns a new object containing only the specified keys.
+ */
+Restrict.toPicked = picked;
+/**
+ * @param obj `any` - source object (e.g., Request Body)
+ * @param schema {@link TransformationSchema}`<T>` - map of keys to transformation functions
+ * @param passThroughKeys `(keyof T)[]` - keys to move over without transformation (Identity mapping)
+ * @returns **`data`** `T` - new object with keys/values from generated from `schema` & `passThroughKeys`
+ */
+function sanitizeAndMap(obj, schema, passThroughKeys = []) {
+    const data = {};
+    // 1. Handle explicit transformations
+    for (const key in schema) {
+        if (schema[key] && hasDefinedEntry(obj, key)) {
+            if ((0, typeValidation_1.isFunction)(schema[key])) {
+                data[key] = schema[key](obj[key]);
+            }
+            else {
+                data[key] = schema[key].transform(obj[key], ...schema[key].args);
+            }
+        }
+    }
+    // 2. Handle simple pass-throughs (Identity mapping)
+    for (const key of passThroughKeys) {
+        if (!data[key] && hasDefinedEntry(obj, key)) {
+            data[key] = obj[key];
+        }
+    }
+    return data;
+}
+/**
+ * @returns `Object.prototype.hasOwnProperty.call(obj, key) && obj[key] !== undefined;`
+ */
+function hasDefinedEntry(obj, key) {
+    return Object.prototype.hasOwnProperty.call(obj, key) && obj[key] !== undefined;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "typeshi",
-    "version": "2.1.1",
+    "version": "2.1.3",
     "description": "TypeScript utility modules",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",