index.js

"use strict";
// eslint-disable-next-line functional/prefer-immutable-types
const config = {
    root: true,
    globals: {},
    env: {
        commonjs: true,
        es6: true,
        "jest/globals": true,
    },
    plugins: [
        "jest",
        "sonarjs",
        "functional",
        "@typescript-eslint",
        "prettier",
        "total-functions",
        "import",
        "prefer-arrow-functions",
        "simple-import-sort",
        "filename-rules",
        "jsdoc",
        "eslint-plugin-tsdoc",
        "no-secrets",
    ],
    parser: "@typescript-eslint/parser",
    parserOptions: {
        project: "./tsconfig.json",
        ecmaVersion: 2018,
        sourceType: "module",
    },
    extends: [
        "eslint:recommended",
        "plugin:@typescript-eslint/eslint-recommended",
        "plugin:@typescript-eslint/recommended",
        "plugin:@typescript-eslint/recommended-requiring-type-checking",
        "plugin:@typescript-eslint/strict",
        "plugin:total-functions/recommended",
        "typed-fp",
        "plugin:sonarjs/recommended",
        "plugin:jest/recommended",
        "plugin:prettier/recommended",
        "plugin:import/recommended",
        "plugin:import/typescript",
        "plugin:jsdoc/recommended-typescript",
    ],
    reportUnusedDisableDirectives: true,
    rules: {
        "no-template-curly-in-string": ["error"],
        // In all contexts, use a structured logger such as Pino instead.
        // In an fp context, use an appropriate IO type.
        "no-console": ["error"],
        // Encourage use of https://github.com/agiledigital-labs/pino-redact-pii
        "no-restricted-properties": [
            "error",
            {
                object: "JSON",
                property: "stringify",
                message: "Use a safe stringify alterative",
            },
            {
                object: "util",
                property: "inspect",
                message: "Use a safe stringify alterative",
            },
        ],
        "functional/no-expression-statements": [
            "error",
            {
                // Permit the following types of expressions to be used as statements (i.e. to have their results discarded)
                // * console.log() and friends
                // * React hooks (functions that start with `use`)
                ignoreCodePattern: "(console.)(?=log|info|warn|debug|error|trace)|^use[a-zA-Z]+",
                ignoreVoid: false,
            },
        ],
        curly: ["error"],
        eqeqeq: ["error", "always"],
        "no-plusplus": ["error", { allowForLoopAfterthoughts: true }],
        "no-alert": "error",
        "no-implicit-coercion": "error",
        "object-shorthand": "warn",
        "prefer-template": "warn",
        "@typescript-eslint/prefer-nullish-coalescing": "error",
        "@typescript-eslint/ban-ts-comment": [
            "error",
            {
                "ts-expect-error": "allow-with-description",
                "ts-ignore": true,
                "ts-nocheck": true,
                "ts-check": false,
                minimumDescriptionLength: 3,
            },
        ],
        "@typescript-eslint/no-unused-vars": [
            "error",
            {
                argsIgnorePattern: "^_",
                varsIgnorePattern: "^_",
                caughtErrorsIgnorePattern: "^_",
            },
        ],
        "@typescript-eslint/consistent-indexed-object-style": ["error", "record"],
        "@typescript-eslint/no-unused-expressions": [
            "error",
            {
                allowShortCircuit: true,
                allowTernary: true,
                enforceForJSX: true,
            },
        ],
        "@typescript-eslint/no-floating-promises": [
            "error",
            { ignoreVoid: true, ignoreIIFE: true },
        ],
        "@typescript-eslint/no-misused-promises": [
            "error",
            {
                checksVoidReturn: {
                    arguments: false,
                    attributes: false,
                },
            },
        ],
        "@typescript-eslint/no-unnecessary-type-arguments": "error",
        "@typescript-eslint/naming-convention": [
            "warn",
            {
                selector: "default",
                format: ["camelCase"],
                leadingUnderscore: "allow",
            },
            {
                selector: "variable",
                format: ["camelCase", "UPPER_CASE"],
                leadingUnderscore: "allow",
            },
            {
                selector: "parameter",
                format: ["camelCase"],
                leadingUnderscore: "allow",
            },
            {
                selector: "property",
                format: null,
                leadingUnderscore: "allow",
            },
            {
                selector: "typeLike",
                format: ["PascalCase"],
            },
        ],
        "@typescript-eslint/padding-line-between-statements": [
            "warn",
            {
                blankLine: "always",
                prev: "*",
                next: [
                    "function",
                    "interface",
                    "type",
                    "try",
                    "throw",
                    "case",
                    "default",
                ],
            },
        ],
        "import/no-extraneous-dependencies": [
            "error",
            // allow devDependencies to be imported into testing files, etc.
            { devDependencies: ["**/*.{test,spec,story,stories}.{ts,tsx}"] },
        ],
        "import/no-default-export": "error",
        "simple-import-sort/imports": "warn",
        "simple-import-sort/exports": "warn",
        "jsdoc/require-throws": "error",
        "jsdoc/check-indentation": "warn",
        "jsdoc/no-blank-blocks": "warn",
        "jsdoc/require-asterisk-prefix": "warn",
        "jsdoc/require-description": "warn",
        "jsdoc/sort-tags": "warn",
        "jsdoc/check-syntax": "warn",
        "jsdoc/tag-lines": ["warn", "never", { startLines: 1 }],
        "jsdoc/require-param": ["warn", { checkDestructuredRoots: false }],
        "jsdoc/require-jsdoc": [
            "warn",
            {
                publicOnly: true,
                require: {
                    FunctionDeclaration: true,
                    FunctionExpression: true,
                    ArrowFunctionExpression: true,
                    ClassDeclaration: true,
                    ClassExpression: true,
                    MethodDefinition: true,
                },
                contexts: [
                    "VariableDeclaration",
                    "TSTypeAliasDeclaration",
                    "TSMethodSignature",
                    "TSInterfaceDeclaration",
                    // Encourage documenting React prop types
                    "TSPropertySignature",
                ],
                enableFixer: true,
            },
        ],
        "jsdoc/check-tag-names": [
            "warn",
            { definedTags: ["remarks", "privateRemarks"] },
        ],
        // tsdoc checks this syntax instead
        "jsdoc/require-hyphen-before-param-description": "off",
        "jsdoc/require-returns": "off",
        "tsdoc/syntax": "warn",
        "prefer-arrow-functions/prefer-arrow-functions": [
            "warn",
            {
                classPropertiesAllowed: true,
                disallowPrototype: true,
                returnStyle: "unchanged",
            },
        ],
        "arrow-body-style": "warn",
        "prefer-arrow-callback": [
            "warn",
            {
                allowNamedFunctions: true,
            },
        ],
        "filename-rules/match": [2, { ".ts": "camelcase", ".tsx": "pascalcase" }],
        "no-secrets/no-secrets": [
            "error",
            { ignoreContent: "https", tolerance: 4.2 },
        ],
    },
    overrides: [
        {
            files: ["*.test.{ts,tsx}"],
            rules: {
                // We allow tests to interpret/execute effects
                "total-functions/no-premature-fp-ts-effects": "off",
                "functional/no-return-void": "off",
                "functional/functional-parameters": "off",
                "functional/no-expression-statements": "off",
                "functional/no-throw-statements": "off",
                "functional/no-conditional-statements": "off",
                "functional/prefer-immutable-types": [
                    "error",
                    { enforcement: "ReadonlyDeep" },
                ],
                "@typescript-eslint/no-floating-promises": "off",
            },
        },
        {
            files: ["*.tsx"],
            rules: {
                "functional/functional-parameters": [
                    "error",
                    {
                        enforceParameterCount: false,
                    },
                ],
                // This is a common pattern in React for hooks and callbacks.
                "functional/no-return-void": "off",
                "functional/prefer-immutable-types": [
                    "error",
                    {
                        ignoreTypePattern: ["JSX"],
                    },
                ],
                "@typescript-eslint/naming-convention": [
                    "warn",
                    {
                        selector: "default",
                        format: ["camelCase"],
                        leadingUnderscore: "allow",
                    },
                    {
                        selector: "variable",
                        // Need to allow PascalCase for React components
                        format: ["PascalCase", "camelCase", "UPPER_CASE"],
                        leadingUnderscore: "allow",
                    },
                    {
                        selector: "parameter",
                        format: ["camelCase"],
                        leadingUnderscore: "allow",
                    },
                    {
                        selector: "property",
                        format: null,
                        leadingUnderscore: "allow",
                    },
                    {
                        selector: "typeLike",
                        format: ["PascalCase"],
                    },
                ],
            },
        },
    ],
    settings: {
        immutability: {
            overrides: [
                // https://github.com/RebeccaStevens/is-immutable-type#default-overrides
                // Note: When providing custom overrides, the default ones will not be used.
                // Be sure to include the default overrides in your custom overrides if you
                // don't want to lose them. You can obtain them with getDefaultOverrides().
                {
                    type: { from: "lib", name: "Map" },
                    to: "Mutable",
                },
                {
                    type: { from: "lib", name: "Set" },
                    to: "Mutable",
                },
                {
                    type: { from: "lib", name: "Date" },
                    to: "Mutable",
                },
                {
                    type: { from: "lib", name: "URL" },
                    to: "Mutable",
                },
                {
                    type: { from: "lib", name: "URLSearchParams" },
                    to: "Mutable",
                },
                {
                    type: "ReadonlyArray",
                    to: "Immutable",
                    from: "ReadonlyDeep",
                },
                {
                    type: "ReadonlyArray",
                    to: "Immutable",
                    from: "ReadonlyDeep",
                },
                {
                    // From fp-ts
                    // export interface JsonArray extends ReadonlyArray<Json> {}
                    type: "JsonArray",
                    to: "Immutable",
                },
                {
                    // From fp-ts
                    // export declare type Json = boolean | number | string | null | JsonArray | JsonRecord
                    type: "Json",
                    to: "Immutable",
                },
                {
                    // From io-ts
                    // export interface Errors extends Array<ValidationError> {}
                    type: "Errors",
                    to: "Immutable",
                    from: "Mutable",
                },
                {
                    // From io-ts
                    // A readonly codec. Not the type of the value represented by the codec. The type of the codec itself.
                    // I.e., the result of calling `T.readonly(...)`.
                    type: "ReadonlyC",
                    to: "Immutable",
                    from: "Mutable",
                },
                {
                    // From https://github.com/agiledigital/readonly-types
                    // TODO work out why this is being detected wrong
                    type: "ReadonlyDate",
                    to: "Immutable",
                },
                {
                    // From fp-ts
                    type: "ReadonlyNonEmptyArray",
                    to: "Immutable",
                },
                {
                    // Sigh
                    type: "Promise",
                    to: "Immutable",
                    from: "ReadonlyDeep",
                },
            ],
        },
    },
};
module.exports = config;