@living-architecture/riviere-extract-conventions-published-language 0.7.0

package/src/published-language/eslint-plugin/http-call-requires-route.cjs

@@ -0,0 +1,104 @@
+function findHttpCallDecoratorExpression(decorators) {
+  for (const decorator of decorators) {
+    const expression = decorator.expression
+    if (expression.type === 'Identifier' && expression.name === 'HttpCall') {
+      return expression
+    }
+    if (expression.type !== 'CallExpression') {
+      continue
+    }
+    if (expression.callee.type !== 'Identifier' || expression.callee.name !== 'HttpCall') {
+      continue
+    }
+    return expression
+  }
+  return null
+}
+
+function getRouteViolation(decoratorExpression) {
+  if (decoratorExpression.type === 'Identifier') {
+    return 'missingRoute'
+  }
+  if (decoratorExpression.arguments.length === 0) {
+    return 'missingRoute'
+  }
+
+  const firstArgument = decoratorExpression.arguments[0]
+  if (firstArgument.type !== 'Literal' || typeof firstArgument.value !== 'string') {
+    return 'routeNotLiteral'
+  }
+
+  if (firstArgument.value.trim().length === 0) {
+    return 'emptyRoute'
+  }
+
+  return null
+}
+
+function getMethodViolation(decoratorExpression) {
+  if (decoratorExpression.arguments.length < 2) {
+    return 'missingMethod'
+  }
+
+  const secondArgument = decoratorExpression.arguments[1]
+  if (secondArgument.type !== 'Literal' || typeof secondArgument.value !== 'string') {
+    return 'methodNotLiteral'
+  }
+
+  if (secondArgument.value.trim().length === 0) {
+    return 'emptyMethod'
+  }
+
+  return null
+}
+
+module.exports = {
+  meta: {
+    type: 'problem',
+    docs: { description: 'Require HttpCall decorator to include route and method' },
+    schema: [],
+    messages: {
+      missingRoute: "Method '{{methodName}}' uses @HttpCall but is missing route argument",
+      missingMethod: "Method '{{methodName}}' uses @HttpCall but is missing method argument",
+      routeNotLiteral: "Method '{{methodName}}' uses @HttpCall but route must be a string literal",
+      methodNotLiteral: "Method '{{methodName}}' uses @HttpCall but method must be a string literal",
+      emptyRoute: "Method '{{methodName}}' uses @HttpCall but route must be non-empty",
+      emptyMethod: "Method '{{methodName}}' uses @HttpCall but method must be non-empty",
+    },
+  },
+  create(context) {
+    return {
+      MethodDefinition(node) {
+        if (node.key.type !== 'Identifier' || !node.decorators) {
+          return
+        }
+
+        const decoratorExpression = findHttpCallDecoratorExpression(node.decorators)
+        if (!decoratorExpression) {
+          return
+        }
+
+        const violation = getRouteViolation(decoratorExpression)
+        if (!violation) {
+          const methodViolation = getMethodViolation(decoratorExpression)
+          if (!methodViolation) {
+            return
+          }
+
+          context.report({
+            node: node.key,
+            messageId: methodViolation,
+            data: { methodName: node.key.name },
+          })
+          return
+        }
+
+        context.report({
+          node: node.key,
+          messageId: violation,
+          data: { methodName: node.key.name },
+        })
+      },
+    }
+  },
+}

package/src/published-language/eslint-plugin/http-call-requires-route.d.cts

@@ -0,0 +1,5 @@
+import type { TSESLint } from '@typescript-eslint/utils'
+
+declare const rule: TSESLint.RuleModule<string, readonly unknown[]>
+
+export = rule

package/src/published-language/eslint-plugin/http-client-public-methods-require-http-call.cjs

@@ -0,0 +1,80 @@
+function hasDecoratorNamed(decorators, decoratorName) {
+  /* v8 ignore next 3 -- typescript-eslint provides an array for decorators on class and method nodes; undefined is structurally unreachable in current parser output */
+  if (!decorators) {
+    return false
+  }
+
+  return decorators.some((decorator) => {
+    const expression = decorator.expression
+    if (expression.type === 'Identifier') {
+      return expression.name === decoratorName
+    }
+    return (
+      expression.type === 'CallExpression' &&
+      expression.callee.type === 'Identifier' &&
+      expression.callee.name === decoratorName
+    )
+  })
+}
+
+function isPublicInstanceMethod(member) {
+  if (member.type !== 'MethodDefinition') {
+    return false
+  }
+  if (member.kind === 'constructor' || member.kind === 'get' || member.kind === 'set') {
+    return false
+  }
+  if (member.static) {
+    return false
+  }
+  if (member.accessibility === 'private' || member.accessibility === 'protected') {
+    return false
+  }
+  return member.key.type === 'Identifier'
+}
+
+module.exports = {
+  meta: {
+    type: 'problem',
+    docs: {description: 'Require public methods in HttpClient classes to have HttpCall decorator',},
+    schema: [],
+    messages: {
+      missingHttpCall:
+        "Public method '{{methodName}}' in @HttpClient class '{{className}}' must have @HttpCall",
+    },
+  },
+  create(context) {
+    return {
+      ClassDeclaration(node) {
+        if (hasDecoratorNamed(node.decorators, 'Ignore')) {
+          return
+        }
+
+        if (!node.id || !hasDecoratorNamed(node.decorators, 'HttpClient')) {
+          return
+        }
+
+        for (const member of node.body.body) {
+          if (hasDecoratorNamed(member.decorators, 'Ignore')) {
+            continue
+          }
+          if (!isPublicInstanceMethod(member)) {
+            continue
+          }
+          if (hasDecoratorNamed(member.decorators, 'HttpCall')) {
+            continue
+          }
+
+          context.report({
+            node: member.key,
+            messageId: 'missingHttpCall',
+            data: {
+              className: node.id.name,
+              methodName: member.key.name,
+            },
+          })
+        }
+      },
+    }
+  },
+}

package/src/published-language/eslint-plugin/http-client-public-methods-require-http-call.d.cts

@@ -0,0 +1,5 @@
+import type { TSESLint } from '@typescript-eslint/utils'
+
+declare const rule: TSESLint.RuleModule<string, readonly unknown[]>
+
+export = rule

package/src/published-language/eslint-plugin/http-client-requires-remote-name.cjs

@@ -0,0 +1,77 @@
+function findHttpClientDecoratorExpression(decorators) {
+  for (const decorator of decorators) {
+    const expression = decorator.expression
+    if (expression.type === 'Identifier' && expression.name === 'HttpClient') {
+      return expression
+    }
+    if (expression.type !== 'CallExpression') {
+      continue
+    }
+    if (expression.callee.type !== 'Identifier' || expression.callee.name !== 'HttpClient') {
+      continue
+    }
+    return expression
+  }
+  return null
+}
+
+function getServiceNameViolation(callExpression) {
+  if (callExpression.type === 'Identifier') {
+    return 'missingServiceName'
+  }
+
+  if (callExpression.arguments.length === 0) {
+    return 'missingServiceName'
+  }
+
+  const firstArgument = callExpression.arguments[0]
+  if (firstArgument.type !== 'Literal' || typeof firstArgument.value !== 'string') {
+    return 'serviceNameNotLiteral'
+  }
+
+  if (firstArgument.value.trim().length === 0) {
+    return 'emptyServiceName'
+  }
+
+  return null
+}
+
+module.exports = {
+  meta: {
+    type: 'problem',
+    docs: { description: 'Require HttpClient decorator to include service name' },
+    schema: [],
+    messages: {
+      missingServiceName:
+        "Class '{{className}}' uses @HttpClient but is missing service name argument",
+      serviceNameNotLiteral:
+        "Class '{{className}}' uses @HttpClient but service name must be a string literal",
+      emptyServiceName: "Class '{{className}}' uses @HttpClient but service name must be non-empty",
+    },
+  },
+  create(context) {
+    return {
+      ClassDeclaration(node) {
+        if (!node.id || !node.decorators) {
+          return
+        }
+
+        const decoratorCall = findHttpClientDecoratorExpression(node.decorators)
+        if (!decoratorCall) {
+          return
+        }
+
+        const violation = getServiceNameViolation(decoratorCall)
+        if (!violation) {
+          return
+        }
+
+        context.report({
+          node: node.id,
+          messageId: violation,
+          data: { className: node.id.name },
+        })
+      },
+    }
+  },
+}

package/src/published-language/eslint-plugin/http-client-requires-remote-name.d.cts

@@ -0,0 +1,5 @@
+import type { TSESLint } from '@typescript-eslint/utils'
+
+declare const rule: TSESLint.RuleModule<string, readonly unknown[]>
+
+export = rule

package/src/published-language/eslint-plugin/index.cjs

@@ -0,0 +1,64 @@
+const requireComponentDecorator = require('./require-component-decorator.cjs')
+const apiControllerRequiresRouteAndMethod = require('./api-controller-requires-route-and-method.cjs')
+const eventRequiresTypeProperty = require('./event-requires-type-property.cjs')
+const eventHandlerRequiresSubscribedEvents = require('./event-handler-requires-subscribed-events.cjs')
+const uiPageRequiresRoute = require('./ui-page-requires-route.cjs')
+const eventPublisherMethodSignature = require('./event-publisher-method-signature.cjs')
+const httpClientRequiresRemoteName = require('./http-client-requires-remote-name.cjs')
+const httpCallRequiresRoute = require('./http-call-requires-route.cjs')
+const httpCallRequiresHttpClientContainer = require('./http-call-requires-http-client-container.cjs')
+const httpClientPublicMethodsRequireHttpCall = require('./http-client-public-methods-require-http-call.cjs')
+const noFetchOutsideHttpClient = require('./no-fetch-outside-http-client.cjs')
+
+const restrictedHttpClientImports = [
+  'axios',
+  'got',
+  'node-fetch',
+  'undici',
+  'superagent',
+  'node:http',
+  'node:https',
+]
+
+function toRestrictedImportPath(packageName) {
+  return {
+    name: packageName,
+    message: `Do not import '${packageName}' directly. Use @HttpClient/@HttpCall conventions for HTTP boundary code.`,
+  }
+}
+
+function toRestrictedImportPattern(packageName) {
+  return {
+    group: [`${packageName}/*`],
+    message: `Do not import subpaths from '${packageName}'. Use @HttpClient/@HttpCall conventions for HTTP boundary code.`,
+  }
+}
+
+module.exports = {
+  rules: {
+    'require-component-decorator': requireComponentDecorator,
+    'api-controller-requires-route-and-method': apiControllerRequiresRouteAndMethod,
+    'event-requires-type-property': eventRequiresTypeProperty,
+    'event-handler-requires-subscribed-events': eventHandlerRequiresSubscribedEvents,
+    'ui-page-requires-route': uiPageRequiresRoute,
+    'event-publisher-method-signature': eventPublisherMethodSignature,
+    'http-client-requires-service-name': httpClientRequiresRemoteName,
+    'http-call-requires-route': httpCallRequiresRoute,
+    'http-call-requires-http-client-container': httpCallRequiresHttpClientContainer,
+    'http-client-public-methods-require-http-call': httpClientPublicMethodsRequireHttpCall,
+    'no-fetch-outside-http-client': noFetchOutsideHttpClient,
+  },
+  configs: {
+    'http-client-import-boundary': {
+      rules: {
+        'no-restricted-imports': [
+          'error',
+          {
+            paths: restrictedHttpClientImports.map(toRestrictedImportPath),
+            patterns: restrictedHttpClientImports.map(toRestrictedImportPattern),
+          },
+        ],
+      },
+    },
+  },
+}

package/src/published-language/eslint-plugin/index.d.ts

@@ -0,0 +1,57 @@
+import type { TSESLint } from '@typescript-eslint/utils'
+
+interface Plugin {
+  rules: {
+    'require-component-decorator': TSESLint.RuleModule<'missingDecorator'>
+    'api-controller-requires-route-and-method': TSESLint.RuleModule<
+      | 'missingRoute'
+      | 'missingMethod'
+      | 'routeNotLiteral'
+      | 'methodNotLiteral'
+      | 'invalidHttpMethod'
+    >
+    'event-requires-type-property': TSESLint.RuleModule<'missingType' | 'typeNotLiteral'>
+    'event-handler-requires-subscribed-events': TSESLint.RuleModule<
+      'missingSubscribedEvents' | 'subscribedEventsNotLiteralArray'
+    >
+    'ui-page-requires-route': TSESLint.RuleModule<'missingRoute' | 'routeNotLiteral'>
+    'event-publisher-method-signature': TSESLint.RuleModule<
+      | 'missingParameter'
+      | 'tooManyParameters'
+      | 'missingTypeAnnotation'
+      | 'notTypeReference'
+      | 'invalidEventType'
+      | 'nonPublicMethod'
+    >
+    'http-client-requires-service-name': TSESLint.RuleModule<
+      'missingServiceName' | 'serviceNameNotLiteral' | 'emptyServiceName'
+    >
+    'http-call-requires-route': TSESLint.RuleModule<
+      | 'missingRoute'
+      | 'missingMethod'
+      | 'routeNotLiteral'
+      | 'methodNotLiteral'
+      | 'emptyRoute'
+      | 'emptyMethod'
+    >
+    'http-call-requires-http-client-container': TSESLint.RuleModule<'missingHttpClientContainer'>
+    'http-client-public-methods-require-http-call': TSESLint.RuleModule<'missingHttpCall'>
+    'no-fetch-outside-http-client': TSESLint.RuleModule<'fetchOutsideHttpClient'>
+  }
+  configs: {
+    'http-client-import-boundary': {
+      rules: {
+        'no-restricted-imports': [
+          'error',
+          {
+            paths: Array<{ name: string; message: string }>
+            patterns: Array<{ group: string[]; message: string }>
+          },
+        ]
+      }
+    }
+  }
+}
+
+declare const plugin: Plugin
+export default plugin

package/src/published-language/eslint-plugin/interface-ast-predicates.cjs

@@ -0,0 +1,83 @@
+function hasDecorator(node, decoratorName) {
+  if (!node.decorators || node.decorators.length === 0) {
+    return false
+  }
+  return node.decorators.some(
+    (d) => d.expression.type === 'Identifier' && d.expression.name === decoratorName,
+  )
+}
+
+function findInstanceProperty(classNode, propertyName) {
+  /* v8 ignore next 3 -- ESLint guarantees ClassDeclaration.body exists per estree spec; structurally unreachable */
+  if (!classNode.body || !classNode.body.body) {
+    return null
+  }
+  return classNode.body.body.find((member) => {
+    return (
+      member.type === 'PropertyDefinition' &&
+      member.static !== true &&
+      member.key &&
+      member.key.type === 'Identifier' &&
+      member.key.name === propertyName
+    )
+  }) || null
+}
+
+function hasStringLiteralValue(property) {
+  /* v8 ignore next 3 -- callers (api-controller, ui-page rules) always guard with findInstanceProperty before calling; null property is structurally unreachable in current call sites */
+  if (!property || !property.value) {
+    return false
+  }
+  return property.value.type === 'Literal' && typeof property.value.value === 'string'
+}
+
+function hasStringLiteralArrayValue(property) {
+  /* v8 ignore next 3 -- callers always guard with findInstanceProperty before calling; null property is structurally unreachable in current call sites */
+  if (!property || !property.value) {
+    return false
+  }
+  if (property.value.type !== 'ArrayExpression') {
+    return false
+  }
+  return property.value.elements.every(
+    (element) => element && element.type === 'Literal' && typeof element.value === 'string'
+  )
+}
+
+function getLiteralValue(property) {
+  /* v8 ignore next 3 -- callers always guard with hasStringLiteralValue before calling; non-literal property is structurally unreachable in current call sites */
+  if (!property || !property.value || property.value.type !== 'Literal') {
+    return null
+  }
+  return property.value.value
+}
+
+function getValueTypeDescription(property) {
+  /* v8 ignore next 3 -- callers always guard with findInstanceProperty before calling; null property is structurally unreachable in current call sites */
+  if (!property || !property.value) {
+    return 'undefined'
+  }
+  const valueType = property.value.type
+  if (valueType === 'Identifier') {
+    return `variable reference '${property.value.name}'`
+  }
+  if (valueType === 'MemberExpression') {
+    return 'member expression (possibly an enum)'
+  }
+  if (valueType === 'CallExpression') {
+    return 'function call'
+  }
+  if (valueType === 'TemplateLiteral') {
+    return 'template literal'
+  }
+  return valueType
+}
+
+module.exports = {
+  hasDecorator,
+  findInstanceProperty,
+  hasStringLiteralValue,
+  hasStringLiteralArrayValue,
+  getLiteralValue,
+  getValueTypeDescription,
+}

package/src/published-language/eslint-plugin/no-fetch-outside-http-client.cjs

@@ -0,0 +1,60 @@
+function hasDecoratorNamed(decorators, decoratorName) {
+  /* v8 ignore next 3 -- typescript-eslint provides an array for decorators on class and method nodes; undefined is structurally unreachable in current parser output */
+  if (!decorators) {
+    return false
+  }
+  return decorators.some((decorator) => {
+    const expression = decorator.expression
+    if (expression.type === 'Identifier') {
+      return expression.name === decoratorName
+    }
+    return (
+      expression.type === 'CallExpression' &&
+      expression.callee.type === 'Identifier' &&
+      expression.callee.name === decoratorName
+    )
+  })
+}
+
+function getEnclosingClassDeclaration(sourceCode, node) {
+  const ancestors = sourceCode.getAncestors(node)
+  for (let index = ancestors.length - 1; index >= 0; index -= 1) {
+    const ancestor = ancestors[index]
+    if (ancestor.type === 'ClassDeclaration') {
+      return ancestor
+    }
+  }
+  return null
+}
+
+module.exports = {
+  meta: {
+    type: 'problem',
+    docs: { description: 'Disallow fetch usage outside HttpClient classes' },
+    schema: [],
+    messages: {
+      fetchOutsideHttpClient:
+        "Call to '{{calleeName}}' is only allowed inside classes decorated with @HttpClient",
+    },
+  },
+  create(context) {
+    return {
+      CallExpression(node) {
+        if (node.callee.type !== 'Identifier' || node.callee.name !== 'fetch') {
+          return
+        }
+
+        const enclosingClass = getEnclosingClassDeclaration(context.sourceCode, node)
+        if (enclosingClass && hasDecoratorNamed(enclosingClass.decorators, 'HttpClient')) {
+          return
+        }
+
+        context.report({
+          node,
+          messageId: 'fetchOutsideHttpClient',
+          data: { calleeName: 'fetch' },
+        })
+      },
+    }
+  },
+}

package/src/published-language/eslint-plugin/no-fetch-outside-http-client.d.cts

@@ -0,0 +1,5 @@
+import type { TSESLint } from '@typescript-eslint/utils'
+
+declare const rule: TSESLint.RuleModule<string, readonly unknown[]>
+
+export = rule

package/src/published-language/eslint-plugin/require-component-decorator.cjs

@@ -0,0 +1,56 @@
+const COMPONENT_DECORATORS = [
+  'DomainOpContainer',
+  'APIContainer',
+  'EventHandlerContainer',
+  'EventPublisherContainer',
+  'UseCase',
+  'Event',
+  'UI',
+  'Ignore',
+]
+
+const CALL_EXPRESSION_DECORATORS = ['Custom']
+
+function getDecoratorName(expression) {
+  if (expression.type === 'Identifier') {
+    return expression.name
+  }
+  if (expression.type === 'CallExpression' && expression.callee.type === 'Identifier') {
+    return expression.callee.name
+  }
+  return null
+}
+
+function hasComponentDecorator(decorators) {
+  return decorators.some((decorator) => {
+    const name = getDecoratorName(decorator.expression)
+    if (name === null) return false
+    return COMPONENT_DECORATORS.includes(name) || CALL_EXPRESSION_DECORATORS.includes(name)
+  })
+}
+
+module.exports = {
+  meta: {
+    type: 'problem',
+    docs: { description: 'Require classes to have a component decorator' },
+    schema: [],
+    messages: {
+      missingDecorator:
+        "Class '{{className}}' requires a component decorator. Add one of: @UseCase, @Event, @UI, @DomainOpContainer, @APIContainer, @EventHandlerContainer, @EventPublisherContainer, @Custom('type'), or @Ignore",
+    },
+  },
+  create(context) {
+    return {
+      ClassDeclaration(node) {
+        if (!node.id) return
+        if (hasComponentDecorator(node.decorators)) return
+
+        context.report({
+          node: node.id,
+          messageId: 'missingDecorator',
+          data: { className: node.id.name },
+        })
+      },
+    }
+  },
+}

package/src/published-language/eslint-plugin/require-component-decorator.d.cts

@@ -0,0 +1,4 @@
+import type { TSESLint } from '@typescript-eslint/utils'
+
+declare const rule: TSESLint.RuleModule<'missingDecorator'>
+export default rule

package/src/published-language/eslint-plugin/rule-module-declarations.d.ts

@@ -0,0 +1,59 @@
+type GenericRuleModule = import('@typescript-eslint/utils').TSESLint.RuleModule<
+  string,
+  readonly unknown[]
+>
+
+declare module './api-controller-requires-route-and-method.cjs' {
+  const rule: GenericRuleModule
+  export default rule
+}
+
+declare module './event-handler-requires-subscribed-events.cjs' {
+  const rule: GenericRuleModule
+  export default rule
+}
+
+declare module './event-publisher-method-signature.cjs' {
+  const rule: GenericRuleModule
+  export default rule
+}
+
+declare module './event-requires-type-property.cjs' {
+  const rule: GenericRuleModule
+  export default rule
+}
+
+declare module './http-call-requires-http-client-container.cjs' {
+  const rule: GenericRuleModule
+  export default rule
+}
+
+declare module './http-call-requires-route.cjs' {
+  const rule: GenericRuleModule
+  export default rule
+}
+
+declare module './http-client-public-methods-require-http-call.cjs' {
+  const rule: GenericRuleModule
+  export default rule
+}
+
+declare module './http-client-requires-remote-name.cjs' {
+  const rule: GenericRuleModule
+  export default rule
+}
+
+declare module './no-fetch-outside-http-client.cjs' {
+  const rule: GenericRuleModule
+  export default rule
+}
+
+declare module './require-component-decorator.cjs' {
+  const rule: GenericRuleModule
+  export default rule
+}
+
+declare module './ui-page-requires-route.cjs' {
+  const rule: GenericRuleModule
+  export default rule
+}