@starci/eslint-canon-be 1.2.2 → 1.7.1

package/transport.mjs

@@ -1,168 +1,168 @@
-const normalize = (filename) => String(filename || "").replace(/\\/g, "/")
-
-/** The decorator's own name, whether it was written `@Controller` or `@Controller("x")`. */
-const decoratorName = (node) => {
-  const expression = node.expression
-  if (!expression) return null
-  if (expression.type === "Identifier") return expression.name
-  if (expression.type === "CallExpression" && expression.callee.type === "Identifier") {
-    return expression.callee.name
-  }
-  return null
-}
-
-/** The route string, or "" for `@Controller()` and for a path given as an object. */
-const routeOf = (node) => {
-  const expression = node.expression
-  if (!expression || expression.type !== "CallExpression") return ""
-  const first = expression.arguments[0]
-  if (first && first.type === "Literal" && typeof first.value === "string") return first.value
-  return ""
-}
-
-/**
- * Which of the four sanctioned reasons this file shows, if any.
- *
- * READ OFF THE FILE, NOT OFF A LIST. A registry of blessed routes rots the moment somebody adds a
- * route and forgets it; the evidence here is the same evidence a reader would use.
- */
-const reasonFor = (route, filename, text) => {
-  const path = normalize(filename)
-  // a probe answers when the app is degraded, before the feature layer is necessarily up
-  if (/^healthz?$/.test(route) || /\/health(z)?[./]/.test(path)) return "probe"
-  // something outside posts to a URL we gave it, and it will never send a GraphQL document
-  if (/webhook/i.test(route) || /webhook/i.test(path)) return "external"
-  // bytes, not fields: multipart in, stream out
-  if (/FileInterceptor|FilesInterceptor|AnyFilesInterceptor|StreamableFile|@Res\s*\(|createReadStream/.test(text)) {
-    return "bytes"
-  }
-  // a machine registering itself, with no user session to carry
-  if (/^(pods|internal|agents)\//.test(route)) return "machine"
-  // an identity that is not a user session - a platform operator or a service token
-  if (/^api\/ops(\/|$)/.test(route) || /Operator[A-Za-z]*Guard|ServiceToken|OPS_TOKEN/.test(text)) {
-    return "operator"
-  }
-  return null
-}
-
-/** A REST door exists only where GraphQL cannot go, and the file has to show which case it is. */
-export const restDoorNeedsAReason = {
-  meta: {
-    type: "problem",
-    docs: { description: "A @Controller is permitted only where GraphQL cannot serve." },
-    schema: [],
-    messages: {
-      unjustified:
-        "This REST door shows none of the four reasons a door may not be GraphQL: an external system posting to a fixed URL, a payload of bytes rather than fields, a machine with no user session, or an identity that is not one. A plain JSON read belongs in the GraphQL schema, where the client already is.",
-    },
-  },
-  create(context) {
-    const filename = context.filename || context.getFilename()
-    const text = (context.sourceCode || context.getSourceCode()).getText()
-    return {
-      Decorator(node) {
-        if (decoratorName(node) !== "Controller") return
-        if (reasonFor(routeOf(node), filename, text)) return
-        context.report({ node, messageId: "unjustified" })
-      },
-    }
-  },
-}
-
-/** A door is a door whatever its transport, and every door in this repository lives in features/. */
-export const doorLivesInFeatures = {
-  meta: {
-    type: "problem",
-    docs: { description: "HTTP doors sit under features/, beside the GraphQL ones." },
-    schema: [],
-    messages: {
-      wrongTree:
-        "A @Controller under src/modules/ is a door parked among the capabilities it calls, where it reads as one and gets imported like one. Every GraphQL door in this repository already lives under features/; transport was never what decided the address.",
-    },
-  },
-  create(context) {
-    const path = normalize(context.filename || context.getFilename())
-    if (!/\/src\/modules\//.test(path)) return {}
-    return {
-      Decorator(node) {
-        if (decoratorName(node) !== "Controller") return
-        context.report({ node, messageId: "wrongTree" })
-      },
-    }
-  },
-}
-
-/** An import specifier's alias prefix for a door. */
-const FEATURES_ALIAS = "@features/"
-
-/** A relative or deep specifier climbing into `features/`, once the alias form is ruled out. */
-const FEATURES_SEGMENT = /(^|\/)features\//
-
-/** Whether an import specifier reaches into `features/`, by alias or by path. */
-const reachesFeatures = (specifier) => {
-  if (typeof specifier !== "string") return false
-  if (specifier.startsWith(FEATURES_ALIAS)) return true
-  return FEATURES_SEGMENT.test(specifier)
-}
-
-/**
- * Rule 6: "A capability stays under `modules/` and is called by a door, never reached directly."
- * A door under `features/` importing a capability under `modules/` is the entire shape TRANSPORT-3
- * sets up, and this rule is not that edge - it fires only the other way: a file living under
- * `modules/` reaching back into `features/`. That reversal makes the capability the caller and the
- * door the thing being reached, which is backwards from what a capability is - it is CALLED, and it
- * stays ignorant of who calls it. One capability importing another capability under `modules/` is
- * untouched here; this rule polices one edge, not the whole graph.
- */
-export const noCapabilityImportsFeatures = {
-  meta: {
-    type: "problem",
-    docs: {
-      description:
-        "TRANSPORT Rule 6: a capability under modules/ never imports from features/ - a door calls into a capability, never the other way round.",
-    },
-    schema: [],
-    messages: {
-      reversed:
-        "`{{specifier}}` reaches from a capability under modules/ into features/, where doors live. A capability is CALLED by a door and stays ignorant of who calls it; importing back into features/ makes the capability the caller, which is the exact edge this law forbids. Move the shared code under modules/, or invert the call so the door reaches in.",
-    },
-  },
-  create(context) {
-    const path = normalize(context.filename || context.getFilename())
-    if (!/\/src\/modules\//.test(path)) return {}
-    const check = (node, specifier) => {
-      if (reachesFeatures(specifier)) context.report({ node, messageId: "reversed", data: { specifier } })
-    }
-    return {
-      ImportDeclaration(node) {
-        check(node.source, node.source.value)
-      },
-      ExportNamedDeclaration(node) {
-        if (node.source) check(node.source, node.source.value)
-      },
-      ExportAllDeclaration(node) {
-        if (node.source) check(node.source, node.source.value)
-      },
-    }
-  },
-}
-
-export const rules = {
-  "rest-door-needs-a-reason": restDoorNeedsAReason,
-  "door-lives-in-features": doorLivesInFeatures,
-  "no-capability-imports-features": noCapabilityImportsFeatures,
-}
-
-/**
- * `no-capability-imports-features` measures at 9 offenders across 6 files in the reference
- * repository (`src/**`, probed against source directly since the published package predates this
- * rule) -- every one a capability under `modules/bussiness/**` importing a single shared helper
- * published under `@features/api/processors/ai/shared/xp/write-coin-history`. That is standing debt,
- * not zero, so it ships at `warn` with the count on record, matching this module's own Exceptions
- * section: measured debt arrives at `warn` and flips to `error` once it reaches zero.
- */
-export const recommended = {
-  "starci-be/rest-door-needs-a-reason": "error",
-  "starci-be/door-lives-in-features": "error",
-  "starci-be/no-capability-imports-features": "warn",
-}
+const normalize = (filename) => String(filename || "").replace(/\\/g, "/")
+
+/** The decorator's own name, whether it was written `@Controller` or `@Controller("x")`. */
+const decoratorName = (node) => {
+  const expression = node.expression
+  if (!expression) return null
+  if (expression.type === "Identifier") return expression.name
+  if (expression.type === "CallExpression" && expression.callee.type === "Identifier") {
+    return expression.callee.name
+  }
+  return null
+}
+
+/** The route string, or "" for `@Controller()` and for a path given as an object. */
+const routeOf = (node) => {
+  const expression = node.expression
+  if (!expression || expression.type !== "CallExpression") return ""
+  const first = expression.arguments[0]
+  if (first && first.type === "Literal" && typeof first.value === "string") return first.value
+  return ""
+}
+
+/**
+ * Which of the four sanctioned reasons this file shows, if any.
+ *
+ * READ OFF THE FILE, NOT OFF A LIST. A registry of blessed routes rots the moment somebody adds a
+ * route and forgets it; the evidence here is the same evidence a reader would use.
+ */
+const reasonFor = (route, filename, text) => {
+  const path = normalize(filename)
+  // a probe answers when the app is degraded, before the feature layer is necessarily up
+  if (/^healthz?$/.test(route) || /\/health(z)?[./]/.test(path)) return "probe"
+  // something outside posts to a URL we gave it, and it will never send a GraphQL document
+  if (/webhook/i.test(route) || /webhook/i.test(path)) return "external"
+  // bytes, not fields: multipart in, stream out
+  if (/FileInterceptor|FilesInterceptor|AnyFilesInterceptor|StreamableFile|@Res\s*\(|createReadStream/.test(text)) {
+    return "bytes"
+  }
+  // a machine registering itself, with no user session to carry
+  if (/^(pods|internal|agents)\//.test(route)) return "machine"
+  // an identity that is not a user session - a platform operator or a service token
+  if (/^api\/ops(\/|$)/.test(route) || /Operator[A-Za-z]*Guard|ServiceToken|OPS_TOKEN/.test(text)) {
+    return "operator"
+  }
+  return null
+}
+
+/** A REST door exists only where GraphQL cannot go, and the file has to show which case it is. */
+export const restDoorNeedsAReason = {
+  meta: {
+    type: "problem",
+    docs: { description: "A @Controller is permitted only where GraphQL cannot serve." },
+    schema: [],
+    messages: {
+      unjustified:
+        "This REST door shows none of the four reasons a door may not be GraphQL: an external system posting to a fixed URL, a payload of bytes rather than fields, a machine with no user session, or an identity that is not one. A plain JSON read belongs in the GraphQL schema, where the client already is.",
+    },
+  },
+  create(context) {
+    const filename = context.filename || context.getFilename()
+    const text = (context.sourceCode || context.getSourceCode()).getText()
+    return {
+      Decorator(node) {
+        if (decoratorName(node) !== "Controller") return
+        if (reasonFor(routeOf(node), filename, text)) return
+        context.report({ node, messageId: "unjustified" })
+      },
+    }
+  },
+}
+
+/** A door is a door whatever its transport, and every door in this repository lives in features/. */
+export const doorLivesInFeatures = {
+  meta: {
+    type: "problem",
+    docs: { description: "HTTP doors sit under features/, beside the GraphQL ones." },
+    schema: [],
+    messages: {
+      wrongTree:
+        "A @Controller under src/modules/ is a door parked among the capabilities it calls, where it reads as one and gets imported like one. Every GraphQL door in this repository already lives under features/; transport was never what decided the address.",
+    },
+  },
+  create(context) {
+    const path = normalize(context.filename || context.getFilename())
+    if (!/\/src\/modules\//.test(path)) return {}
+    return {
+      Decorator(node) {
+        if (decoratorName(node) !== "Controller") return
+        context.report({ node, messageId: "wrongTree" })
+      },
+    }
+  },
+}
+
+/** An import specifier's alias prefix for a door. */
+const FEATURES_ALIAS = "@features/"
+
+/** A relative or deep specifier climbing into `features/`, once the alias form is ruled out. */
+const FEATURES_SEGMENT = /(^|\/)features\//
+
+/** Whether an import specifier reaches into `features/`, by alias or by path. */
+const reachesFeatures = (specifier) => {
+  if (typeof specifier !== "string") return false
+  if (specifier.startsWith(FEATURES_ALIAS)) return true
+  return FEATURES_SEGMENT.test(specifier)
+}
+
+/**
+ * Rule 6: "A capability stays under `modules/` and is called by a door, never reached directly."
+ * A door under `features/` importing a capability under `modules/` is the entire shape TRANSPORT-3
+ * sets up, and this rule is not that edge - it fires only the other way: a file living under
+ * `modules/` reaching back into `features/`. That reversal makes the capability the caller and the
+ * door the thing being reached, which is backwards from what a capability is - it is CALLED, and it
+ * stays ignorant of who calls it. One capability importing another capability under `modules/` is
+ * untouched here; this rule polices one edge, not the whole graph.
+ */
+export const noCapabilityImportsFeatures = {
+  meta: {
+    type: "problem",
+    docs: {
+      description:
+        "TRANSPORT Rule 6: a capability under modules/ never imports from features/ - a door calls into a capability, never the other way round.",
+    },
+    schema: [],
+    messages: {
+      reversed:
+        "`{{specifier}}` reaches from a capability under modules/ into features/, where doors live. A capability is CALLED by a door and stays ignorant of who calls it; importing back into features/ makes the capability the caller, which is the exact edge this law forbids. Move the shared code under modules/, or invert the call so the door reaches in.",
+    },
+  },
+  create(context) {
+    const path = normalize(context.filename || context.getFilename())
+    if (!/\/src\/modules\//.test(path)) return {}
+    const check = (node, specifier) => {
+      if (reachesFeatures(specifier)) context.report({ node, messageId: "reversed", data: { specifier } })
+    }
+    return {
+      ImportDeclaration(node) {
+        check(node.source, node.source.value)
+      },
+      ExportNamedDeclaration(node) {
+        if (node.source) check(node.source, node.source.value)
+      },
+      ExportAllDeclaration(node) {
+        if (node.source) check(node.source, node.source.value)
+      },
+    }
+  },
+}
+
+export const rules = {
+  "rest-door-needs-a-reason": restDoorNeedsAReason,
+  "door-lives-in-features": doorLivesInFeatures,
+  "no-capability-imports-features": noCapabilityImportsFeatures,
+}
+
+/**
+ * `no-capability-imports-features` measures at 9 offenders across 6 files in the reference
+ * repository (`src/**`, probed against source directly since the published package predates this
+ * rule) -- every one a capability under `modules/bussiness/**` importing a single shared helper
+ * published under `@features/api/processors/ai/shared/xp/write-coin-history`. That is standing debt,
+ * not zero, so it ships at `warn` with the count on record, matching this module's own Exceptions
+ * section: measured debt arrives at `warn` and flips to `error` once it reaches zero.
+ */
+export const recommended = {
+  "starci-be/rest-door-needs-a-reason": "error",
+  "starci-be/door-lives-in-features": "error",
+  "starci-be/no-capability-imports-features": "warn",
+}

package/type-safety.mjs

@@ -14,7 +14,7 @@
  * (TYPE-3, rule 4, extended; see the export below for its `recommended` level and the measurement
  * that set it), the const enum
  * (TYPE-4, rule 5), the unguarded cast off an `unknown` value (TYPE-1's second half, rule 2), and
- * the per-line suppression standing in for a lane (TYPE-6, rule 7). Each is a way of switching the
+ * a way of switching the
  * compiler off -- or of leaving it turned further down than the law asks -- that looks locally
  * reasonable, which is exactly the class a rule is for.
  *
@@ -28,7 +28,7 @@ import { normalizePath } from "./lib/path.mjs"
 /** The spec family and the test tree may build a deliberately wrong value on purpose. */
 const isTestFile = (filename) => {
   const file = normalizePath(filename)
-  return /\.(?:spec|test|e2e-spec|int-spec|harness-spec)\.ts$/.test(file) || file.includes("/src/tests/")
+  return /\.(?:spec|test|e2e-spec)\.ts$/.test(file) || file.includes("/src/tests/")
 }
 
 /** A parameter property (`private readonly x: T`) wraps the parameter it declares. */
@@ -387,77 +387,114 @@ export const noConstEnum = {
   },
 }
 
-// -- TYPE-5 (rule 6) -- ATTEMPTED, NOT SHIPPED ------------------------------------------------------
-//
-// A rule was written here: two-or-more `is`/`has`-prefixed booleans sharing a type literal with a
-// field that is optional and not itself boolean. It was measured against the reference backend
-// before shipping, per this canon's own standard -- and both of its two real firings were wrong.
-// `GlobalSearchItem` (`isEnrolled` / `isFree` / `isPremium` beside an unrelated optional
-// `parentPath`) and `AdvertisementSeedItem` (`isHouseAd` / `isActive` beside an unrelated optional
-// `ctaText`) are both genuinely independent facts about one entity, not a product of states -- the
-// exact "transport type" and "independent booleans" exceptions `type-safety.md` already names. A
-// rule reporting a defect on 2 of its 2 real firings is not a rule with debt to burn down; it is
-// wrong, and shipping it at any level would teach a reader to distrust the machine rather than the
-// code. TYPE-5 stays `documented`, exactly as the law's own `Layer held` table already says: seeing
-// past a transport DTO to whether its flags are truly one situation needs the meaning of the code,
-// which is a reader's job, not a decidable question of syntax.
+// -- R72 -------------------------------------------------------------------------------------------
+
+/** `as never` asserts that a value is of no type at all, which satisfies every parameter and checks nothing. */
+export const noNeverCast = {
+  meta: {
+    type: "problem",
+    docs: { description: "No `x as never` outside the test lanes." },
+    schema: [],
+    messages: {
+      neverCast:
+        "`as never` makes this value assignable to anything, so the compiler stops checking the call it is passed to. It hides a real mismatch between the value and the parameter. Give the value the type the parameter wants, narrow it with a guard, or fix the signature.",
+    },
+  },
+  create(context) {
+    if (isTestFile(context.filename || context.getFilename())) return {}
+    return {
+      TSAsExpression(node) {
+        if (node.typeAnnotation?.type === "TSNeverKeyword") context.report({ node, messageId: "neverCast" })
+      },
+    }
+  },
+}
+
+/** `x!` claims a value is present without checking. */
+export const noNonNullAssertion = {
+  meta: {
+    type: "problem",
+    docs: { description: "No non-null assertion (`x!`) outside the test lanes." },
+    schema: [],
+    messages: {
+      nonNull:
+        "`!` claims this value is present and checks nothing; when it is not, the failure is a `TypeError` far from here. Narrow with a check that returns or throws a typed error, or change the type so absence is impossible.",
+    },
+  },
+  create(context) {
+    if (isTestFile(context.filename || context.getFilename())) return {}
+    return {
+      TSNonNullExpression(node) {
+        context.report({ node, messageId: "nonNull" })
+      },
+    }
+  },
+}
 
-// -- TYPE-6 (rule 7) ----------------------------------------------------------------------------------
+// -- R75 -------------------------------------------------------------------------------------------
 
-/** This law's own published rule names -- the only ones this rule polices. */
-const TYPE_SAFETY_RULE_NAMES = [
-  "no-double-cast",
-  "no-inline-param-type",
-  "no-inline-object-type",
-  "no-const-enum",
-  "no-unguarded-unknown-cast",
-]
+const HANDLER_DECORATORS = new Set(["Query", "Mutation", "Subscription", "ResolveField", "Get", "Post", "Put", "Patch", "Delete", "MessagePattern", "EventPattern", "Cron", "Interval"])
+const SURFACE_CLASS_DECORATORS = new Set(["Injectable", "Resolver", "Controller"])
 
-const DISABLE_DIRECTIVE = /^eslint-disable(?:-next-line|-line)?\b/
+const decoratorIdentifier = (decorator) => {
+  const expression = decorator?.expression
+  if (!expression) return null
+  if (expression.type === "Identifier") return expression.name
+  if (expression.type === "CallExpression" && expression.callee.type === "Identifier") return expression.callee.name
+  return null
+}
 
-/**
- * A sanctioned exit is declared at the lane, once -- not suppressed per line.
- *
- * `no-double-cast`'s test-lane exemption already lives in `isTestFile`, consulted once, so every
- * place the exit is in force is derivable from that one function. A per-line `eslint-disable` for
- * any rule this law publishes is therefore never the lane speaking -- it is either redundant (the
- * lane already covers the file) or an undeclared second exit (the file needed one and reached for
- * a comment instead of a lane). Either way `type-safety.md` names this exact failure: "a per-line
- * suppression standing in for a lane-wide exit".
- *
- * Deliberately scoped to only the five rule names this law publishes -- a rule that policed every
- * `eslint-disable` in the repository would be reaching into every other family's lane, which is
- * outside this file's boundary.
- */
-export const noLineSuppression = {
+/** A method that a caller or the framework reaches states what it returns. */
+export const explicitHandlerReturnType = {
   meta: {
     type: "problem",
-    docs: {
-      description:
-        "No inline `eslint-disable` for a type-safety rule; the lane is the only sanctioned exit (TYPE-6, law 7).",
-    },
+    docs: { description: "Handlers and public methods of an Injectable, Resolver or Controller declare a return type." },
     schema: [],
     messages: {
-      suppression:
-        "This comment disables `starci-be/{{name}}` on one line. That rule's only sanctioned exit is declared once, at the lane, inside the rule itself -- a per-line suppression is never that declaration, it is a stand-in for one. Delete the comment; if the file genuinely needs the exemption, it belongs in the lane the rule already recognizes.",
+      handler:
+        "This handler declares no return type, so the transport contract is whatever the body happens to return today and a change of the body silently changes the wire. Declare the return type (`Promise<Type>`).",
+      publicMethod:
+        "This public method declares no return type, so its callers depend on an inferred shape that changes with the body. Declare the return type.",
     },
   },
   create(context) {
-    const sourceCode = context.sourceCode || context.getSourceCode()
+    if (isTestFile(context.filename || context.getFilename())) return {}
     return {
-      "Program:exit"(node) {
-        for (const comment of sourceCode.getAllComments()) {
-          const text = comment.value.trim()
-          if (!DISABLE_DIRECTIVE.test(text)) continue
-          const named = TYPE_SAFETY_RULE_NAMES.find((name) => text.includes(`starci-be/${name}`))
-          if (!named) continue
-          context.report({ node: comment ?? node, messageId: "suppression", data: { name: named } })
+      MethodDefinition(node) {
+        if (node.kind !== "method" || node.static || !node.value.body || node.value.returnType) return
+        if (node.computed || node.key.type !== "Identifier") return
+        const isHandler = (node.decorators ?? []).some((decorator) => HANDLER_DECORATORS.has(decoratorIdentifier(decorator)))
+        if (isHandler) {
+          context.report({ node: node.key, messageId: "handler" })
+          return
         }
+        if (node.accessibility === "private" || node.accessibility === "protected" || node.override) return
+        const klass = node.parent?.parent
+        if (!klass || klass.type !== "ClassDeclaration") return
+        const exported = klass.parent?.type === "ExportNamedDeclaration" || klass.parent?.type === "ExportDefaultDeclaration"
+        const decorators = [...(klass.decorators ?? []), ...(klass.parent?.decorators ?? [])].map(decoratorIdentifier)
+        if (!exported || !decorators.some((name) => SURFACE_CLASS_DECORATORS.has(name))) return
+        context.report({ node: node.key, messageId: "publicMethod" })
       },
     }
   },
 }
 
+// -- TYPE-5 (rule 6) -- ATTEMPTED, NOT SHIPPED ------------------------------------------------------
+//
+// A rule was written here: two-or-more `is`/`has`-prefixed booleans sharing a type literal with a
+// field that is optional and not itself boolean. It was measured against the reference backend
+// before shipping, per this canon's own standard -- and both of its two real firings were wrong.
+// `GlobalSearchItem` (`isEnrolled` / `isFree` / `isPremium` beside an unrelated optional
+// `parentPath`) and `AdvertisementSeedItem` (`isHouseAd` / `isActive` beside an unrelated optional
+// `ctaText`) are both genuinely independent facts about one entity, not a product of states -- the
+// exact "transport type" and "independent booleans" exceptions `type-safety.md` already names. A
+// rule reporting a defect on 2 of its 2 real firings is not a rule with debt to burn down; it is
+// wrong, and shipping it at any level would teach a reader to distrust the machine rather than the
+// code. TYPE-5 stays `documented`, exactly as the law's own `Layer held` table already says: seeing
+// past a transport DTO to whether its flags are truly one situation needs the meaning of the code,
+// which is a reader's job, not a decidable question of syntax.
+
 /** The rules this law contributes to the plugin. */
 export const rules = {
   "no-double-cast": noDoubleCast,
@@ -465,7 +502,9 @@ export const rules = {
   "no-inline-object-type": noInlineObjectType,
   "no-const-enum": noConstEnum,
   "no-unguarded-unknown-cast": noUnguardedUnknownCast,
-  "no-line-suppression": noLineSuppression,
+  "no-never-cast": noNeverCast,
+  "no-non-null-assertion": noNonNullAssertion,
+  "explicit-handler-return-type": explicitHandlerReturnType,
 }
 
 /**
@@ -501,7 +540,9 @@ export const recommended = {
   "starci-be/no-inline-object-type": "error",
   "starci-be/no-const-enum": "error",
   "starci-be/no-unguarded-unknown-cast": "warn", // no=3 -- see type-safety.mjs's doc comment
-  "starci-be/no-line-suppression": "error",
+  "starci-be/no-never-cast": "error",
+  "starci-be/no-non-null-assertion": "error",
+  "starci-be/explicit-handler-return-type": "error",
   "@typescript-eslint/no-explicit-any": "error",
   "@typescript-eslint/array-type": ["error", {
     default: "generic",