eslint-local-rules.js

'use strict'
const kennitala = require('kennitala')
const fakeNationalIdPrefixes = ['010130', /(\d+)\1{6,}/]

module.exports = {
  'disallow-kennitalas': {
    meta: {
      docs: {
        description: 'disallow kennitalas',
        category: 'Possible Errors',
        recommended: true,
      },
      schema: [],
    },
    create: function (context) {
      function checkKennitala(value, node) {
        if (
          kennitala.isValid(value) &&
          !fakeNationalIdPrefixes.some(
            (nID) => new String(value).search(nID) >= 0,
          )
        ) {
          context.report({
            node: node,
            message: `Found valid SSN: ${value}`,
          })
        }
      }
      return {
        Literal(node) {
          const { value } = node
          checkKennitala(value, node)
        },
        TemplateElement(node) {
          if (!node.value) return
          const value = node.value.cooked
          checkKennitala(value, node)
        },
      }
    },
  },
  'no-async-module-init': {
    meta: {
      type: 'problem',
      docs: {
        description: 'disallow async module initialisation',
        category: 'Possible Errors',
        recommended: true,
      },
      messages: {
        noAsyncRegister:
          'Disallowing static async {{ name }} function in modules to prevent unexpected startup failures or timeouts.',
        noAsyncProviderFactory:
          'Disallowing async useFactory in module providers to prevent unexpected startup failures or timeouts.',
        noReturnPromiseDynamicModule:
          'Disallowing static async functions with returnType Promise<DynamicModule> in modules to prevent unexpected startup failures or timeouts.',
      },
    },
    schema: [],
    create: function (context) {
      const nameSymbols = [
        'register',
        'forRoot',
        'forRootAsync',
        'forFeature',
        'forFeatureAsync',
      ]

      const rules = {
        ...nameSymbols.reduce((rules, name) => {
          return {
            ...rules,
            [`MethodDefinition[static=true][key.name='${name}'][value.async=true]`]: (
              node,
            ) => {
              context.report({
                node,
                messageId: 'noAsyncRegister',
                data: {
                  name,
                },
              })
            },
          }
        }, {}),
        "MethodDefinition[static=true] TSTypeReference[typeName.name='Promise'] TSTypeReference[typeName.name='DynamicModule']": (
          node,
        ) => {
          context.report({
            node,
            messageId: 'noReturnPromiseDynamicModule',
          })
        },
        "Property[key.name='useFactory'][value.async=true]": (node) => {
          context.report({
            node,
            messageId: 'noAsyncProviderFactory',
          })
        },
      }

      return rules
    },
  },
  /**
   * This rule is used to enforce the use of CacheField decorator or explicit cache control on all fields that resolve
   * to an object. Otherwise, these fields may disable caching for the whole response:
   *
   * https://www.apollographql.com/docs/apollo-server/performance/caching/#calculating-cache-behavior
   *
   * This is mainly relevant for the CMS domain, where we use persistent cached GET queries and Apollo response caching.
   *
   * Generally, each root resolver should specify a maxAge based on the frequency of updates to the underlying data.
   * Field resolvers which fetch data can configure their own maxAge. All other non-scalar fields should configure
   * `@CacheControl(inheritFromParent: true)`, which `@CacheField` does automatically.
   */
  'require-cache-control': {
    meta: {
      type: 'problem',
      hasSuggestions: true,
      docs: {
        description: 'require cache control for graphql field',
        category: 'Possible Errors',
        recommended: true,
      },
      messages: {
        noCacheControl:
          'Fields resolving as objects should configure cache control to not break caching-logic in Apollo.',
      },
    },
    schema: [],
    create: function (context) {
      const scalarTypes = [
        'ID',
        'String',
        'Boolean',
        'Int',
        'Float',
        'Number',
        'Date',
      ]
      let hasImport = false
      let lastImport = null
      return {
        ImportDeclaration: (node) => {
          lastImport = node
        },
        'ImportDeclaration ImportSpecifier[local.name=CacheField]': (node) => {
          hasImport = true
          lastImport = node
        },
        'PropertyDefinition > Decorator > CallExpression[callee.name=Field] > ArrowFunctionExpression.arguments:first-child > .body': (
          node,
        ) => {
          const identifierName =
            node.type === 'Identifier'
              ? node.name
              : node.type === 'ArrayExpression' &&
                node.elements[0].type === 'Identifier'
              ? node.elements[0].name
              : null

          const isScalarType =
            identifierName === null ||
            scalarTypes.includes(identifierName) ||
            identifierName.match(/json/i)
          const callExpressionNode = node.parent.parent
          const propertyNode = callExpressionNode.parent.parent
          const hasCacheControl = propertyNode.decorators.find(
            (decorator) =>
              decorator.expression?.callee?.name === 'CacheControl',
          )
          if (isScalarType || hasCacheControl) {
            return
          }

          context.report({
            node: callExpressionNode,
            messageId: 'noCacheControl',
            suggest: [
              {
                desc: 'Use @CacheField() instead.',
                fix: (fixer) => {
                  const fixes = [
                    fixer.replaceText(callExpressionNode.callee, 'CacheField'),
                  ]
                  if (!hasImport) {
                    const newImport =
                      "import { CacheField } from '@island.is/nest/graphql';"
                    if (lastImport) {
                      // insert after the last import decl
                      fixes.push(
                        fixer.insertTextAfter(lastImport, `\n${newImport}`),
                      )
                    } else {
                      // insert at the start of the file
                      fixes.push(
                        fixer.insertTextAfterRange([0, 0], `${newImport}\n`),
                      )
                    }
                  }
                  return fixes
                },
              },
            ],
          })
        },
      }
    },
  },
}