How to fix Decorator factory must return a function in TypeScript

// WRONG - no return statement (returns undefined)
function MyDecorator(config: string) {
  function decorator(target: any) {
    console.log(config, target);
  }
  // Missing return!
}

// CORRECT - returns the decorator function
function MyDecorator(config: string) {
  return function decorator(target: any) {
    console.log(config, target);
  };
}

// Usage
@MyDecorator("my-config")
class MyClass {}

// WRONG - curly braces without return
const MyDecorator = (config: string) => {
  (target: any) => {
    console.log(config, target);
  }
};

// CORRECT - explicit return
const MyDecorator = (config: string) => {
  return (target: any) => {
    console.log(config, target);
  };
};

// ALSO CORRECT - implicit return with parentheses
const MyDecorator = (config: string) => (target: any) => {
  console.log(config, target);
};

// WRONG - some paths return undefined
function MyDecorator(enabled: boolean) {
  if (enabled) {
    return function(target: any) {
      console.log("Enabled", target);
    };
  }
  // Missing return for else case!
}

// CORRECT - all paths return a function
function MyDecorator(enabled: boolean) {
  return function(target: any) {
    if (enabled) {
      console.log("Enabled", target);
    }
  };
}

// ALSO CORRECT - explicit returns for all cases
function MyDecorator(enabled: boolean) {
  if (enabled) {
    return function(target: any) {
      console.log("Enabled", target);
    };
  }

  return function(target: any) {
    console.log("Disabled", target);
  };
}

// Class decorator
function ClassDecorator(options: any) {
  return function<T extends { new (...args: any[]): {} }>(constructor: T) {
    // Modify or return constructor
    return constructor;
  };
}

// Method decorator
function MethodDecorator(options: any) {
  return function(
    target: any,
    propertyKey: string | symbol,
    descriptor: PropertyDescriptor
  ) {
    // Modify descriptor
    return descriptor;
  };
}

// Property decorator
function PropertyDecorator(options: any) {
  return function(target: any, propertyKey: string | symbol) {
    // Define property metadata
  };
}

// Parameter decorator
function ParameterDecorator(options: any) {
  return function(
    target: any,
    propertyKey: string | symbol,
    parameterIndex: number
  ) {
    // Store parameter metadata
  };
}

// WRONG - async factory returns a Promise, not a function
async function MyDecorator(config: string) {
  const data = await fetchConfig(config);
  return function(target: any) {
    console.log(data, target);
  };
}

// WRONG - trying to await in decorator usage (not supported)
@await MyDecorator("config")
class MyClass {}

// CORRECT - fetch synchronously or use a different pattern
function MyDecorator(config: string) {
  // Fetch data inside the decorator, not the factory
  return function(target: any) {
    fetchConfig(config).then(data => {
      console.log(data, target);
    });
  };
}

// CORRECT - pass data directly if already available
function MyDecorator(data: any) {
  return function(target: any) {
    console.log(data, target);
  };
}

// Plain decorator (no factory) - use without parentheses
function SimpleDecorator(target: any) {
  console.log("Decorating", target);
}

@SimpleDecorator  // No parentheses
class ClassA {}

// Decorator factory - requires parentheses
function ConfigurableDecorator(config: string) {
  return function(target: any) {
    console.log(config, target);
  };
}

@ConfigurableDecorator("my-config")  // With parentheses and arguments
class ClassB {}

// WRONG - mixing them up
@SimpleDecorator("config")  // Error: SimpleDecorator doesn't return a function
class ClassC {}

@ConfigurableDecorator  // Error: This returns the factory, not the decorator
class ClassD {}