@edirect/template 1.0.2 → 1.0.6

package/README.md

@@ -1,6 +1,6 @@
 # @edirect/template
 
-The EDirectInsure template mapper module.
+TemplateModule is a library that provides methods to transform a payload based on a given template. The transformation includes mapping fields, applying transformers, setting default values and so on.
 
 ### Installation
 
@@ -8,6 +8,57 @@ The EDirectInsure template mapper module.
 $ npm i --save @edirect/template
 ```
 
+### Import
+
+```javascript
+import { TemplateModule } from "./TemplateModule";
+```
+
+### Methods
+
+#### `Constructor`
+
+The TemplateModule class does not have a constructor.
+
+#### `setContext(context): void`
+
+Sets the context object to be used during the transformation.
+
+#### `setTemplate(template): void`
+
+Sets the template object that describes the transformation to be performed.
+
+#### `setTransformers(transformers: ITransformer): void`
+
+Sets the transformers to be used during the transformation.
+
+#### `verifyTransformer(transformer: ITransformer, methodName: string): boolean`
+
+Verifies if a given transformer method exists.
+
+#### `runTransformer(transformer: string, value?: unknown): unknown | null`
+
+Runs a transformer on a given value.
+
+- transformer - The name of the transformer to be used.
+- value - The value to be transformed.
+
+#### `checkValue(value: any): boolean`
+
+Checks if a given value is not null, undefined, or an empty string.
+
+#### `setValueByCondition(object, key: string, value: unknown)`
+
+Sets a value in an object after verify using the checkValue() method.
+
+- object - The object to be modified.
+- key - The key of the value to be set.
+- value - The value to be set.
+
+#### `transformPayload<T, U>(obj: T, template = this.template): U`
+
+Transforms a payload object on a given template.
+
 ### Simple example
 
 ```javascript
@@ -63,7 +114,7 @@ To map a value that you'd like to use some transformer feature, you can use thes
 - `transformer`: it's a JS function, where you receive value and context as parameters and have all freedom to handle and return a value
 - `defaultValue` it's an option if the engine doesn't find any value in the fields data source array or the transformer doesn't return a value.
 
-#### File name: `baseTransformers.ts`
+##### File name: baseTransformers.ts
 
 ```javascript
 import { ITransformer, ITransformerParams } from "@edirect/template";
@@ -89,7 +140,7 @@ const transformers: ITransformer = {
 export default transformers;
 ```
 
-#### File name `index.ts`
+##### File name: index.ts
 
 ```javascript
 import { TemplateModule } from "@edirect/template";
@@ -140,3 +191,276 @@ console.log(result);
 //   timeZone: "Time zone in Porto (GMT+1)",
 // }
 ```
+
+### Example with nested object + transformers
+
+`Note`: the transformer notation uses three keys to identify an object as being a transformer: fields, transformer, and defaultValue, if there are at least 1 of these keys, the engine will consider the object as being a transformer, on the other hand, if there isn't, the engine will consider as a nested object to mapper all information.
+
+##### File name: baseTransformers.ts
+
+```javascript
+import { ITransformer, ITransformerParams } from "@edirect/template";
+
+const upperCase = ({ value }: ITransformerParams): string | null => {
+  return value ? String(value).toUpperCase() : null;
+};
+
+const transformers: ITransformer = {
+  upperCase,
+};
+
+export default transformers;
+```
+
+##### File name: index.ts
+
+```javascript
+import { TemplateModule } from "@edirect/template";
+import baseTransformers from "./baseTransformers";
+
+const template = {
+  order: {
+    date: "order.date",
+    value: "order.value",
+    subscriber: {
+      name: "sub.name",
+      phone: "sub.phone",
+      email: {
+        fields: ["email", "sub.email"],
+      },
+      address: {
+        street: "sub.add.stt",
+        number: "sub.add.num",
+        city: {
+          fields: ["sub.add.city"],
+          transformer: "upperCase",
+        },
+        state: {
+          fields: ["sub.add.stt"],
+          transformer: "upperCase",
+        },
+        zip: {
+          fields: ["sub.add.zip"],
+          defaultValue: "0000-000",
+        },
+      },
+    },
+  },
+};
+
+const dataSource = {
+  order: {
+    value: 1000.0,
+    date: "2000-01-01",
+  },
+  sub: {
+    name: "name-test",
+    phone: "999999999",
+    email: "template.service@bolltech.io",
+    add: {
+      st: "st-test",
+      num: 100,
+      city: "city-test",
+      stt: "state-test",
+      zip: "zip-test",
+    },
+  },
+};
+
+const templateModule = new TemplateModule();
+
+templateModule.setTemplate(template);
+templateModule.setContext(dataSource);
+templateModule.setTransformers(baseTransformers);
+
+const result = templateModule.transformPayload(dataSource);
+console.log(result);
+
+// {
+//   order: {
+//     date: "2000-01-01",
+//     value: 1000,
+//     subscriber: {
+//       name: "name-test",
+//       phone: "999999999",
+//       email: "template.service@bolltech.io",
+//       address: {
+//         street: "state-test",
+//         number: 100,
+//         city: "CITY-TEST",
+//         state: "STATE-TEST",
+//         zip: "zip-test",
+//       },
+//     },
+//   },
+// }
+```
+
+### Example with arrays + transformers
+
+`Note`: When it comes to arrays mapper, we need to have in mind that is required use this two keys: arraySource and arrayTemplate.
+
+- `arraySource`: source path where the engine will seek the information to mapper
+- `arrayTemplate`: template that will be used for each object within the array
+
+##### File name: baseTransformers.ts
+
+```javascript
+import { ITransformer, ITransformerParams } from "@edirect/template";
+
+const upperCase = ({ value }: ITransformerParams): string | null => {
+  return value ? String(value).toUpperCase() : null;
+};
+
+const transformers: ITransformer = {
+  upperCase,
+};
+
+export default transformers;
+```
+
+##### File name: index.ts
+
+```javascript
+import { TemplateModule } from "@edirect/template";
+import baseTransformers from "./baseTransformers";
+
+const template = {
+  quote: {
+    orders: {
+      arraySource: "order",
+      arrayTemplate: {
+        value: "value",
+        date: "date",
+        products: {
+          arraySource: "products",
+          arrayTemplate: {
+            id: "id",
+            value: "value",
+            description: {
+              fields: ["description"],
+              transformer: "upperCase",
+              defaultValue: "Default description",
+            },
+            categories: "categories",
+          },
+        },
+      },
+    },
+  },
+};
+
+const dataSource = {
+  order: [
+    {
+      value: 1000.0,
+      date: "2000-01-01",
+      products: [
+        {
+          id: "id-test-1",
+          value: 1000,
+          description: "description-test 1",
+          categories: ["category-1"],
+        },
+        {
+          id: "id-test-2",
+          value: 2000,
+          description: "description-test 2",
+          categories: ["category-1", "category-2"],
+        },
+        {
+          id: "id-test-3",
+          value: 3000,
+          categories: ["category-1", "category-2", "category-3"],
+        },
+      ],
+    },
+  ],
+};
+
+const templateModule = new TemplateModule();
+
+templateModule.setTemplate(template);
+templateModule.setContext(dataSource);
+templateModule.setTransformers(baseTransformers);
+
+const result = templateModule.transformPayload(dataSource);
+console.log(result);
+
+//{
+//  quote: {
+//     orders: [
+//       {
+//         value: 1000,
+//         date: "2000-01-01",
+//         products: [
+//           {
+//             id: "id-test-1",
+//             value: 1000,
+//             description: "DESCRIPTION-TEST 1",
+//             categories: ["category-1"],
+//           },
+//           {
+//             id: "id-test-2",
+//             value: 2000,
+//             description: "DESCRIPTION-TEST 2",
+//             categories: ["category-1", "category-2"],
+//           },
+//           {
+//             id: "id-test-3",
+//             value: 3000,
+//             description: "Default description",
+//             categories: ["category-1", "category-2", "category-3"],
+//           },
+//         ],
+//       },
+//     ],
+//   },
+// }
+```
+
+### Example inferring types to transformPayload
+
+```typescript
+import { TemplateModule } from "@edirect/template";
+
+interface DataSource {
+  subscriber: {
+    firstName: string;
+    lastName: string;
+  };
+}
+
+interface TransformedData {
+  edirect_firstname: string;
+  edirect_lastname: string;
+}
+
+function transformData(dataSource: DataSource): TransformedData {
+  const template = {
+    edirect_firstname: "subscriber.firstName",
+    edirect_lastname: "subscriber.lastName",
+  };
+
+  const templateModule = new TemplateModule();
+  templateModule.setTemplate(template);
+
+  return templateModule.transformPayload<DataSource, TransformedData>(
+    dataSource
+  );
+}
+
+const dataSource = {
+  subscriber: {
+    firstName: "template",
+    lastName: "service",
+  },
+};
+
+console.log(transformData(dataSource));
+
+// {
+//   edirect_firstname: "template",
+//   edirect_lastname: "service",
+// }
+```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@edirect/template",
-  "version": "1.0.2",
+  "version": "1.0.6",
   "description": "Template Module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",