@echoes-of-order/eslint-config 1.121.0

package/rules/stylistic.js

@@ -0,0 +1,93 @@
+/**
+ * Stylistic Rules
+ *
+ * Code-Styling und Formatierungsregeln
+ */
+
+export default {
+  rules: {
+    // Styling-Regeln
+    "@stylistic/indent": [
+      "error",
+      2,
+      {
+        "SwitchCase": 1,
+        "VariableDeclarator": 1,
+        "outerIIFEBody": 1,
+        "MemberExpression": 1,
+        "FunctionDeclaration": {
+          "parameters": 1,
+          "body": 1
+        },
+        "FunctionExpression": {
+          "parameters": 1,
+          "body": 1
+        },
+        "CallExpression": {
+          "arguments": 1
+        },
+        "ArrayExpression": 1,
+        "ObjectExpression": 1,
+        "ImportDeclaration": 1,
+        "flatTernaryExpressions": false,
+        "ignoreComments": false,
+        "ignoredNodes": [
+          "TemplateLiteral *",
+          "JSXElement",
+          "JSXElement > *",
+          "JSXAttribute",
+          "JSXIdentifier",
+          "JSXNamespacedName",
+          "JSXMemberExpression",
+          "JSXSpreadAttribute",
+          "JSXExpressionContainer",
+          "JSXOpeningElement",
+          "JSXClosingElement",
+          "JSXFragment",
+          "JSXOpeningFragment",
+          "JSXClosingFragment",
+          "JSXText",
+          "JSXEmptyExpression",
+          "JSXSpreadChild"
+        ]
+      }
+    ],
+    "@stylistic/quotes": ["error", "double"],
+    "@stylistic/semi": ["error", "always"],
+    "@stylistic/comma-dangle": ["error", "always-multiline"],
+    "@stylistic/object-curly-spacing": ["error", "always"],
+    "@stylistic/array-bracket-spacing": ["error", "never"],
+    "@stylistic/space-before-function-paren": ["error", "always"],
+    "@stylistic/arrow-spacing": ["error", { before: true, after: true }],
+    "@stylistic/block-spacing": ["error", "always"],
+    "@stylistic/brace-style": ["error", "1tbs", { allowSingleLine: true }],
+    "@stylistic/comma-spacing": ["error", { before: false, after: true }],
+    "@stylistic/computed-property-spacing": ["error", "never"],
+    "@stylistic/eol-last": ["error", "always"],
+    "@stylistic/key-spacing": ["error", { beforeColon: false, afterColon: true }],
+    "@stylistic/keyword-spacing": ["error", { before: true, after: true }],
+    "@stylistic/linebreak-style": ["error", "unix"],
+    "@stylistic/max-len": ["error", { code: 120, ignoreUrls: true }],
+    "@stylistic/max-statements-per-line": ["error", { max: 1 }],
+    "@stylistic/new-parens": "error",
+    "@stylistic/no-mixed-spaces-and-tabs": "error",
+    "@stylistic/no-multiple-empty-lines": ["error", { max: 2, maxEOF: 1 }],
+    "@stylistic/no-trailing-spaces": "error",
+    "@stylistic/no-whitespace-before-property": "error",
+    "@stylistic/object-curly-newline": ["error", { multiline: true, consistent: true }],
+    "@stylistic/object-property-newline": ["error", { allowAllPropertiesOnSameLine: true }],
+    "@stylistic/one-var-declaration-per-line": ["error", "always"],
+    "@stylistic/operator-linebreak": ["error", "before"],
+    "@stylistic/padded-blocks": ["error", "never"],
+    "@stylistic/quote-props": ["error", "as-needed"],
+    "@stylistic/semi-spacing": ["error", { before: false, after: true }],
+    "@stylistic/semi-style": ["error", "last"],
+    "@stylistic/space-before-blocks": "error",
+    "@stylistic/space-in-parens": ["error", "never"],
+    "@stylistic/space-infix-ops": "error",
+    "@stylistic/space-unary-ops": ["error", { words: true, nonwords: false }],
+    "@stylistic/spaced-comment": ["error", "always"],
+    "@stylistic/template-tag-spacing": ["error", "never"],
+    "@stylistic/wrap-regex": "error",
+  },
+};

package/rules/typeorm-column-type-validation.js

@@ -0,0 +1,224 @@
+/**
+ * @fileoverview TypeORM Column Type Validation Rule
+ * Stellt sicher, dass @Column Decorators explizite Type-Definitionen haben
+ * Verhindert ColumnTypeUndefinedError zur Laufzeit
+ */
+
+/** @type {import('eslint').Rule.RuleModule} */
+const typeormColumnTypeValidationRule = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Ensure @Column decorators have explicit type definitions to prevent ColumnTypeUndefinedError",
+      category: "TypeORM",
+      recommended: true,
+    },
+    hasSuggestions: true,
+    schema: [],
+    messages: {
+      missingColumnType: "@Column decorator for '{{propertyName}}' must have explicit type definition. Add type parameter: @Column({ type: '{{suggestedType}}' })",
+      missingColumnTypeGeneric: "@Column decorator for '{{propertyName}}' must have explicit type definition. Add type parameter: @Column({ type: '{{suggestedType}}' }{{additionalOptions}})",
+      useCreateDateColumn: "Consider using @CreateDateColumn() instead of @Column() for '{{propertyName}}'",
+      useUpdateDateColumn: "Consider using @UpdateDateColumn() instead of @Column() for '{{propertyName}}'",
+    },
+  },
+
+  create(context) {
+    const filename = context.getFilename();
+    const isEntityFile = filename.includes("/entity/") && filename.endsWith(".ts") && !filename.includes("test");
+
+    if (!isEntityFile) return {};
+
+    /**
+     * Schlägt einen TypeORM-Typ basierend auf TypeScript-Typ vor
+     */
+    function suggestTypeormType(tsType) {
+      const typeMap = {
+        "string": "varchar",
+        "number": "int",
+        "boolean": "boolean",
+        "Date": "timestamp",
+        "Date | null": "timestamp",
+        "string | null": "varchar",
+        "number | null": "int",
+        "boolean | null": "boolean",
+      };
+
+      return typeMap[tsType] || "varchar";
+    }
+
+    /**
+     * Prüft ob ein Property ein Datum ist
+     */
+    function isDateProperty(propertyName, tsType) {
+      const datePatterns = ["createdAt", "updatedAt", "deletedAt", "modifiedAt"];
+      return datePatterns.some(pattern =>
+        propertyName.toLowerCase().includes(pattern.toLowerCase())
+      ) || tsType === "Date" || tsType === "Date | null";
+    }
+
+    /**
+     * Schlägt den passenden Decorator für Datum-Properties vor
+     */
+    function suggestDateDecorator(propertyName) {
+      if (propertyName.toLowerCase().includes("created")) {
+        return "CreateDateColumn";
+      }
+      if (propertyName.toLowerCase().includes("updated") || propertyName.toLowerCase().includes("modified")) {
+        return "UpdateDateColumn";
+      }
+      return null;
+    }
+
+    /**
+     * Extrahiert TypeScript-Typ aus Property-Definition
+     */
+    function extractTypeScriptType(node) {
+      if (!node.typeAnnotation?.typeAnnotation) return "unknown";
+
+      const sourceCode = context.getSourceCode();
+      const typeText = sourceCode.getText(node.typeAnnotation.typeAnnotation);
+
+      // Entferne Whitespace und vereinfache
+      return typeText.replace(/\s+/g, " ").trim();
+    }
+
+    /**
+     * Prüft ob @Column Decorator Argumente hat
+     */
+    function hasColumnArguments(decorator) {
+      return decorator.expression.arguments && decorator.expression.arguments.length > 0;
+    }
+
+    /**
+     * Prüft ob @Column Decorator einen type-Parameter hat
+     */
+    function hasTypeParameter(decorator) {
+      if (!hasColumnArguments(decorator)) return false;
+
+      const args = decorator.expression.arguments[0];
+      if (args.type !== "ObjectExpression") return false;
+
+      return args.properties.some(prop =>
+        prop.type === "Property" &&
+        prop.key.name === "type"
+      );
+    }
+
+    return {
+      PropertyDefinition(node) {
+        if (!node.decorators || node.decorators.length === 0) return;
+
+        const columnDecorator = node.decorators.find(decorator =>
+          decorator.expression.callee?.name === "Column"
+        );
+
+        if (!columnDecorator) return;
+
+        const propertyName = node.key.name;
+        const tsType = extractTypeScriptType(node);
+
+        // Prüfe ob @Column() ohne Argumente verwendet wird
+        if (!hasColumnArguments(columnDecorator)) {
+          const suggestedType = suggestTypeormType(tsType);
+          const dateDecorator = suggestDateDecorator(propertyName);
+
+          if (dateDecorator) {
+            context.report({
+              node: columnDecorator,
+              messageId: dateDecorator === "CreateDateColumn" ? "useCreateDateColumn" : "useUpdateDateColumn",
+              data: { propertyName },
+              suggest: [
+                {
+                  desc: `Replace with @${dateDecorator}()`,
+                  fix(fixer) {
+                    return fixer.replaceText(
+                      columnDecorator.expression,
+                      `${dateDecorator}()`
+                    );
+                  }
+                }
+              ]
+            });
+          } else {
+            context.report({
+              node: columnDecorator,
+              messageId: "missingColumnType",
+              data: {
+                propertyName,
+                suggestedType
+              },
+              suggest: [
+                {
+                  desc: `Add type parameter to @Column`,
+                  fix(fixer) {
+                    return fixer.replaceText(
+                      columnDecorator.expression,
+                      `Column({ type: '${suggestedType}' })`
+                    );
+                  }
+                }
+              ]
+            });
+          }
+          return;
+        }
+
+        // Prüfe ob @Column({ ... }) ohne type-Parameter verwendet wird
+        if (!hasTypeParameter(columnDecorator)) {
+          const suggestedType = suggestTypeormType(tsType);
+          const args = columnDecorator.expression.arguments[0];
+
+          // Erstelle zusätzliche Optionen für den Fix
+          let additionalOptions = "";
+          if (args.type === "ObjectExpression" && args.properties.length > 0) {
+            const existingProps = args.properties
+              .filter(prop => prop.key.name !== "type")
+              .map(prop => {
+                const sourceCode = context.getSourceCode();
+                return sourceCode.getText(prop);
+              })
+              .join(", ");
+
+            if (existingProps) {
+              additionalOptions = `, ${existingProps}`;
+            }
+          }
+
+          context.report({
+            node: columnDecorator,
+            messageId: "missingColumnTypeGeneric",
+            data: {
+              propertyName,
+              suggestedType,
+              additionalOptions
+            },
+            suggest: [
+              {
+                desc: `Add type parameter to @Column`,
+                fix(fixer) {
+                  const sourceCode = context.getSourceCode();
+                  const decoratorText = sourceCode.getText(columnDecorator.expression);
+
+                  // Füge type-Parameter am Anfang der Objekt-Argumente hinzu
+                  const newDecoratorText = decoratorText.replace(
+                    /Column\(\s*\{/,
+                    `Column({ type: '${suggestedType}'`
+                  );
+
+                  return fixer.replaceText(columnDecorator.expression, newDecoratorText);
+                }
+              }
+            ]
+          });
+        }
+      }
+    };
+  },
+};
+
+export default {
+  rules: {
+    "typeorm-column-type-validation": typeormColumnTypeValidationRule,
+  },
+};

package/rules/typescript-advanced.js

@@ -0,0 +1,113 @@
+/**
+ * TypeScript Advanced Rules
+ *
+ * Erweiterte TypeScript-Regeln für Backend-Projekte
+ */
+
+export default {
+  rules: {
+    // TypeScript-Advanced-Regeln
+    "@typescript-eslint/array-type": ["error", {
+      default: "array-simple",
+      readonly: "array-simple"
+    }],
+    "@typescript-eslint/ban-tslint-comment": "error",
+    "@typescript-eslint/consistent-indexed-object-style": ["error", "record"],
+    "@typescript-eslint/consistent-type-assertions": ["error", {
+      assertionStyle: "as",
+      objectLiteralTypeAssertions: "never"
+    }],
+    "@typescript-eslint/no-base-to-string": ["error", {
+      ignoredTypeNames: ["Error", "RegExp", "URL", "URLSearchParams"]
+    }],
+    "@typescript-eslint/no-confusing-non-null-assertion": "error",
+    "@typescript-eslint/no-confusing-void-expression": ["error", {
+      ignoreArrowShorthand: false,
+      ignoreVoidOperator: false
+    }],
+    "@typescript-eslint/no-duplicate-type-constituents": "error",
+    "@typescript-eslint/no-dynamic-delete": "error",
+    "@typescript-eslint/no-extraneous-class": ["error", {
+      allowConstructorOnly: false,
+      allowEmpty: false,
+      allowStaticOnly: false,
+      allowWithDecorator: false
+    }],
+    "@typescript-eslint/no-invalid-void-type": ["error", {
+      allowInGenericTypeArguments: false,
+      allowAsThisParameter: false
+    }],
+    "@typescript-eslint/no-meaningless-void-operator": ["error", {
+      checkNever: true
+    }],
+    "@typescript-eslint/no-non-null-asserted-nullish-coalescing": "error",
+    "@typescript-eslint/no-non-null-asserted-optional-chain": "error",
+    "@typescript-eslint/no-redundant-type-constituents": "error",
+    "@typescript-eslint/no-unnecessary-boolean-literal-compare": ["error", {
+      allowComparingNullableBooleansToTrue: false,
+      allowComparingNullableBooleansToFalse: false
+    }],
+    "@typescript-eslint/no-unnecessary-condition": ["error", {
+      allowConstantLoopConditions: false,
+      allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing: false
+    }],
+    "@typescript-eslint/no-unnecessary-qualifier": "error",
+    "@typescript-eslint/no-unnecessary-type-arguments": "error",
+    "@typescript-eslint/no-unnecessary-type-assertion": "error",
+    "@typescript-eslint/no-unnecessary-type-constraint": "error",
+    "@typescript-eslint/no-useless-empty-export": "error",
+    "@typescript-eslint/prefer-as-const": "error",
+    "@typescript-eslint/prefer-for-of": "error",
+    "@typescript-eslint/prefer-function-type": "error",
+    "@typescript-eslint/prefer-includes": "error",
+    "@typescript-eslint/prefer-literal-enum-member": "error",
+    "@typescript-eslint/prefer-readonly": "error",
+    "@typescript-eslint/prefer-readonly-parameter-types": "off", // Zu strikt für Backend-Entwicklung
+    "@typescript-eslint/prefer-reduce-type-parameter": "error",
+    "@typescript-eslint/prefer-regexp-exec": "error",
+    "@typescript-eslint/prefer-return-this-type": "error",
+    "@typescript-eslint/prefer-string-starts-ends-with": "error",
+    "@typescript-eslint/prefer-ts-expect-error": "error",
+    "@typescript-eslint/promise-function-async": "error",
+    "@typescript-eslint/require-array-sort-compare": "error",
+    "@typescript-eslint/restrict-plus-operands": "error",
+    "@typescript-eslint/restrict-template-expressions": ["error", {
+      allowNumber: true,
+      allowBoolean: true,
+      allowAny: false,
+      allowNullish: false,
+      allowRegExp: false
+    }],
+    "@typescript-eslint/sort-type-constituents": "error",
+    "@typescript-eslint/strict-boolean-expressions": ["error", {
+      allowString: false,
+      allowNumber: false,
+      allowNullableObject: false,
+      allowNullableBoolean: false,
+      allowNullableString: false,
+      allowNullableNumber: false,
+      allowAny: false
+    }],
+    "@typescript-eslint/switch-exhaustiveness-check": "error",
+    "@typescript-eslint/triple-slash-reference": "error",
+    "@stylistic/type-annotation-spacing": "error",
+    "@typescript-eslint/typedef": ["error", {
+      arrayDestructuring: false,
+      arrowParameter: false,
+      memberVariableDeclaration: true,
+      objectDestructuring: false,
+      parameter: true,
+      propertyDeclaration: true,
+      variableDeclaration: false,
+      variableDeclarationIgnoreFunction: false
+    }],
+    "@typescript-eslint/unbound-method": ["error", {
+      ignoreStatic: true
+    }],
+    "@typescript-eslint/unified-signatures": "error",
+    "@typescript-eslint/non-nullable-type-assertion-style": "error",
+    "@typescript-eslint/prefer-enum-initializers": "error",
+    "@typescript-eslint/prefer-namespace-keyword": "error",
+    "@typescript-eslint/return-await": ["error", "always"],
+  },
+};

package/rules/typescript-core.js

@@ -0,0 +1,111 @@
+/**
+ * TypeScript Core Rules
+ *
+ * Grundlegende TypeScript-Regeln für alle Backend-Projekte
+ * Basierend auf den ursprünglichen Backend-Regeln
+ */
+
+export default {
+  rules: {
+    // Ursprüngliche Backend TypeScript-Regeln
+    "@typescript-eslint/prefer-readonly-parameter-types": "off",
+    "@typescript-eslint/no-magic-numbers": "off",
+    "@typescript-eslint/no-unused-vars": [
+      "error",
+      {
+        args: "all",
+        argsIgnorePattern: "^_",
+        caughtErrors: "all",
+        caughtErrorsIgnorePattern: "^_",
+        destructuredArrayIgnorePattern: "^_",
+        varsIgnorePattern: "^_",
+        ignoreRestSiblings: true,
+      },
+    ],
+    // TypeORM-Regeln nur im Backend aktivieren (siehe configs/backend.js)
+
+    "@typescript-eslint/naming-convention": [
+      "error",
+      {
+        selector: "default",
+        format: ["strictCamelCase"],
+      },
+      {
+        selector: ["class"],
+        format: ["StrictPascalCase"],
+      },
+      {
+        selector: ["enum", "interface", "typeAlias"],
+        format: ["StrictPascalCase"],
+      },
+      {
+        selector: ["enumMember"],
+        format: ["StrictPascalCase"],
+      },
+      {
+        selector: "parameter",
+        format: ["camelCase"],
+        leadingUnderscore: "allow",
+        trailingUnderscore: "allow",
+      },
+      {
+        selector: "typeParameter",
+        format: ["PascalCase"],
+        custom: {
+          regex: "^[A-Z]$",
+          match: true,
+        },
+      },
+      {
+        selector: "import",
+        format: null,
+      },
+      {
+        selector: "property",
+        filter: {
+          regex: "^(allowEIO3|allowEio3|addTrailingSlash|maxHttpBufferSize|perMessageDeflate|pingInterval|pingTimeout|connectTimeout|upgradeTimeout|httpCompression|timestampRequests|timestampParam|forceBase64|withCredentials|rememberUpgrade|randomizationFactor|reconnectionAttempts|reconnectionDelay|reconnectionDelayMax|autoConnect|forceNew)$",
+          match: true,
+        },
+        format: null,
+      },
+    ],
+    "@typescript-eslint/max-params": [
+      "error",
+      {
+        max: 10,
+      },
+    ],
+    "@typescript-eslint/no-misused-promises": [
+      "error",
+      {
+        checksVoidReturn: false,
+      },
+    ],
+    "@typescript-eslint/unbound-method": "off",
+    "@typescript-eslint/no-extraneous-class": "off",
+    "@typescript-eslint/no-redeclare": "off",
+    "@typescript-eslint/array-type": "error",
+    "@typescript-eslint/no-empty-function": "error",
+    "@typescript-eslint/no-empty-interface": "error",
+    "@typescript-eslint/no-inferrable-types": "error",
+    "@typescript-eslint/no-namespace": "error",
+    "@typescript-eslint/no-non-null-asserted-optional-chain": "error",
+    "@typescript-eslint/adjacent-overload-signatures": "error",
+    "@typescript-eslint/ban-ts-comment": "error",
+    "@typescript-eslint/ban-tslint-comment": "error",
+    "@typescript-eslint/explicit-module-boundary-types": "error",
+    "@typescript-eslint/explicit-member-accessibility": "off",
+    "@typescript-eslint/interface-name-prefix": "off",
+    "@typescript-eslint/no-explicit-any": "error",
+    "@typescript-eslint/no-non-null-assertion": "off",
+    "@typescript-eslint/object-literal-sort-keys": "off",
+    "@typescript-eslint/no-unsafe-call": "error",
+    "@typescript-eslint/no-unsafe-return": "error",
+    "@typescript-eslint/no-unsafe-assignment": "error",
+    "@typescript-eslint/no-unsafe-argument": "error",
+    "@typescript-eslint/no-unsafe-member-access": "error",
+    "@typescript-eslint/no-floating-promises": "error",
+    "@typescript-eslint/no-use-before-define": "error",
+    "@typescript-eslint/class-methods-use-this": "off",
+  },
+};

package/rules/typescript.js

@@ -0,0 +1,146 @@
+// TypeScript ESLint Rules
+export default {
+  rules: {
+    "@typescript-eslint/prefer-readonly-parameter-types": "off",
+    "@typescript-eslint/no-magic-numbers": "off",
+    "@typescript-eslint/no-unused-vars": [
+      "error",
+      {
+        args: "all",
+        argsIgnorePattern: "^_",
+        caughtErrors: "all",
+        caughtErrorsIgnorePattern: "^_",
+        destructuredArrayIgnorePattern: "^_",
+        varsIgnorePattern: "^_",
+        ignoreRestSiblings: true,
+      },
+    ],
+    "@typescript-eslint/naming-convention": [
+      "error",
+      {
+        selector: "default",
+        format: ["strictCamelCase"],
+      },
+      {
+        selector: "function",
+        format: ["StrictPascalCase"],
+        filter: {
+          regex: "^[A-Z][a-zA-Z0-9]*$",
+          match: true
+        },
+        modifiers: ["exported"]
+      },
+      {
+        selector: "classicAccessor",
+        format: ["strictCamelCase"],
+      },
+      {
+        selector: ["class"],
+        format: ["StrictPascalCase"],
+      },
+      {
+        selector: ["enum", "interface", "typeAlias"],
+        format: ["StrictPascalCase"],
+      },
+      {
+        selector: ["enumMember"],
+        format: ["StrictPascalCase"],
+      },
+      {
+        selector: "parameter",
+        format: ["camelCase"],
+        leadingUnderscore: "allow",
+        trailingUnderscore: "allow",
+      },
+      {
+        selector: "typeParameter",
+        format: ["PascalCase"],
+        custom: {
+          regex: "^T[A-Z][a-zA-Z]*$|^[A-Z]$",
+          match: true,
+        },
+      },
+      {
+        selector: "import",
+        format: null,
+      },
+      {
+        selector: "variable",
+        format: ["StrictPascalCase"],
+        filter: {
+          regex: "^((?!Props$)[A-Z][A-Za-z0-9]*)$",
+          match: true
+        }
+      },
+      {
+        selector: "variable",
+        format: ["StrictPascalCase"],
+        modifiers: ["const"],
+        types: ["function"],
+        filter: {
+          regex: "^[A-Z][A-Za-z]+$",
+          match: true,
+        },
+      },
+      {
+        selector: "variable",
+        format: ["strictCamelCase"],
+        modifiers: ["const"],
+        types: ["function"],
+        filter: {
+          regex: "^[A-Z][A-Za-z]+$",
+          match: false,
+        },
+      },
+      {
+        selector: "objectLiteralProperty",
+        format: ["strictCamelCase"],
+        filter: {
+          regex: "^(Mui|&|@|#|\\.).*",
+          match: false,
+        },
+      },
+    ],
+    "@typescript-eslint/max-params": [
+      "error",
+      {
+        max: 10,
+      },
+    ],
+    "@typescript-eslint/no-misused-promises": [
+      "error",
+      {
+        checksVoidReturn: false,
+      },
+    ],
+    "@typescript-eslint/unbound-method": "off",
+    "@typescript-eslint/no-extraneous-class": "off",
+    "@typescript-eslint/no-redeclare": "off",
+    "@typescript-eslint/array-type": "error",
+    "@typescript-eslint/no-empty-function": ["error", {
+      "allow": ["arrowFunctions", "functions", "methods"]
+    }],
+    "@typescript-eslint/no-empty-interface": "error",
+    "@typescript-eslint/no-inferrable-types": "off",
+    "@typescript-eslint/no-namespace": "error",
+    "@typescript-eslint/no-non-null-asserted-optional-chain": "error",
+    "@typescript-eslint/adjacent-overload-signatures": "error",
+    "@typescript-eslint/ban-ts-comment": "error",
+    "@typescript-eslint/ban-tslint-comment": "error",
+    "@typescript-eslint/explicit-module-boundary-types": "error",
+    "@typescript-eslint/explicit-member-accessibility": "off",
+    "@typescript-eslint/interface-name-prefix": "off",
+    "@typescript-eslint/no-explicit-any": "error",
+    "@typescript-eslint/no-non-null-assertion": "off",
+    "@typescript-eslint/object-literal-sort-keys": "off",
+    "@typescript-eslint/no-unsafe-call": "error",
+    "@typescript-eslint/no-unsafe-return": "error",
+    "@typescript-eslint/no-unsafe-assignment": "error",
+    "@typescript-eslint/no-unsafe-argument": "error",
+    "@typescript-eslint/no-unsafe-member-access": "error",
+    "@typescript-eslint/no-floating-promises": "error",
+    "@typescript-eslint/no-use-before-define": "error",
+    "@typescript-eslint/class-methods-use-this": "off",
+    "no-warning-comments": ["error", { terms: ["todo", "fixme", "xxx"], location: "anywhere" }],
+  },
+};