@oliveward-common/eslint-plugin-ddd 0.0.13

package/README.md

@@ -0,0 +1,33 @@
+# @oliveward-common/eslint-plugin-ddd
+
+ESLint plugin with DDD-focused rules for this repository style.
+
+## Install
+
+```bash
+npm install -D @oliveward-common/eslint-plugin-ddd eslint
+```
+
+## Rules
+
+- `ddd/no-external-entity-mutation`
+- `ddd/no-entity-manager-create-assign`
+
+## Usage (Flat Config)
+
+```js
+import dddPlugin from '@oliveward-common/eslint-plugin-ddd'
+
+export default [
+  {
+    files: ['**/*.{ts,tsx,mts,cts}'],
+    plugins: {
+      ddd: dddPlugin,
+    },
+    rules: {
+      'ddd/no-external-entity-mutation': 'error',
+      'ddd/no-entity-manager-create-assign': 'error',
+    },
+  },
+]
+```

package/index.js

@@ -0,0 +1,374 @@
+import ts from 'typescript'
+
+function getParserServices(context) {
+  const services = context.sourceCode.parserServices ?? context.parserServices
+  if (!services?.program || !services?.esTreeNodeToTSNodeMap) {
+    return null
+  }
+  return services
+}
+
+function getResolvedSymbol(symbol, checker) {
+  if (!symbol) {
+    return null
+  }
+  if ((symbol.flags & ts.SymbolFlags.Alias) !== 0) {
+    return checker.getAliasedSymbol(symbol)
+  }
+  return symbol
+}
+
+function getDecoratorCallee(decorator) {
+  if (ts.isCallExpression(decorator.expression)) {
+    return decorator.expression.expression
+  }
+  return decorator.expression
+}
+
+function symbolComesFromMikroOrm(symbol) {
+  const declarations = symbol?.getDeclarations?.() ?? []
+  return declarations.some((declaration) =>
+    declaration.getSourceFile().fileName.includes('@mikro-orm/'),
+  )
+}
+
+function isMikroEntityDecorator(decorator, checker) {
+  const callee = getDecoratorCallee(decorator)
+  const decoratorName =
+    ts.isIdentifier(callee) ? callee.text : ts.isPropertyAccessExpression(callee) ? callee.name.text : null
+
+  if (decoratorName !== 'Entity') {
+    return false
+  }
+
+  const symbol = getResolvedSymbol(checker.getSymbolAtLocation(callee), checker)
+  if (!symbol) {
+    return true
+  }
+
+  return symbolComesFromMikroOrm(symbol)
+}
+
+function isEntityClassDeclaration(classDeclaration, checker) {
+  const decorators = ts.canHaveDecorators(classDeclaration) ? ts.getDecorators(classDeclaration) ?? [] : []
+  return decorators.some((decorator) => isMikroEntityDecorator(decorator, checker))
+}
+
+function getEntityInfoFromSymbol(symbol, checker) {
+  const resolvedSymbol = getResolvedSymbol(symbol, checker)
+  if (!resolvedSymbol) {
+    return null
+  }
+
+  const declarations = resolvedSymbol.getDeclarations() ?? []
+  for (const declaration of declarations) {
+    if (ts.isClassDeclaration(declaration) && isEntityClassDeclaration(declaration, checker)) {
+      return {
+        symbol: resolvedSymbol,
+        declaration,
+      }
+    }
+  }
+
+  return null
+}
+
+function getBaseTypes(type, checker) {
+  if ((type.flags & ts.TypeFlags.Object) === 0) {
+    return []
+  }
+
+  const objectType = type
+  if ((objectType.objectFlags & ts.ObjectFlags.ClassOrInterface) === 0) {
+    return []
+  }
+
+  return checker.getBaseTypes(objectType) ?? []
+}
+
+function getEntityInfoFromType(type, checker, visited = new Set()) {
+  if (!type || visited.has(type)) {
+    return null
+  }
+
+  visited.add(type)
+
+  if (type.isUnion?.()) {
+    for (const unionType of type.types) {
+      const unionEntityInfo = getEntityInfoFromType(unionType, checker, visited)
+      if (unionEntityInfo) {
+        return unionEntityInfo
+      }
+    }
+  }
+
+  if (type.isIntersection?.()) {
+    for (const intersectionType of type.types) {
+      const intersectionEntityInfo = getEntityInfoFromType(intersectionType, checker, visited)
+      if (intersectionEntityInfo) {
+        return intersectionEntityInfo
+      }
+    }
+  }
+
+  const directEntityInfo = getEntityInfoFromSymbol(type.getSymbol?.(), checker)
+  if (directEntityInfo) {
+    return directEntityInfo
+  }
+
+  const aliasEntityInfo = getEntityInfoFromSymbol(type.aliasSymbol, checker)
+  if (aliasEntityInfo) {
+    return aliasEntityInfo
+  }
+
+  const baseTypes = getBaseTypes(type, checker)
+  for (const baseType of baseTypes) {
+    const baseEntityInfo = getEntityInfoFromType(baseType, checker, visited)
+    if (baseEntityInfo) {
+      return baseEntityInfo
+    }
+  }
+
+  return null
+}
+
+function unwrapEstreeExpression(node) {
+  if (!node) {
+    return node
+  }
+
+  if (node.type === 'TSAsExpression' || node.type === 'TSTypeAssertion' || node.type === 'TSNonNullExpression') {
+    return unwrapEstreeExpression(node.expression)
+  }
+
+  if (node.type === 'ChainExpression') {
+    return unwrapEstreeExpression(node.expression)
+  }
+
+  return node
+}
+
+function getTsNode(services, estreeNode) {
+  try {
+    return services.esTreeNodeToTSNodeMap.get(estreeNode)
+  } catch {
+    return null
+  }
+}
+
+function isInsideClass(tsNode, targetClassSymbol, checker) {
+  let current = tsNode
+  while (current) {
+    if (ts.isClassDeclaration(current) && current.name) {
+      const classSymbol = getResolvedSymbol(checker.getSymbolAtLocation(current.name), checker)
+      if (classSymbol === targetClassSymbol) {
+        return true
+      }
+    }
+
+    current = current.parent
+  }
+
+  return false
+}
+
+function getMemberName(memberExpression) {
+  if (!memberExpression.computed && memberExpression.property.type === 'Identifier') {
+    return memberExpression.property.name
+  }
+
+  if (memberExpression.computed && memberExpression.property.type === 'Literal') {
+    return typeof memberExpression.property.value === 'string' ? memberExpression.property.value : null
+  }
+
+  return null
+}
+
+function isLikelyEntityManagerReference(node) {
+  if (!node) {
+    return false
+  }
+
+  if (node.type === 'Identifier') {
+    return node.name === 'em'
+  }
+
+  if (node.type === 'MemberExpression') {
+    const memberName = getMemberName(node)
+    return memberName === 'em'
+  }
+
+  return false
+}
+
+function isMikroEntityManagerType(type, checker, visited = new Set()) {
+  if (!type || visited.has(type)) {
+    return false
+  }
+
+  visited.add(type)
+
+  if (type.isUnion?.()) {
+    return type.types.some((unionType) => isMikroEntityManagerType(unionType, checker, visited))
+  }
+
+  if (type.isIntersection?.()) {
+    return type.types.some((intersectionType) => isMikroEntityManagerType(intersectionType, checker, visited))
+  }
+
+  const resolvedSymbol = getResolvedSymbol(type.getSymbol?.(), checker)
+  if (resolvedSymbol) {
+    const name = resolvedSymbol.getName()
+    if (name.includes('EntityManager') && symbolComesFromMikroOrm(resolvedSymbol)) {
+      return true
+    }
+  }
+
+  const aliasSymbol = getResolvedSymbol(type.aliasSymbol, checker)
+  if (aliasSymbol) {
+    const aliasName = aliasSymbol.getName()
+    if (aliasName.includes('EntityManager') && symbolComesFromMikroOrm(aliasSymbol)) {
+      return true
+    }
+  }
+
+  const baseTypes = getBaseTypes(type, checker)
+  return baseTypes.some((baseType) => isMikroEntityManagerType(baseType, checker, visited))
+}
+
+const noExternalEntityMutationRule = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Disallow mutating properties of MikroORM @Entity instances outside entity class methods',
+    },
+    schema: [],
+    messages: {
+      noExternalMutation:
+        'Do not mutate {{entityName}} properties from outside the entity class. Add behavior/transition methods on the entity and call those methods instead.',
+    },
+  },
+  create(context) {
+    const services = getParserServices(context)
+    if (!services) {
+      return {}
+    }
+
+    const checker = services.program.getTypeChecker()
+
+    function reportIfExternalEntityMutation(memberExpressionNode, reportNode) {
+      const objectNode = unwrapEstreeExpression(memberExpressionNode.object)
+      const tsObjectNode = getTsNode(services, objectNode)
+      if (!tsObjectNode) {
+        return
+      }
+
+      const objectType = checker.getTypeAtLocation(tsObjectNode)
+      const entityInfo = getEntityInfoFromType(objectType, checker)
+      if (!entityInfo) {
+        return
+      }
+
+      const tsReportNode = getTsNode(services, reportNode)
+      if (!tsReportNode) {
+        return
+      }
+
+      if (isInsideClass(tsReportNode, entityInfo.symbol, checker)) {
+        return
+      }
+
+      context.report({
+        node: reportNode,
+        messageId: 'noExternalMutation',
+        data: {
+          entityName: entityInfo.symbol.getName(),
+        },
+      })
+    }
+
+    return {
+      AssignmentExpression(node) {
+        const leftNode = unwrapEstreeExpression(node.left)
+        if (!leftNode || leftNode.type !== 'MemberExpression') {
+          return
+        }
+
+        reportIfExternalEntityMutation(leftNode, node)
+      },
+      UpdateExpression(node) {
+        const argumentNode = unwrapEstreeExpression(node.argument)
+        if (!argumentNode || argumentNode.type !== 'MemberExpression') {
+          return
+        }
+
+        reportIfExternalEntityMutation(argumentNode, node)
+      },
+    }
+  },
+}
+
+const noEntityManagerCreateAssignRule = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Disallow EntityManager.create and EntityManager.assign',
+    },
+    schema: [],
+    messages: {
+      disallowedMethod:
+        'Do not call EntityManager.{{methodName}}. Construct entities via constructors, then persist with em.persist(...).',
+    },
+  },
+  create(context) {
+    const services = getParserServices(context)
+    const checker = services?.program.getTypeChecker()
+
+    return {
+      CallExpression(node) {
+        const calleeNode = unwrapEstreeExpression(node.callee)
+        if (!calleeNode || calleeNode.type !== 'MemberExpression') {
+          return
+        }
+
+        const methodName = getMemberName(calleeNode)
+        if (!methodName || (methodName !== 'create' && methodName !== 'assign')) {
+          return
+        }
+
+        const objectNode = unwrapEstreeExpression(calleeNode.object)
+
+        let shouldReport = isLikelyEntityManagerReference(objectNode)
+
+        if (!shouldReport && services && checker) {
+          const tsObjectNode = getTsNode(services, objectNode)
+          if (tsObjectNode) {
+            const objectType = checker.getTypeAtLocation(tsObjectNode)
+            shouldReport = isMikroEntityManagerType(objectType, checker)
+          }
+        }
+
+        if (!shouldReport) {
+          return
+        }
+
+        context.report({
+          node: calleeNode.property,
+          messageId: 'disallowedMethod',
+          data: {
+            methodName,
+          },
+        })
+      },
+    }
+  },
+}
+
+const dddPlugin = {
+  rules: {
+    'no-external-entity-mutation': noExternalEntityMutationRule,
+    'no-entity-manager-create-assign': noEntityManagerCreateAssignRule,
+  },
+}
+
+export default dddPlugin

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@oliveward-common/eslint-plugin-ddd",
+  "version": "0.0.13",
+  "private": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "main": "./index.js",
+  "exports": {
+    ".": "./index.js"
+  },
+  "files": [
+    "index.js",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "node -e \"process.exit(0)\""
+  },
+  "dependencies": {
+    "typescript": "^6.0.3"
+  },
+  "peerDependencies": {
+    "eslint": "^10.3.0"
+  }
+}