Support passing a transformer function to

Author: kjellmorten

src/tests/transform.test.ts

@@ -14,7 +14,7 @@ const removeAuthor = async (item: Record<string, unknown>) =>
         0,
         item.title.length -
           6 -
-          (typeof item.author === 'string' ? item.author.length : 0)
+          (typeof item.author === 'string' ? item.author.length : 0),
       )
     : item.title
 
@@ -174,7 +174,7 @@ test('should reverse map simple object with dedicated rev transform', async (t)
   t.deepEqual(ret, expected)
 })
 
-test('should transform beofre data is set on outer path', async (t) => {
+test('should transform before data is set on outer path', async (t) => {
   const def = {
     attributes: [
       'result.data',
@@ -630,6 +630,28 @@ test('should provide index when iterating in reverse', async (t) => {
   t.deepEqual(ret, expected)
 })
 
+test('should use transformer function provided directly to $transform', async (t) => {
+  const def = [
+    {
+      title: 'content.heading',
+      author: 'meta.writer.username',
+    },
+    { $transform: appendAuthorToTitle },
+  ]
+  const data = {
+    content: { heading: 'The heading' },
+    meta: { writer: { username: 'johnf' } },
+  }
+  const expected = {
+    title: 'The heading - by johnf',
+    author: 'johnf',
+  }
+
+  const ret = await mapTransform(def)(data)
+
+  t.deepEqual(ret, expected)
+})
+
 test('should support $value shorthand', async (t) => {
   const def = [
     {
@@ -795,7 +817,7 @@ test('should throw when transform is given an unknown transformer id', (t) => {
   t.true(error instanceof Error)
   t.is(
     error?.message,
-    "Transform operator was given the unknown transformer id 'unknown'"
+    "Transform operator was given the unknown transformer id 'unknown'",
   )
 })
 
@@ -811,7 +833,7 @@ test('should throw when transform is given an unknown transformer id symbol', (t
   t.true(error instanceof Error)
   t.is(
     error?.message,
-    "Transform operator was given the unknown transformer id 'Symbol(unknown)'"
+    "Transform operator was given the unknown transformer id 'Symbol(unknown)'",
   )
 })
 
@@ -829,7 +851,7 @@ test('should throw when transform operation is missing a transformer id', (t) =>
   t.true(error instanceof Error)
   t.is(
     error?.message,
-    'Transform operator was given no transformer id or an invalid transformer id'
+    'Transform operator was given no transformer id or an invalid transformer id',
   )
 })
 
@@ -847,7 +869,7 @@ test('should throw when transform operation has invalid transformer id', async (
   t.true(error instanceof Error)
   t.is(
     error?.message,
-    'Transform operator was given no transformer id or an invalid transformer id'
+    'Transform operator was given no transformer id or an invalid transformer id',
   )
 })
 
@@ -873,7 +895,7 @@ test('should run operation objects trought modifyOperationObject', async (t) =>
   }
 
   const ret = await mapTransform(def, { transformers, modifyOperationObject })(
-    data
+    data,
   )
 
   t.deepEqual(ret, expected)

src/types.ts

@@ -41,7 +41,7 @@ export interface Options {
   fwdAlias?: string
   revAlias?: string
   modifyOperationObject?: (
-    operation: Record<string, unknown>
+    operation: Record<string, unknown>,
   ) => Record<string, unknown>
   modifyGetValue?: (value: unknown, state: State, options: Options) => unknown
 }
@@ -99,7 +99,11 @@ export interface AsyncTransformer<T = TransformerProps> {
 export type Path = string
 
 export interface TransformOperation extends TransformerProps {
-  $transform: string | symbol
+  $transform:
+    | string
+    | symbol
+    | DataMapperWithOptions
+    | AsyncDataMapperWithOptions
   $iterate?: boolean
   $direction?: string
 }

src/utils/definitionHelpers.ts

@@ -123,26 +123,32 @@ const createOperation =
   ): Operation =>
   (options) => {
     const { [fnProp]: fnId, ...props } = def
-    if (typeof fnId !== 'string' && typeof fnId !== 'symbol') {
-      throw new Error(
-        `${humanizeOperatorName(
-          fnProp,
-        )} operator was given no transformer id or an invalid transformer id`,
-      )
-    }
+    let transformFn
+    if (typeof fnId === 'function') {
+      transformFn = fnId as DataMapperWithOptions | AsyncDataMapperWithOptions
+    } else {
+      if (typeof fnId !== 'string' && typeof fnId !== 'symbol') {
+        throw new Error(
+          `${humanizeOperatorName(
+            fnProp,
+          )} operator was given no transformer id or an invalid transformer id`,
+        )
+      }
 
-    // eslint-disable-next-line security/detect-object-injection
-    const fn = options.transformers && options.transformers[fnId]
-    if (typeof fn !== 'function') {
-      throw new Error(
-        `${humanizeOperatorName(
-          fnProp,
-        )} operator was given the unknown transformer id '${String(fnId)}'`,
-      )
+      // eslint-disable-next-line security/detect-object-injection
+      const fn = options.transformers && options.transformers[fnId]
+      if (typeof fn !== 'function') {
+        throw new Error(
+          `${humanizeOperatorName(
+            fnProp,
+          )} operator was given the unknown transformer id '${String(fnId)}'`,
+        )
+      }
+      transformFn = fn(props)
     }
 
-    return typeof fn === 'function'
-      ? wrapFromDefinition(operationFn(fn(props)), def)(options)
+    return typeof transformFn === 'function'
+      ? wrapFromDefinition(operationFn(transformFn), def)(options)
       : passStateThroughNext
   }
 
@@ -252,12 +258,12 @@ export const defToOperations = (
   isPipeline(def)
     ? def.flatMap((def) => defToOperations(def, options))
     : isObject(def)
-    ? operationFromObject(def, options)
-    : isPath(def)
-    ? get(def)
-    : isOperation(def)
-    ? def
-    : () => () => async (value) => value
+      ? operationFromObject(def, options)
+      : isPath(def)
+        ? get(def)
+        : isOperation(def)
+          ? def
+          : () => () => async (value) => value
 
 export function defToOperation(
   def: TransformDefinition | undefined,