Enhance transformer api

Author: openscript

src/DSVImport.tsx

@@ -6,8 +6,8 @@ import { State } from './models/state';
 import { applyMiddlewares } from './middlewares/middleware';
 import { createValidatorMiddleware } from './middlewares/validatorMiddleware';
 import { ValidationError } from './models/validation';
-import { Transformers } from './models/transformer';
 import { createTransformerMiddleware } from './middlewares/transformerMiddleware';
+import { Transformer } from './models/transformer';
 
 interface EventListenerProps<T> {
   onChange?: (value: T[]) => void;
@@ -35,7 +35,7 @@ const EventListener = <T extends { [key: string]: string }>(props: EventListener
 export interface Props<T> {
   onChange?: (value: T[]) => void;
   onValidation?: (errors: ValidationError<T>[]) => void;
-  transformers?: Transformers<T>;
+  transformers?: Transformer[];
   columns: ColumnsType<T>;
 }
 

src/middlewares/transformerMiddleware.test.ts

@@ -15,6 +15,8 @@ describe('validatorMiddleware', () => {
     { forename: 'Heidi', surname: ' Muster', email: '[email protected]' },
     { forename: 'Joe', surname: 'Doe', email: ' [email protected] ' }
   ];
+  const trimTransformer = (value: string) => value.trim();
+  const markTransformer = (value: string) => `${value}!`;
 
   it('should not dispatch if there are no transformers', () => {
     const state: State<TestType> = { columns: defaultColumns };
@@ -25,8 +27,7 @@ describe('validatorMiddleware', () => {
   });
 
   it('should run a transformer on all values', () => {
-    const trimTransformer = (value: string) => value.trim();
-    const state: State<TestType> = { columns: defaultColumns, transformers: [{ transformer: trimTransformer }] };
+    const state: State<TestType> = { columns: defaultColumns, transformers: [trimTransformer] };
     const dispatchMock = jest.fn();
 
     middleware(state, dispatchMock, { type: 'setParsed', parsed });
@@ -42,10 +43,12 @@ describe('validatorMiddleware', () => {
   });
 
   it('should run transformers on values of a certain column', () => {
-    const trimTransformer = (value: string) => value.trim();
     const state: State<TestType> = {
-      columns: defaultColumns,
-      transformers: [{ transformer: trimTransformer, column: 'surname' }]
+      columns: [
+        { key: 'forename', label: 'Forename' },
+        { key: 'surname', label: 'Surname', transformers: [trimTransformer, markTransformer] },
+        { key: 'email', label: 'Email' }
+      ]
     };
     const dispatchMock = jest.fn();
 
@@ -54,9 +57,9 @@ describe('validatorMiddleware', () => {
     expect(dispatchMock).toBeCalledWith({
       type: 'setParsed',
       parsed: [
-        { forename: 'Hans', surname: 'Muster', email: '[email protected]' },
-        { forename: 'Heidi', surname: 'Muster', email: '[email protected]' },
-        { forename: 'Joe', surname: 'Doe', email: ' [email protected] ' }
+        { forename: 'Hans', surname: 'Muster!', email: '[email protected]' },
+        { forename: 'Heidi', surname: 'Muster!', email: '[email protected]' },
+        { forename: 'Joe', surname: 'Doe!', email: ' [email protected] ' }
       ]
     });
   });

src/middlewares/transformerMiddleware.ts

@@ -1,36 +1,50 @@
 import { State } from '../models/state';
 import { Dispatch } from 'react';
 import { Actions } from '../models/actions';
-import { TransformerConfiguration } from '../models/transformer';
 import { ColumnsType } from '../models/column';
+import { Transformer } from '../models/transformer';
 
-const executeTransformer = <T>(
-  values: T[],
-  transformerConfiguration: TransformerConfiguration<T>,
-  columns: ColumnsType<T>
-) => {
-  const currentColumns = transformerConfiguration.column
-    ? columns.filter((c) => c.key === transformerConfiguration.column)
-    : columns;
+const executeGlobalTransformers = <T>(values: T[], transformer: Transformer, columns: ColumnsType<T>) => {
   return values.map<T>((r) => {
     const transformed = { ...r };
-    currentColumns.forEach((c) => {
-      transformed[c.key] = (transformerConfiguration.transformer(
-        new String(r[c.key]).toString()
-      ) as unknown) as T[keyof T];
+    columns.forEach((c) => {
+      transformed[c.key] = (transformer(new String(r[c.key]).toString()) as unknown) as T[keyof T];
+    });
+    return transformed;
+  });
+};
+
+const executeColumnTransformers = <T>(values: T[], columns: ColumnsType<T>) => {
+  return values.map<T>((r) => {
+    const transformed = { ...r };
+    columns.forEach((c) => {
+      if (c.transformers) {
+        transformed[c.key] = (c.transformers.reduce(
+          (acc, t) => t(acc),
+          new String(r[c.key]).toString()
+        ) as unknown) as T[keyof T];
+      }
     });
     return transformed;
   });
 };
 
 export const createTransformerMiddleware = <T>() => {
   return (state: State<T>, next: Dispatch<Actions<T>>, action: Actions<T>) => {
-    if (action.type === 'setParsed' && state.transformers) {
-      const parsed = state.transformers.reduce<T[]>(
-        (acc, t) => executeTransformer(acc, t, state.columns),
-        action.parsed
-      );
-      next({ type: 'setParsed', parsed });
+    if (action.type === 'setParsed') {
+      let parsed = action.parsed;
+      if (state.transformers) {
+        parsed = state.transformers.reduce<T[]>((acc, t) => executeGlobalTransformers(acc, t, state.columns), parsed);
+      }
+
+      const hasColumnTransformers = state.columns.find((c) => c.transformers) ? true : false;
+      if (hasColumnTransformers) {
+        parsed = executeColumnTransformers(parsed, state.columns);
+      }
+
+      if (state.transformers || hasColumnTransformers) {
+        next({ type: 'setParsed', parsed });
+      }
     }
   };
 };

src/models/column.ts

@@ -1,3 +1,4 @@
 import { Rule } from './rule';
+import { Transformer } from './transformer';
 
-export type ColumnsType<T> = { key: keyof T; label: string; rules?: Rule[] }[];
+export type ColumnsType<T> = { key: keyof T; label: string; rules?: Rule[]; transformers?: Transformer[] }[];

src/models/state.ts

@@ -1,12 +1,12 @@
 import { ColumnsType } from './column';
 import { ValidationError } from './validation';
-import { Transformers } from './transformer';
+import { Transformer } from './transformer';
 
 export interface State<T> {
   raw?: string;
   parsed?: T[];
   validation?: ValidationError<T>[];
-  transformers?: Transformers<T>;
+  transformers?: Transformer[];
   columns: ColumnsType<T>;
 }
 

src/models/transformer.ts

@@ -1,3 +1 @@
 export type Transformer = (value: string) => string;
-export type TransformerConfiguration<T> = { transformer: Transformer; column?: keyof T };
-export type Transformers<T> = TransformerConfiguration<T>[];