vouchington-tooling 0.6.2 → 0.7.0

package/ast-grep/rules/no-self-comparison-assertion.yml

@@ -0,0 +1,53 @@
+id: no-self-comparison-assertion
+language: TypeScript
+severity: error
+message: 'This compares an expression against itself (e.g. expect(result.id).toBe(result.id)). ast-grep metavariables enforce identical text, so both sides read the same value the same way; nearly every real occurrence of this shape is a copy-paste bug where the second operand should have been an independently derived expected value. Compare against that instead, or a fixture-provided value the code under test did not produce. (Two syntactic shapes are exempted because they cannot be tautological by construction: an expression containing a call anywhere in it, e.g. expect(f(a)).toBe(f(a)) or expect((await load()).id).toBe((await load()).id), is a fresh invocation on each side and legitimately tests that the call is deterministic/pure; and a postfix/prefix increment or decrement, e.g. expect(index++).toBe(index++), advances state between the two reads. A getter or other stateful property access is NOT exempted -- ast-grep cannot see whether a given `.foo` is a plain field or a getter with side effects, and every real violation this rule has caught in this repo is a plain field, so this stays flagged by design; if you are deliberately asserting that such an accessor is stable across two reads, add an `ast-grep-ignore: no-self-comparison-assertion` comment with that rationale instead of weakening this rule.)'
+files:
+  - '**/*.test.ts'
+  - '**/*.test.mts'
+  - '**/*.test.cts'
+  - '**/*.spec.ts'
+  - '**/*.spec.mts'
+  - '**/*.spec.cts'
+rule:
+  pattern: 'expect($X).toBe($X)'
+constraints:
+  X:
+    not:
+      any:
+        - kind: 'true'
+        - kind: 'false'
+        - kind: 'number'
+        - kind: 'string'
+        - kind: 'null'
+        - kind: 'undefined'
+        - kind: 'call_expression'
+        - kind: 'update_expression'
+        - has:
+            kind: 'call_expression'
+            stopBy: end
+examples:
+  - code: 'expect(result.id).toBe(result.id)'
+    isValid: false
+    file: 'backend/services/example/__tests__/items.test.mts'
+  - code: 'expect(conversationId).toBe(conversationId)'
+    isValid: false
+    file: 'src/__tests__/routes.user-admin.part-5.test.mts'
+  - code: 'expect(result.id).toBe(expectedId)'
+    isValid: true
+    file: 'backend/services/example/__tests__/items.test.mts'
+  - code: 'expect(await run()).not.toBeNull()'
+    isValid: true
+    file: 'src/__tests__/routes.user-admin.part-5.test.mts'
+  - code: 'expect(buildCanonicalRequestString(...args)).toBe(buildCanonicalRequestString(...args))'
+    isValid: true
+    file: 'backend/services/example/request-canonical.test.mts'
+  - code: 'expect((await load()).id).toBe((await load()).id)'
+    isValid: true
+    file: 'backend/services/example/__tests__/items.test.mts'
+  - code: 'expect(result.id).toBe(result.id)'
+    isValid: true
+    file: 'backend/services/example/items.mts'
+  - code: 'expect(index++).toBe(index++)'
+    isValid: true
+    file: 'backend/services/example/__tests__/items.test.mts'

package/ast-grep/rules/no-sql-offset.yml

@@ -0,0 +1,65 @@
+id: no-sql-offset
+language: TypeScript
+severity: error
+message: 'Do not use SQL OFFSET in backend sql templates; use cursor pagination, LIMIT + 1, COUNT, EXISTS, or ROW_NUMBER() instead'
+files:
+  - 'backend/**/*.ts'
+  - 'backend/**/*.mts'
+  - 'backend/**/*.cts'
+rule:
+  all:
+    - kind: template_string
+    # This repo's SQL templates parameterize with `${...}`; numeric literals catch raw
+    # examples and fixtures without flagging ordinary prose such as "offset by".
+    - regex: '(?i)\bOFFSET\s+(?:\$\{|[0-9])'
+    - inside:
+        kind: call_expression
+        stopBy: end
+        has:
+          kind: identifier
+          regex: '^sql$'
+          stopBy: neighbor
+examples:
+  - code: |-
+      import sql from 'sql-template-strings'
+      export const query = sql`
+        SELECT id FROM posts
+        ORDER BY id DESC
+        OFFSET ${limit}
+      `
+    isValid: false
+    file: 'backend/services/example/search.mts'
+  - code: |-
+      import sql from 'sql-template-strings'
+      export const query = sql`
+        SELECT id FROM posts
+        ORDER BY id DESC
+        OFFSET 10
+      `
+    isValid: false
+    file: 'backend/services/example/search.mts'
+  - code: |-
+      import sql from 'sql-template-strings'
+      export const query = sql`
+        SELECT id FROM posts
+        ORDER BY id DESC
+        LIMIT ${limit + 1}
+      `
+    isValid: true
+    file: 'backend/services/example/search.mts'
+  - code: |-
+      export function copyBuffer(chunks: Uint8Array[]) {
+        let offset = 0
+        for (const chunk of chunks) offset += chunk.byteLength
+        return offset
+      }
+    isValid: true
+    file: 'backend/services/example/domain-verification-well-known.mts'
+  - code: |-
+      import sql from 'sql-template-strings'
+      export const query = sql`
+        INSERT INTO examples (body)
+        VALUES ('offset by a travel credit')
+      `
+    isValid: true
+    file: 'backend/src/example.mts'

package/ast-grep/rules/no-sync-throw-assert-on-async-enqueue.yml

@@ -0,0 +1,42 @@
+id: no-sync-throw-assert-on-async-enqueue
+language: TypeScript
+severity: error
+message: 'Best-effort syntactic heuristic (not type-aware): this wraps a synchronous throw-assertion around a call that looks like a Promise-returning enqueue call. expect(() => fn()).not.toThrow() and .toThrow() only observe a synchronous throw and never see an async rejection, so this gives false confidence in the async contract. Await the call and assert on its resolved value instead, e.g. expect(await enqueueFoo()).toBeUndefined() or await expect(enqueueFoo()).resolves.toBeDefined().'
+files:
+  - 'backend/**/*.test.mts'
+rule:
+  # NOTE: member-call patterns MUST precede plain-call patterns in this list. ast-grep's `any:`
+  # does not backtrack across constraint failures: once an earlier arm structurally matches a node
+  # (even loosely, e.g. a bare-identifier pattern absorbing a qualified member-expression) and its
+  # constraint then fails, the match for that node is rejected outright rather than falling through
+  # to try a later, more specific arm. Listing the more specific member-call shape first avoids this.
+  any:
+    - pattern: 'expect(() => $OBJ.$CALL($$$ARGS)).not.toThrow()'
+    - pattern: 'expect(() => $OBJ.$CALL($$$ARGS)).toThrow()'
+    - pattern: 'expect(() => $CALL($$$ARGS)).not.toThrow()'
+    - pattern: 'expect(() => $CALL($$$ARGS)).toThrow()'
+constraints:
+  CALL:
+    all:
+      - regex: '^enqueue\w*$'
+      - not:
+          regex: 'BestEffort'
+examples:
+  - code: 'expect(() => enqueueBulkSourceSyncs([])).not.toThrow()'
+    isValid: false
+    file: 'backend/queues/example/enqueues.generated.test.mts'
+  - code: 'expect(() => queueModule.enqueueBulkSourceSyncs([])).not.toThrow()'
+    isValid: false
+    file: 'backend/queues/example/enqueues.test.mts'
+  - code: "expect(() => assertSafeUrlSync('http://example.com/path')).not.toThrow()"
+    isValid: true
+    file: 'backend/services/example/ssrf.test.mts'
+  - code: 'expect(await enqueueBulkSourceSyncs([])).toBeUndefined()'
+    isValid: true
+    file: 'backend/queues/example/enqueues.generated.test.mts'
+  - code: 'expect(() => enqueueBulkSourceSyncs([])).not.toThrow()'
+    isValid: true
+    file: 'backend/queues/example/enqueues.mts'
+  - code: "expect(() => enqueueReportResolutionNotificationsBestEffort([{ user_id: crypto.randomUUID(), id: crypto.randomUUID() }], () => { throw new Error('queue unavailable') })).not.toThrow()"
+    isValid: true
+    file: 'backend/services/example/__tests__/resolve.test.mts'

package/ast-grep/rules/no-tautological-literal-assertion-tsx.yml

@@ -0,0 +1,31 @@
+id: no-tautological-literal-assertion-tsx
+language: Tsx
+severity: error
+message: 'This asserts a literal against an identical literal (e.g. expect(true).toBe(true)), which can never fail and provides zero real coverage of the code under test. Assert on the actual value the code under test produced instead -- for example expect(await run()).not.toBeNull(), or a specific value or shape derived from calling the function being tested.'
+files:
+  - '**/*.test.tsx'
+  - '**/*.spec.tsx'
+rule:
+  pattern: 'expect($LIT).toBe($LIT)'
+constraints:
+  LIT:
+    any:
+      - kind: 'true'
+      - kind: 'false'
+      - kind: 'number'
+      - kind: 'string'
+      - kind: 'null'
+      - kind: 'undefined'
+examples:
+  - code: 'expect(true).toBe(true)'
+    isValid: false
+    file: 'web/components/example/__tests__/add-to-list-menu-item.mock.test.tsx'
+  - code: "expect('placeholder').toBe('placeholder')"
+    isValid: false
+    file: 'web/components/example/__tests__/source-list-item.interactions.mock.test.tsx'
+  - code: 'expect(screen.getByRole("button")).toBeInTheDocument()'
+    isValid: true
+    file: 'web/components/example/__tests__/add-to-list-menu-item.mock.test.tsx'
+  - code: 'expect(true).toBe(true)'
+    isValid: true
+    file: 'web/components/example/add-to-list-menu-item.tsx'

package/ast-grep/rules/no-tautological-literal-assertion.yml

@@ -0,0 +1,38 @@
+id: no-tautological-literal-assertion
+language: TypeScript
+severity: error
+message: 'This asserts a literal against an identical literal (e.g. expect(true).toBe(true)), which can never fail and provides zero real coverage of the code under test. Assert on the actual value the code under test produced instead -- for example expect(await run()).not.toBeNull(), or a specific value or shape derived from calling the function being tested.'
+files:
+  - '**/*.test.ts'
+  - '**/*.test.mts'
+  - '**/*.test.cts'
+  - '**/*.spec.ts'
+  - '**/*.spec.mts'
+  - '**/*.spec.cts'
+rule:
+  pattern: 'expect($LIT).toBe($LIT)'
+constraints:
+  LIT:
+    any:
+      - kind: 'true'
+      - kind: 'false'
+      - kind: 'number'
+      - kind: 'string'
+      - kind: 'null'
+      - kind: 'undefined'
+examples:
+  - code: 'expect(true).toBe(true)'
+    isValid: false
+    file: 'src/__tests__/client-content-routes.test.mts'
+  - code: "expect('placeholder').toBe('placeholder')"
+    isValid: false
+    file: 'backend/services/example/__tests__/items.test.mts'
+  - code: 'expect(await run()).not.toBeNull()'
+    isValid: true
+    file: 'src/__tests__/client-content-routes.test.mts'
+  - code: 'expect(page2.results.length).toBeLessThanOrEqual(2)'
+    isValid: true
+    file: 'backend/services/example/get-trending-posts.test.mts'
+  - code: 'expect(true).toBe(true)'
+    isValid: true
+    file: 'backend/services/example/get-trending-posts.mts'

package/ast-grep/rules/no-test-max-lines-disable-tsx.yml

@@ -0,0 +1,41 @@
+# NOTE: This rule flags eslint/oxlint disable directives that suppress max-lines
+# (or all rules) inside test files. Test files must stay within their line limit;
+# split the test or extract reusable helpers instead.
+# NOTE: ast-grep maps `.tsx` to language `Tsx`, not `TypeScript`. This rule
+# only scans `.tsx` files; see no-test-max-lines-disable.yml for the
+# companion rule that covers `.ts/.mts/.cts` files.
+id: no-test-max-lines-disable-tsx
+language: Tsx
+severity: error
+message: 'Test files must not disable max-lines or all lint rules; split the test or extract reusable helpers instead.'
+files:
+  - '**/*.test.tsx'
+  - '**/*.spec.tsx'
+  - '**/__tests__/**/*.tsx'
+rule:
+  kind: comment
+  any:
+    - regex: '^(?://|/\*)\s*(?:eslint|oxlint)-disable(?:-next-line|-line)?\s*(?:\*/\s*$|--|\s*$)'
+    - regex: '^(?://|/\*)\s*(?:eslint|oxlint)-disable(?:-next-line|-line)?(?:[^\n-]|-[^\n-])*(?:\s|,)(?:max-lines(?:[^-a-zA-Z0-9_]|$)|eslint/max-lines(?:[^-a-zA-Z0-9_]|$))'
+examples:
+  - code: '// oxlint-disable max-lines'
+    isValid: false
+    file: 'web/components/__tests__/foo.test.tsx'
+  - code: '// eslint-disable'
+    isValid: false
+    file: 'web/components/__tests__/foo.test.tsx'
+  - code: '// oxlint-disable vitest/expect-expect'
+    isValid: true
+    file: 'web/components/__tests__/foo.test.tsx'
+  - code: '// oxlint-disable no-console'
+    isValid: true
+    file: 'web/components/__tests__/foo.spec.tsx'
+  - code: '// eslint-disable max-lines-per-function'
+    isValid: true
+    file: 'web/components/__tests__/foo.test.tsx'
+  - code: '// eslint-disable eslint/max-lines-per-function'
+    isValid: true
+    file: 'web/components/__tests__/foo.test.tsx'
+  - code: '// oxlint-disable no-console -- split because of max-lines'
+    isValid: true
+    file: 'web/components/__tests__/foo.test.tsx'

package/ast-grep/rules/no-test-max-lines-disable.yml

@@ -0,0 +1,53 @@
+# NOTE: This rule flags eslint/oxlint disable directives that suppress max-lines
+# (or all rules) inside test files. Test files must stay within their line limit;
+# split the test or extract reusable helpers instead.
+# NOTE: ast-grep maps `.tsx` to language `Tsx`, not `TypeScript`. This rule
+# only scans `.ts/.mts/.cts` files; see no-test-max-lines-disable-tsx.yml for
+# the companion rule that covers `.tsx` files.
+id: no-test-max-lines-disable
+language: TypeScript
+severity: error
+message: 'Test files must not disable max-lines or all lint rules; split the test or extract reusable helpers instead.'
+files:
+  - '**/*.test.ts'
+  - '**/*.test.mts'
+  - '**/*.test.cts'
+  - '**/*.spec.ts'
+  - '**/*.spec.mts'
+  - '**/*.spec.cts'
+  - '**/__tests__/**/*.ts'
+  - '**/__tests__/**/*.mts'
+  - '**/__tests__/**/*.cts'
+rule:
+  kind: comment
+  any:
+    - regex: '^(?://|/\*)\s*(?:eslint|oxlint)-disable(?:-next-line|-line)?\s*(?:\*/\s*$|--|\s*$)'
+    - regex: '^(?://|/\*)\s*(?:eslint|oxlint)-disable(?:-next-line|-line)?(?:[^\n-]|-[^\n-])*(?:\s|,)(?:max-lines(?:[^-a-zA-Z0-9_]|$)|eslint/max-lines(?:[^-a-zA-Z0-9_]|$))'
+examples:
+  - code: '// oxlint-disable max-lines'
+    isValid: false
+    file: 'backend/services/users.test.ts'
+  - code: '// eslint-disable'
+    isValid: false
+    file: 'backend/services/users.test.mts'
+  - code: '// oxlint-disable-next-line max-lines'
+    isValid: false
+    file: 'backend/services/users.spec.ts'
+  - code: '/* eslint-disable eslint/max-lines */'
+    isValid: false
+    file: 'backend/__tests__/foo.ts'
+  - code: '// oxlint-disable vitest/expect-expect'
+    isValid: true
+    file: 'backend/services/users.test.ts'
+  - code: '// oxlint-disable no-console'
+    isValid: true
+    file: 'backend/services/users.test.mts'
+  - code: '// eslint-disable max-lines-per-function'
+    isValid: true
+    file: 'backend/services/users.test.ts'
+  - code: '// eslint-disable eslint/max-lines-per-function'
+    isValid: true
+    file: 'backend/services/users.test.ts'
+  - code: '// oxlint-disable no-console -- split because of max-lines'
+    isValid: true
+    file: 'backend/services/users.test.ts'

package/ast-grep/rules/no-three-sequential-awaits-tsx.yml

@@ -0,0 +1,288 @@
+id: no-three-sequential-awaits-tsx
+language: Tsx
+severity: error
+message: 'Avoid 3 sequential await statements; abstract dependent work or parallelize independent work with Promise.all().'
+files:
+  - '**/*.tsx'
+ignores:
+  - '**/*.test.tsx'
+  - '**/*.spec.tsx'
+  - '**/*.mock.test.tsx'
+  - '**/*.stories.tsx'
+  - 'web/test-helpers/**'
+rule:
+  all:
+    - not:
+        follows:
+          stopBy: neighbor
+          any:
+            - all:
+                - pattern:
+                    context: await $P
+                    selector: expression_statement
+                - not:
+                    pattern: await params
+                - not:
+                    pattern: await searchParams
+                - not:
+                    has:
+                      pattern: Promise.all($$)
+                - not:
+                    has:
+                      pattern: Promise.allSettled($$)
+            - all:
+                - pattern: const $W = await $P
+                - not:
+                    pattern: const $W = await params
+                - not:
+                    pattern: const $W = await searchParams
+                - not:
+                    pattern: const $W = await Promise.all($$$)
+                - not:
+                    pattern: const $W = await Promise.allSettled($$$)
+            - all:
+                - pattern: let $W = await $P
+                - not:
+                    pattern: let $W = await params
+                - not:
+                    pattern: let $W = await searchParams
+                - not:
+                    pattern: let $W = await Promise.all($$$)
+                - not:
+                    pattern: let $W = await Promise.allSettled($$$)
+            - all:
+                - pattern: var $W = await $P
+                - not:
+                    pattern: var $W = await params
+                - not:
+                    pattern: var $W = await searchParams
+                - not:
+                    pattern: var $W = await Promise.all($$$)
+                - not:
+                    pattern: var $W = await Promise.allSettled($$$)
+            - all:
+                - pattern:
+                    context: $W = await $P
+                    selector: expression_statement
+                - not:
+                    pattern: $W = await params
+                - not:
+                    pattern: $W = await searchParams
+                - not:
+                    pattern: $W = await Promise.all($$$)
+                - not:
+                    pattern: $W = await Promise.allSettled($$$)
+    - any:
+        - all:
+            - pattern:
+                context: await $A
+                selector: expression_statement
+            - not:
+                pattern: await params
+            - not:
+                pattern: await searchParams
+            - not:
+                has:
+                  pattern: Promise.all($$)
+            - not:
+                has:
+                  pattern: Promise.allSettled($$)
+        - all:
+            - pattern: const $X = await $A
+            - not:
+                pattern: const $X = await params
+            - not:
+                pattern: const $X = await searchParams
+            - not:
+                pattern: const $X = await Promise.all($$$)
+            - not:
+                pattern: const $X = await Promise.allSettled($$$)
+        - all:
+            - pattern: let $X = await $A
+            - not:
+                pattern: let $X = await params
+            - not:
+                pattern: let $X = await searchParams
+            - not:
+                pattern: let $X = await Promise.all($$$)
+            - not:
+                pattern: let $X = await Promise.allSettled($$$)
+        - all:
+            - pattern: var $X = await $A
+            - not:
+                pattern: var $X = await params
+            - not:
+                pattern: var $X = await searchParams
+            - not:
+                pattern: var $X = await Promise.all($$$)
+            - not:
+                pattern: var $X = await Promise.allSettled($$$)
+        - all:
+            - pattern:
+                context: $X = await $A
+                selector: expression_statement
+            - not:
+                pattern: $X = await params
+            - not:
+                pattern: $X = await searchParams
+            - not:
+                pattern: $X = await Promise.all($$$)
+            - not:
+                pattern: $X = await Promise.allSettled($$$)
+    - precedes:
+        stopBy: neighbor
+        all:
+          - any:
+              - all:
+                  - pattern:
+                      context: await $B
+                      selector: expression_statement
+                  - not:
+                      pattern: await params
+                  - not:
+                      pattern: await searchParams
+                  - not:
+                      has:
+                        pattern: Promise.all($$)
+                  - not:
+                      has:
+                        pattern: Promise.allSettled($$)
+              - all:
+                  - pattern: const $Y = await $B
+                  - not:
+                      pattern: const $Y = await params
+                  - not:
+                      pattern: const $Y = await searchParams
+                  - not:
+                      pattern: const $Y = await Promise.all($$$)
+                  - not:
+                      pattern: const $Y = await Promise.allSettled($$$)
+              - all:
+                  - pattern: let $Y = await $B
+                  - not:
+                      pattern: let $Y = await params
+                  - not:
+                      pattern: let $Y = await searchParams
+                  - not:
+                      pattern: let $Y = await Promise.all($$$)
+                  - not:
+                      pattern: let $Y = await Promise.allSettled($$$)
+              - all:
+                  - pattern: var $Y = await $B
+                  - not:
+                      pattern: var $Y = await params
+                  - not:
+                      pattern: var $Y = await searchParams
+                  - not:
+                      pattern: var $Y = await Promise.all($$$)
+                  - not:
+                      pattern: var $Y = await Promise.allSettled($$$)
+              - all:
+                  - pattern:
+                      context: $Y = await $B
+                      selector: expression_statement
+                  - not:
+                      pattern: $Y = await params
+                  - not:
+                      pattern: $Y = await searchParams
+                  - not:
+                      pattern: $Y = await Promise.all($$$)
+                  - not:
+                      pattern: $Y = await Promise.allSettled($$$)
+          - precedes:
+              stopBy: neighbor
+              any:
+                - all:
+                    - pattern:
+                        context: await $C
+                        selector: expression_statement
+                    - not:
+                        pattern: await params
+                    - not:
+                        pattern: await searchParams
+                    - not:
+                        has:
+                          pattern: Promise.all($$)
+                    - not:
+                        has:
+                          pattern: Promise.allSettled($$)
+                - all:
+                    - pattern: const $Z = await $C
+                    - not:
+                        pattern: const $Z = await params
+                    - not:
+                        pattern: const $Z = await searchParams
+                    - not:
+                        pattern: const $Z = await Promise.all($$$)
+                    - not:
+                        pattern: const $Z = await Promise.allSettled($$$)
+                - all:
+                    - pattern: let $Z = await $C
+                    - not:
+                        pattern: let $Z = await params
+                    - not:
+                        pattern: let $Z = await searchParams
+                    - not:
+                        pattern: let $Z = await Promise.all($$$)
+                    - not:
+                        pattern: let $Z = await Promise.allSettled($$$)
+                - all:
+                    - pattern: var $Z = await $C
+                    - not:
+                        pattern: var $Z = await params
+                    - not:
+                        pattern: var $Z = await searchParams
+                    - not:
+                        pattern: var $Z = await Promise.all($$$)
+                    - not:
+                        pattern: var $Z = await Promise.allSettled($$$)
+                - all:
+                    - pattern:
+                        context: $Z = await $C
+                        selector: expression_statement
+                    - not:
+                        pattern: $Z = await params
+                    - not:
+                        pattern: $Z = await searchParams
+                    - not:
+                        pattern: $Z = await Promise.all($$$)
+                    - not:
+                        pattern: $Z = await Promise.allSettled($$$)
+constraints:
+  A:
+    not:
+      regex: '^Promise\.all(Settled)?\b'
+  B:
+    not:
+      regex: '^Promise\.all(Settled)?\b'
+  C:
+    not:
+      regex: '^Promise\.all(Settled)?\b'
+  P:
+    not:
+      regex: '^Promise\.all(Settled)?\b'
+examples:
+  - code: |
+      async function run() {
+        await one()
+        await two()
+        await three()
+      }
+    isValid: false
+    file: 'web/app/example.tsx'
+  - code: |
+      async function run() {
+        const { id } = await params
+        const topic = await getTopic(id)
+        const aliases = await getAliases(id)
+        return <div>{topic.name}{aliases.length}</div>
+      }
+    isValid: true
+    file: 'web/app/example.tsx'
+  - code: |
+      async function run() {
+        await Promise.all([one(), two(), three()])
+        return <div />
+      }
+    isValid: true
+    file: 'web/app/example.tsx'