Circular dependency has been detected when using the ESLint with TypeORM

Question

Circular dependency has been detected when using the ESLint with TypeORM

Having two entity typeorm with a bi-directional one-to-one relationship:

Departament:

@Entity('Departament')
export default class Departament {
  @PrimaryGeneratedColumn()
  id: string;

  @Column()
  departament_name: string;

  @OneToOne(type => User, user => user.departament)
  @JoinColumn()
  user: User;

  @CreateDateColumn({ name: 'created_at' })
  createdAt: Date;

  @UpdateDateColumn({ name: 'updated_at' })
  UpdatedAt: Date;
}

User:

@Entity('User')
export default class User {
  @PrimaryGeneratedColumn()
  id: string;

  @Column()
  name: string;

  @Column()
  last_name: string;

  @Column()
  email: string;

  @Column()
  login: string;

  @Column()
  password: string;

  @OneToOne(type => Departament, departament => departament.user)
  departament: Departament;
}

Here are my .eslintrc settings:

{
  "env": {
    "es6": true,
    "node": true,
    "jest": true
  },
  "extends": [
    "airbnb-base",
    "plugin:@typescript-eslint/recommended",
    "prettier/@typescript-eslint",
    "plugin:prettier/recommended"
  ],
  "globals": {
    "Atomics": "readonly",
    "SharedArrayBuffer": "readonly"
  },
  "parser": "@typescript-eslint/parser",
  "parserOptions": {
    "ecmaVersion": 2018,
    "sourceType": "module"
  },
  "plugins": ["@typescript-eslint", "prettier"],
  "rules": {
    "prettier/prettier": "error",
    "no-new": "off",
    "no-underscore-dangle": "off",
    "class-methods-use-this": "off",
    "no-await-in-loop": "off",
    "import/prefer-default-export": "off",
    "import/extensions": [
      "error",
      "ignorePackages",
      {
        "ts": "never"
      }
    ],
    "import/no-extraneous-dependencies": [
      "error",
      {
        "devDependencies": ["**/*.spec.ts", "src/utils/tests/*.ts"]
      }
    ],
    "no-useless-constructor": "off",
    "@typescript-eslint/no-unused-vars": [
      "error",
      {
        "argsIgnorePattern": "_"
      }
    ],
    "@typescript-eslint/no-useless-constructor": "error",
    "camelcase": "off",
    "@typescript-eslint/camelcase": "off"
  },
  "overrides": [
    {
      "files": ["*.js"],
      "rules": {
        "@typescript-eslint/no-var-requires": "off"
      }
    }
  ],
  "settings": {
    "import/extensions": [".ts", ".js"],
    "import/parsers": {
      "@typescript-eslint/parser": [".ts", ".js"]
    },
    "import/resolver": {
      "typescript": {
        "alwaysTryTypes": true
      }
    }
  }
}

Encountering these errors:

Error: dependency cycle detected.eslintimport/no-cycle

Specifically on (user and department)

And also this error:

'type' is defined but never used. Allowed unused args must match /_/u.eslint@typescript-eslint/no-unused-vars

I'm struggling to resolve this issue and unsure of the best course of action as I follow the TypeORM getting started guide.

typescript typeorm

Answer 1

Answer №1

Dealing with circular imports in programming can sometimes be a challenge, but it's usually possible to resolve them without causing too many issues. The eslint rule import/no-cycle is designed to catch any potential problems early on, which is definitely helpful. For more insights on this topic, check out a detailed Stack Overflow answer that recommends avoiding circular dependencies altogether.

If you're using TypeORM, there's an ongoing discussion in the repository that explores different solutions, each with its own pros and cons. Two commonly used solutions are entity schemas and string references. These approaches involve defining relations using strings and resolving them later when needed.

This method of handling circular dependencies is not unique to TypeORM; similar strategies can be found in other ORMs like SQLAlchemy in Python or ActiveRecord in Ruby on Rails. By retrieving entity classes or schemas from a registry using their names as strings, the need for explicit module imports to establish relationships is eliminated.

For example:

Entity schemas

Instead of defining entities using traditional class syntax and decorators, you can create instances of EntitySchema:

export const DepartmentEntity = new EntitySchema({
  name: "Department",
  columns: { /* omitted for brevity */ },
  relations: {
    user: {
      type: "one-to-one",
      target: "User"
    }
  }
})

export const UserEntity = new EntitySchema({
  ...
})

String references

This approach involves changing type functions and inverse side functions to strings and updating the relation attribute using import type:

...

...

Which one to choose?

The decision is yours to make. While the mechanics remain similar for both approaches, entity schemas are expected to become a core feature in future versions of TypeORM, offering better type safety compared to traditional classes. Consider your project requirements and preferences before deciding which solution suits you best.

Answer 2

Dealing with circular imports in programming can sometimes be a challenge, but it's usually possible to resolve them without causing too many issues. The eslint rule import/no-cycle is designed to catch any potential problems early on, which is definitely helpful. For more insights on this topic, check out a detailed Stack Overflow answer that recommends avoiding circular dependencies altogether.

If you're using TypeORM, there's an ongoing discussion in the repository that explores different solutions, each with its own pros and cons. Two commonly used solutions are entity schemas and string references. These approaches involve defining relations using strings and resolving them later when needed.

This method of handling circular dependencies is not unique to TypeORM; similar strategies can be found in other ORMs like SQLAlchemy in Python or ActiveRecord in Ruby on Rails. By retrieving entity classes or schemas from a registry using their names as strings, the need for explicit module imports to establish relationships is eliminated.

For example:

Entity schemas

Instead of defining entities using traditional class syntax and decorators, you can create instances of EntitySchema:

export const DepartmentEntity = new EntitySchema({
  name: "Department",
  columns: { /* omitted for brevity */ },
  relations: {
    user: {
      type: "one-to-one",
      target: "User"
    }
  }
})

export const UserEntity = new EntitySchema({
  ...
})

String references

This approach involves changing type functions and inverse side functions to strings and updating the relation attribute using import type:

...

...

Which one to choose?

The decision is yours to make. While the mechanics remain similar for both approaches, entity schemas are expected to become a core feature in future versions of TypeORM, offering better type safety compared to traditional classes. Consider your project requirements and preferences before deciding which solution suits you best.

Circular dependency has been detected when using the ESLint with TypeORM

Answer №1

Entity schemas

String references

Which one to choose?

Similar questions

React Typescript: Unable to set component as element

When switching tabs, Ion-select should not reload the selected name

Adding dependency service to the parent class in Angular

What could be causing the sorting function to malfunction on certain columns?

Troubleshooting problems encountered in Nest.js due to modifications made within a service.ts file

What is the best approach to handling an undefined quantity of input FormControls within Angular?

Sending input in a nested event listener

Utilizing the get and set methods to alter the structure of a string, but encountering the issue where the set method is

Angular: accomplish cascading requests to achieve desired outcomes

The 'import.meta' meta-property can only be used with the '--module' set to 'es2020', 'esnext', or 'system'.ts(1343)

Steps for opening standalone angular2 and TypeScript project in visual studio: A guide to launching your project

Ways to resolve: The JSX component does not contain any construction or call signatures

Is emitting a side effect event acceptable within an RxJS pipe?

Please indicate the data type in Vue using Typescript

Confirming changes to checkbox values in Angular 2 prior to updating

I am encountering unexpected behavior with NextJS's getInitialProps function, as it is giving me a compiler error stating "varName not found on type {}"

`How can TypeScript be used to designate the type of a variable within the useState hook?`

Typescript throwing error TS2307 when attempting to deploy a NodeJS app on Heroku platform

Determine the accurate data type while iterating through a for loop

Tips for telling the difference between typescript Index signatures and JavaScript computed property names