typeshi 2.1.3 → 2.1.5

package/dist/utils/object.d.ts

@@ -24,24 +24,35 @@ export declare class Restrict {
     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.
+ * define a `TransformationSchema<T, S>` to use in `sanitizeAndMap`, where entries from
+ * a `source` object `S` are mapped to a new object `T`
+ *
+ * `values` are either:
+ * 1. a `function` where only need to pass in `source[K]` to get the transformed value `T[K]`
+ * 2. {@link TransformOptions}, an object with props:
+ * - `sourceKey (keyof S, optional)` - indicates that should transform `source[sourceKey]` to `T[K]`.
+ * `sourceKey = TransformOptions.sourceKey ?? K`
+ * - `transform (function, optional)` - `function` that uses `source[sourceKey]` & `args` to compute `T[K]`
+ * - `args (any[], optional)` - the array of arguments passed into `transform` using the spread operator, i.e. `transform(source[sourceKey], ...args)`
+ * - `defaultValue (T[K], optional)` - assign this value to `K` **only when** `transform` is `undefined`
+ * and `source[sourceKey]` is `undefined`
  */
-export type TransformationSchema<T> = {
-    [K in keyof T]?: ((val: any) => T[K]) | {
-        transform: (val: any, ...args: any[]) => T[K];
-        args: any[];
-    };
+export type TransformationSchema<T extends object, S extends Record<keyof any, unknown> = any> = {
+    [K in keyof T]?: ((val: S[keyof S]) => T[K]) | TransformOptions<T, K, S>;
+};
+export type TransformOptions<T extends object, K extends keyof T, S extends Record<keyof any, unknown> = any> = {
+    transform?: (val: S[keyof S], ...args: any[]) => T[K];
+    args?: any[];
+    defaultValue?: T[K];
+    sourceKey?: keyof S;
 };
 /**
- * @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)
+ * @param obj `S` - source object (e.g., Request Body)
+ * @param schema {@link TransformationSchema}`<T, S>` - map of keys to transformation functions.
+ * @param passThroughKeys `(keyof T)[] (optional)` - 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;
+export declare function sanitizeAndMap<T extends object, S extends Record<keyof any, unknown> = any>(obj: S, schema: TransformationSchema<T, S>, passThroughKeys?: (keyof T)[]): T;
 /**
  * @returns `Object.prototype.hasOwnProperty.call(obj, key) && obj[key] !== undefined;`
  */

package/dist/utils/object.js

@@ -42,23 +42,31 @@ Restrict.keys = hasValidKeysOnly;
  */
 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)
+ * @param obj `S` - source object (e.g., Request Body)
+ * @param schema {@link TransformationSchema}`<T, S>` - map of keys to transformation functions.
+ * @param passThroughKeys `(keyof T)[] (optional)` - 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]);
+        const schemaValue = schema[key];
+        if (!schemaValue)
+            continue;
+        const sourceKey = 'sourceKey' in schemaValue && schemaValue.sourceKey ? schemaValue.sourceKey : key;
+        if (hasDefinedEntry(obj, sourceKey)) {
+            if ((0, typeValidation_1.isFunction)(schemaValue)) { // schemaValue is ((val: S[keyof S]) => T[K])
+                data[key] = schemaValue(obj[sourceKey]);
             }
-            else {
-                data[key] = schema[key].transform(obj[key], ...schema[key].args);
+            else if ((0, typeValidation_1.isFunction)(schemaValue.transform)) { // schemaValue is { transform?: (val: S[keyof S], ...args: any[]) => T[K]; args?: any[]; sourceKey?: keyof S}
+                data[key] = schemaValue.transform(obj[sourceKey], ...(schemaValue.args ?? []));
             }
         }
+        else if (!(0, typeValidation_1.isFunction)(schemaValue) && 'defaultValue' in schemaValue) {
+            // `obj[K]` is `undefined`, can apply defaultValue
+            data[key] = schemaValue.defaultValue;
+        }
     }
     // 2. Handle simple pass-throughs (Identity mapping)
     for (const key of passThroughKeys) {

package/package.json

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