How to prevent some fields of my object to be transformed by class-transformer

Answer: I've analyzed and debugged the whole TransformOperationExecutor.ts, and simply put, there is no in-build way to suppress the myriad of transformations this executor attempts to do. I thought maybe removing the @Type decorator all together could achieve the goal. But even with the missing type information, the library still tries to transform complex objects into plain objects as best as possible. The reason why @Transform(({value})=>...) is not working is that even for the returned value, there are multiple checks to figure out if the transformed value needs any further transformations to be "plain".

Workaround: The only solution I see is to build that functionality yourself. I can offer the following implementation to simulate an @Ignore feature:

import { classToPlain, ClassTransformOptions, Transform, TransformFnParams } from 'class-transformer';

// New decorator to be used on members that should not be transformed.
export function Ignore() {
    // reuse transform decorator
    return Transform((params: TransformFnParams) => {
        if (params.type == TransformationType.CLASS_TO_PLAIN) {
            // class-transformer won't touch functions,
            // so we use function-objects as container to skip transformation.
            const container = () => params.value;
            container.type = '__skipTransformContainer__';

            return container;
        }
        // On other transformations just return the value.
        return params.value;
    });
}

// Extended classToPlain to unwrap the container objects
export function customClassToPlain<T>(object: T, options?: ClassTransformOptions) {
    const result = classToPlain(object, options);
    unwrapSkipTransformContainers(result);
    return result;
}

// Recursive function to iterate over all keys of an object and its nested objects.
function unwrapSkipTransformContainers(obj: any) {
    for (const i in obj) {
        if (obj.hasOwnProperty(i)) {
            const currentValue = obj[i];
            if (currentValue?.type === '__skipTransformContainer__') {
                // retrieve the original value and also set it.
                obj[i] = currentValue();
                continue;
            }

            // recursion + recursion anchor
            if (typeof currentValue === 'object') {
                unwrapSkipTransformContainers(currentValue);
            }
        }
    }
}

This solution exploits that the class-transformer won't transform functions (except get/set functions), as those are not part of a plain object. We reuse the Transform decorator to wrap members we don't want to be transformed with a function. We also mark those functions with the string __skipTransformContainer__ to make it easy to find them later and not accidentally call the wrong functions. Then we write a new customClassToPlain, which first calls the default classToPlain and then calls a recursive unwrap function on the result. The unwrap function is called unwrapSkipTransformContainer and recursively searches all __skipTransformContainer__-containers to retrieve the untransformed values.

Usage:

export abstract class StopStep extends Step {
  id: string;
  name: string;
  description: string;
  pointOfInterest: PointOfInterest | null;
  address: string;
  @Ignore()
  coordinates: firebase.firestore.GeoPoint;
}

class ExampleStep extends StopStep {/*logic*/}
    
const step = new ExampleStep();
const plain = customClassToPlain(step);

Bad news; Micro S. is right. "class-transformer" forces to apply default transformation even you have a custom transformation function. This limits usage of custom transformation function, and means "you can not return what ever you want".

Good news; JavaScript is a high flexible language. This means you can override any function of a class prototype. The code below fixes this issue without loosing performance.

import isPlainObject from 'putil-isplainobject';

const oldTransformFn = TransformOperationExecutor.prototype.transform;
TransformOperationExecutor.prototype.transform =
  function transform(source: Record<string, any> | Record<string, any>[] | any,
                     value: Record<string, any> | Record<string, any>[] | any,
                     targetType: Function | TypeMetadata,
                     // eslint-disable-next-line @typescript-eslint/no-unused-vars
                     arrayType: Function,
                     // eslint-disable-next-line @typescript-eslint/no-unused-vars
                     isMap: boolean,
                     // eslint-disable-next-line @typescript-eslint/no-unused-vars
                     level?: number): any {
    // @ts-ignore
    if (isPlainObject(value) && targetType === Object) {
      return value;
    }
    // @ts-ignore
    return oldTransformFn.apply(this, arguments);
  };