index.ts

import * as AST from '../../../ast';
import type { DecoratorImportSpecs } from '../../../util/index';
import { LIFECYCLE_HOOKS } from '../../../util/index';
import AbstractEOProp from '../abstract';
import EOActionMethod from './method';
import EOActionProp from './property';

export interface Action {
  hasInfiniteLoop: boolean;
}

/**
 * Ember Object Actions Property
 *
 * A wrapper object for Ember Object `actions` object properties to be
 * transformed into a series of `ClassMethod`s with the `@action` decorator.
 *
 * Each action on the object is represented either by an `EOActionMethod` or
 * `EOActionProp`.
 *
 * @example
 *
 * ```
 * import someActionUtil from 'some/action/util';
 *
 * const MyObject = EmberObject.extend({
 *   actions: {
 *     someActionUtil,
 *     bar() {},
 *   }
 * });
 * ```
 *
 * transforms into:
 *
 * ```
 * import someActionUtil from 'some/action/util';
 *
 * class MyObject extends EmberObject {
 *   @action
 *   someActionUtil() {
 *     return someActionUtil.call(this, ...arguments);
 *   }
 *
 *   @action
 *   bar() {}
 * }
 * ```
 */
export default class EOActionsProp extends AbstractEOProp<
  AST.EOActionsProp,
  AST.ClassMethod[]
> {
  readonly isClassDecorator = false as const;

  protected readonly value = this.rawProp.value;

  override get decoratorImportSpecs(): DecoratorImportSpecs {
    return {
      ...super.decoratorImportSpecs,
      action: true,
    };
  }

  build(): AST.ClassMethod[] {
    return this.actions.map((action) => {
      return action.build();
    });
  }

  // eslint-disable-next-line @typescript-eslint/class-literal-property-style
  protected override get needsDecorators(): boolean {
    return true;
  }

  protected override get typeErrors(): string[] {
    return [...this.lifecycleHookErrors, ...this.infiniteLoopErrors];
  }

  private get actions(): Array<EOActionProp | EOActionMethod> {
    return this.value.properties.map((raw) =>
      AST.isEOActionMethod(raw)
        ? new EOActionMethod(raw, this.options)
        : new EOActionProp(raw, this.options)
    );
  }

  /**
   * Iterate over actions and verify that the action name does not match the lifecycle hooks
   * The transformation is not supported if an action has the same name as lifecycle hook
   * Reference: https://github.com/ember-codemods/ember-native-class-codemod/issues/34
   */
  private get lifecycleHookErrors(): string[] {
    const { actions } = this;
    const errors: string[] = [];
    for (const action of actions) {
      const { name } = action;
      if (LIFECYCLE_HOOKS.has(name)) {
        errors.push(
          this.makeActionError(
            name,
            'action name matches one of the lifecycle hooks. Rename and try again. See https://github.com/ember-codemods/ember-native-class-codemod/issues/34 for more details'
          )
        );
      }
    }
    return errors;
  }

  /**
   * Validation against pattern mentioned https://github.com/scalvert/eslint-plugin-ember-es6-class/pull/2
   */
  private get infiniteLoopErrors(): string[] {
    const { actions } = this;
    const errors: string[] = [];
    for (const action of actions) {
      if (action.hasInfiniteLoop) {
        const { name } = action;
        errors.push(
          this.makeActionError(
            name,
            `calling the passed action would cause an infinite loop. See https://github.com/scalvert/eslint-plugin-ember-es6-class/pull/2 for more details`
          )
        );
      }

      return errors;
    }
    return errors;
  }

  private makeActionError(actionName: string, message: string): string {
    return this.makeError(`[${actionName}]: ${message}`);
  }
}