@shivaedev/quality 0.57.1 → 0.59.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/CHANGELOG.md +34 -0
- package/README.md +19 -6
- package/dist/adapters/ImportAnalysisFailure.d.ts +10 -0
- package/dist/adapters/ImportAnalysisFailure.d.ts.map +1 -0
- package/dist/adapters/ImportAnalysisFailure.js +4 -0
- package/dist/adapters/ImportAnalysisFailure.js.map +1 -0
- package/dist/adapters/ImportCompiler.d.ts +2 -13
- package/dist/adapters/ImportCompiler.d.ts.map +1 -1
- package/dist/adapters/ImportCompiler.js +7 -13
- package/dist/adapters/ImportCompiler.js.map +1 -1
- package/dist/adapters/bodyReferences.d.ts +10 -0
- package/dist/adapters/bodyReferences.d.ts.map +1 -0
- package/dist/adapters/bodyReferences.js +125 -0
- package/dist/adapters/bodyReferences.js.map +1 -0
- package/dist/adapters/engineEscapes.d.ts +10 -0
- package/dist/adapters/engineEscapes.d.ts.map +1 -0
- package/dist/adapters/engineEscapes.js +103 -0
- package/dist/adapters/engineEscapes.js.map +1 -0
- package/dist/adapters/imports/analysisFailure.d.ts +3 -0
- package/dist/adapters/imports/analysisFailure.d.ts.map +1 -0
- package/dist/adapters/imports/analysisFailure.js +5 -0
- package/dist/adapters/imports/analysisFailure.js.map +1 -0
- package/dist/adapters/imports/analyzeDepartures.d.ts +5 -0
- package/dist/adapters/imports/analyzeDepartures.d.ts.map +1 -0
- package/dist/adapters/imports/analyzeDepartures.js +5 -0
- package/dist/adapters/imports/analyzeDepartures.js.map +1 -0
- package/dist/adapters/imports/analyzeGraph.d.ts +4 -0
- package/dist/adapters/imports/analyzeGraph.d.ts.map +1 -0
- package/dist/adapters/imports/analyzeGraph.js +6 -0
- package/dist/adapters/imports/analyzeGraph.js.map +1 -0
- package/dist/adapters/imports/checkBrowser.d.ts +4 -0
- package/dist/adapters/imports/checkBrowser.d.ts.map +1 -0
- package/dist/adapters/imports/checkBrowser.js +4 -0
- package/dist/adapters/imports/checkBrowser.js.map +1 -0
- package/dist/adapters/indirectServiceReferences.d.ts +3 -0
- package/dist/adapters/indirectServiceReferences.d.ts.map +1 -0
- package/dist/adapters/indirectServiceReferences.js +19 -0
- package/dist/adapters/indirectServiceReferences.js.map +1 -0
- package/dist/adapters/knip/entryPointFindings.d.ts +1 -1
- package/dist/adapters/knip/entryPointFindings.d.ts.map +1 -1
- package/dist/adapters/nativeTransactionFindings.d.ts +4 -0
- package/dist/adapters/nativeTransactionFindings.d.ts.map +1 -0
- package/dist/adapters/nativeTransactionFindings.js +98 -0
- package/dist/adapters/nativeTransactionFindings.js.map +1 -0
- package/dist/adapters/outcomeAssertions.d.ts +9 -0
- package/dist/adapters/outcomeAssertions.d.ts.map +1 -0
- package/dist/adapters/outcomeAssertions.js +94 -0
- package/dist/adapters/outcomeAssertions.js.map +1 -0
- package/dist/adapters/outsideImportFindings.d.ts +1 -1
- package/dist/adapters/outsideImportFindings.d.ts.map +1 -1
- package/dist/adapters/positiveRefusalFindings.d.ts +4 -0
- package/dist/adapters/positiveRefusalFindings.d.ts.map +1 -0
- package/dist/adapters/positiveRefusalFindings.js +41 -0
- package/dist/adapters/positiveRefusalFindings.js.map +1 -0
- package/dist/adapters/queueReadoutFindings.d.ts +1 -1
- package/dist/adapters/queueReadoutFindings.d.ts.map +1 -1
- package/dist/adapters/rpcBoundaryFindings.d.ts +4 -0
- package/dist/adapters/rpcBoundaryFindings.d.ts.map +1 -0
- package/dist/adapters/rpcBoundaryFindings.js +90 -0
- package/dist/adapters/rpcBoundaryFindings.js.map +1 -0
- package/dist/adapters/serviceAccess.d.ts +4 -0
- package/dist/adapters/serviceAccess.d.ts.map +1 -0
- package/dist/adapters/serviceAccess.js +33 -0
- package/dist/adapters/serviceAccess.js.map +1 -0
- package/dist/adapters/serviceAssemblyImports.d.ts +10 -0
- package/dist/adapters/serviceAssemblyImports.d.ts.map +1 -0
- package/dist/adapters/serviceAssemblyImports.js +71 -0
- package/dist/adapters/serviceAssemblyImports.js.map +1 -0
- package/dist/adapters/serviceAssemblySyntax.d.ts +10 -0
- package/dist/adapters/serviceAssemblySyntax.d.ts.map +1 -0
- package/dist/adapters/serviceAssemblySyntax.js +105 -0
- package/dist/adapters/serviceAssemblySyntax.js.map +1 -0
- package/dist/adapters/serviceDefinitionProblems.d.ts +7 -0
- package/dist/adapters/serviceDefinitionProblems.d.ts.map +1 -0
- package/dist/adapters/serviceDefinitionProblems.js +43 -0
- package/dist/adapters/serviceDefinitionProblems.js.map +1 -0
- package/dist/adapters/serviceIdFindings.d.ts.map +1 -1
- package/dist/adapters/serviceIdFindings.js +12 -7
- package/dist/adapters/serviceIdFindings.js.map +1 -1
- package/dist/adapters/transactionChanges.d.ts +3 -0
- package/dist/adapters/transactionChanges.d.ts.map +1 -0
- package/dist/adapters/transactionChanges.js +81 -0
- package/dist/adapters/transactionChanges.js.map +1 -0
- package/dist/adapters/vitePort.d.ts +2 -0
- package/dist/adapters/vitePort.d.ts.map +1 -0
- package/dist/adapters/vitePort.js +5 -0
- package/dist/adapters/vitePort.js.map +1 -0
- package/dist/appViteConfig.d.ts +4 -1
- package/dist/appViteConfig.d.ts.map +1 -1
- package/dist/appViteConfig.js +7 -3
- package/dist/appViteConfig.js.map +1 -1
- package/dist/imports/departures.d.ts +1 -1
- package/dist/imports/departures.d.ts.map +1 -1
- package/dist/imports/fences/check.d.ts +1 -1
- package/dist/imports/fences/check.d.ts.map +1 -1
- package/dist/imports/graph.d.ts +1 -1
- package/dist/imports/graph.d.ts.map +1 -1
- package/dist/rules/builtIn.d.ts +2 -2
- package/dist/rules/builtIn.d.ts.map +1 -1
- package/dist/rules/builtIn.js +8 -0
- package/dist/rules/builtIn.js.map +1 -1
- package/dist/rules/effect/rpcBoundary.d.ts +2 -0
- package/dist/rules/effect/rpcBoundary.d.ts.map +1 -0
- package/dist/rules/effect/rpcBoundary.js +9 -0
- package/dist/rules/effect/rpcBoundary.js.map +1 -0
- package/dist/rules/effect/serviceCatalog.d.ts +1 -1
- package/dist/rules/effect/serviceCatalog.d.ts.map +1 -1
- package/dist/rules/effect/serviceCatalog.js +4 -2
- package/dist/rules/effect/serviceCatalog.js.map +1 -1
- package/dist/rules/effect/serviceDefinitionAssembly.d.ts +2 -0
- package/dist/rules/effect/serviceDefinitionAssembly.d.ts.map +1 -0
- package/dist/rules/effect/serviceDefinitionAssembly.js +43 -0
- package/dist/rules/effect/serviceDefinitionAssembly.js.map +1 -0
- package/dist/rules/effect/serviceIds.js +1 -1
- package/dist/rules/effect/serviceIds.js.map +1 -1
- package/dist/rules/effect/serviceParameters.d.ts.map +1 -1
- package/dist/rules/effect/serviceParameters.js +12 -6
- package/dist/rules/effect/serviceParameters.js.map +1 -1
- package/dist/rules/effect/sqlTransact.d.ts +2 -0
- package/dist/rules/effect/sqlTransact.d.ts.map +1 -0
- package/dist/rules/effect/sqlTransact.js +9 -0
- package/dist/rules/effect/sqlTransact.js.map +1 -0
- package/dist/rules/stories/engine.d.ts.map +1 -1
- package/dist/rules/stories/engine.js +24 -7
- package/dist/rules/stories/engine.js.map +1 -1
- package/dist/rules/stories/positiveRefusals.d.ts +2 -0
- package/dist/rules/stories/positiveRefusals.d.ts.map +1 -0
- package/dist/rules/stories/positiveRefusals.js +17 -0
- package/dist/rules/stories/positiveRefusals.js.map +1 -0
- package/dist/rules/stories/sources.d.ts +1 -1
- package/dist/rules/stories/sources.d.ts.map +1 -1
- package/dist/rules/stories/usesInputs.d.ts.map +1 -1
- package/dist/rules/stories/usesInputs.js +3 -2
- package/dist/rules/stories/usesInputs.js.map +1 -1
- package/dist/testing/adapters/cli.d.ts +2 -2
- package/dist/testing/adapters/cli.d.ts.map +1 -1
- package/dist/testing/adapters/cli.js +11 -14
- package/dist/testing/adapters/cli.js.map +1 -1
- package/dist/testing/adapters/git.d.ts +10 -0
- package/dist/testing/adapters/git.d.ts.map +1 -1
- package/dist/testing/adapters/git.js +6 -2
- package/dist/testing/adapters/git.js.map +1 -1
- package/dist/testing/adapters/hookRepository.d.ts.map +1 -1
- package/dist/testing/adapters/hookRepository.js +6 -2
- package/dist/testing/adapters/hookRepository.js.map +1 -1
- package/dist/testing/ruleStory.d.ts.map +1 -1
- package/dist/testing/ruleStory.js +1 -2
- package/dist/testing/ruleStory.js.map +1 -1
- package/package.json +6 -6
- package/src/adapters/ImportAnalysisFailure.ts +6 -0
- package/src/adapters/ImportCompiler.ts +7 -20
- package/src/adapters/bodyReferences.ts +141 -0
- package/src/adapters/engineEscapes.ts +119 -0
- package/src/adapters/imports/analysisFailure.ts +5 -0
- package/src/adapters/imports/analyzeDepartures.ts +9 -0
- package/src/adapters/imports/analyzeGraph.ts +9 -0
- package/src/adapters/imports/checkBrowser.ts +5 -0
- package/src/adapters/indirectServiceReferences.ts +25 -0
- package/src/adapters/nativeTransactionFindings.ts +108 -0
- package/src/adapters/outcomeAssertions.ts +110 -0
- package/src/adapters/outsideImportFindings.ts +1 -1
- package/src/adapters/positiveRefusalFindings.ts +52 -0
- package/src/adapters/rpcBoundaryFindings.ts +98 -0
- package/src/adapters/serviceAccess.ts +38 -0
- package/src/adapters/serviceAssemblyImports.ts +93 -0
- package/src/adapters/serviceAssemblySyntax.ts +129 -0
- package/src/adapters/serviceDefinitionProblems.ts +63 -0
- package/src/adapters/serviceIdFindings.ts +16 -13
- package/src/adapters/transactionChanges.ts +85 -0
- package/src/adapters/vitePort.ts +5 -0
- package/src/appViteConfig.ts +13 -3
- package/src/rules/builtIn.ts +8 -0
- package/src/rules/effect/rpcBoundary.ts +10 -0
- package/src/rules/effect/serviceCatalog.ts +4 -2
- package/src/rules/effect/serviceDefinitionAssembly.ts +46 -0
- package/src/rules/effect/serviceIds.ts +1 -1
- package/src/rules/effect/serviceParameters.ts +12 -6
- package/src/rules/effect/sqlTransact.ts +10 -0
- package/src/rules/stories/engine.ts +25 -9
- package/src/rules/stories/positiveRefusals.ts +17 -0
- package/src/rules/stories/usesInputs.ts +3 -2
- package/src/testing/adapters/cli.ts +22 -14
- package/src/testing/adapters/git.ts +7 -2
- package/src/testing/adapters/hookRepository.ts +6 -2
- package/src/testing/ruleStory.ts +1 -2
|
@@ -0,0 +1,110 @@
|
|
|
1
|
+
import ts from "typescript";
|
|
2
|
+
import { type ImportBinding, importBindings } from "#rules/stories/importBindings.ts";
|
|
3
|
+
import { memberName, unwrapped } from "#rules/stories/syntax.ts";
|
|
4
|
+
|
|
5
|
+
export interface OutcomeAssertion {
|
|
6
|
+
readonly expected: ts.Expression;
|
|
7
|
+
readonly negative: boolean;
|
|
8
|
+
readonly node: ts.Node;
|
|
9
|
+
readonly subject: string;
|
|
10
|
+
}
|
|
11
|
+
|
|
12
|
+
function receiver(node: ts.Expression): ts.Expression | undefined {
|
|
13
|
+
const value = unwrapped(node);
|
|
14
|
+
return ts.isPropertyAccessExpression(value) || ts.isElementAccessExpression(value) ? unwrapped(value.expression) : undefined;
|
|
15
|
+
}
|
|
16
|
+
|
|
17
|
+
function imported(node: ts.Expression, name: string, modules: readonly string[], bindings: ReadonlyMap<string, ImportBinding>): boolean {
|
|
18
|
+
const value = unwrapped(node);
|
|
19
|
+
if (!ts.isIdentifier(value)) {
|
|
20
|
+
return false;
|
|
21
|
+
}
|
|
22
|
+
const binding = bindings.get(value.text);
|
|
23
|
+
return binding === undefined ? value.text === name : binding.imported === name && modules.includes(binding.module);
|
|
24
|
+
}
|
|
25
|
+
|
|
26
|
+
function subject(node: ts.Expression, checker: ts.TypeChecker): string | undefined {
|
|
27
|
+
const value = unwrapped(node);
|
|
28
|
+
if (ts.isYieldExpression(value)) {
|
|
29
|
+
return value.expression === undefined ? undefined : subject(value.expression, checker);
|
|
30
|
+
}
|
|
31
|
+
if (ts.isIdentifier(value)) {
|
|
32
|
+
const declaration = checker.getSymbolAtLocation(value)?.valueDeclaration;
|
|
33
|
+
if (declaration !== undefined && ts.isVariableDeclaration(declaration) && declaration.initializer !== undefined) {
|
|
34
|
+
return subject(declaration.initializer, checker);
|
|
35
|
+
}
|
|
36
|
+
}
|
|
37
|
+
const named = ts.isCallExpression(value) ? unwrapped(value.expression) : value;
|
|
38
|
+
const name = ts.isIdentifier(named) ? named.text : memberName(named);
|
|
39
|
+
return name !== undefined && /outcome$/iu.test(name) ? value.getText() : undefined;
|
|
40
|
+
}
|
|
41
|
+
|
|
42
|
+
function assertion(node: ts.CallExpression, checker: ts.TypeChecker, bindings: ReadonlyMap<string, ImportBinding>): OutcomeAssertion | undefined {
|
|
43
|
+
const matcher = memberName(node.expression);
|
|
44
|
+
if (matcher === undefined || !["toBe", "toEqual", "toMatchObject"].includes(matcher)) {
|
|
45
|
+
return;
|
|
46
|
+
}
|
|
47
|
+
let root = receiver(node.expression);
|
|
48
|
+
const negative = root !== undefined && memberName(root) === "not";
|
|
49
|
+
if (negative && root !== undefined) {
|
|
50
|
+
root = receiver(root);
|
|
51
|
+
}
|
|
52
|
+
if (root === undefined || !ts.isCallExpression(root)) {
|
|
53
|
+
return;
|
|
54
|
+
}
|
|
55
|
+
const callee = memberName(root.expression) === "soft" ? receiver(root.expression) : root.expression;
|
|
56
|
+
const actual = root.arguments[0];
|
|
57
|
+
const expected = node.arguments[0];
|
|
58
|
+
const key = actual === undefined ? undefined : subject(actual, checker);
|
|
59
|
+
if (
|
|
60
|
+
callee !== undefined
|
|
61
|
+
&& imported(callee, "expect", ["vitest", "@effect/vitest"], bindings)
|
|
62
|
+
&& key !== undefined
|
|
63
|
+
&& expected !== undefined
|
|
64
|
+
&& (!negative || matcher !== "toMatchObject")
|
|
65
|
+
) {
|
|
66
|
+
return { expected, negative, node, subject: key };
|
|
67
|
+
}
|
|
68
|
+
return undefined;
|
|
69
|
+
}
|
|
70
|
+
|
|
71
|
+
function grouped(node: ts.CallExpression, checker: ts.TypeChecker, bindings: ReadonlyMap<string, ImportBinding>): readonly OutcomeAssertion[] {
|
|
72
|
+
const rows = node.arguments[0];
|
|
73
|
+
if (
|
|
74
|
+
!imported(node.expression, "outcomes", ["@shivaedev/test-story/server/outcomes.ts"], bindings)
|
|
75
|
+
|| rows === undefined
|
|
76
|
+
|| !ts.isArrayLiteralExpression(rows)
|
|
77
|
+
) {
|
|
78
|
+
return [];
|
|
79
|
+
}
|
|
80
|
+
const assertions: OutcomeAssertion[] = [];
|
|
81
|
+
for (const row of rows.elements) {
|
|
82
|
+
if (!ts.isArrayLiteralExpression(row)) {
|
|
83
|
+
continue;
|
|
84
|
+
}
|
|
85
|
+
const read = row.elements[1];
|
|
86
|
+
const expected = row.elements[2];
|
|
87
|
+
const key = read !== undefined && ts.isArrowFunction(read) && !ts.isBlock(read.body) ? subject(read.body, checker) : undefined;
|
|
88
|
+
if (key !== undefined && expected !== undefined) {
|
|
89
|
+
assertions.push({ expected, negative: false, node: row, subject: key });
|
|
90
|
+
}
|
|
91
|
+
}
|
|
92
|
+
return assertions;
|
|
93
|
+
}
|
|
94
|
+
|
|
95
|
+
export function outcomeAssertions(body: ts.Node, checker: ts.TypeChecker): readonly OutcomeAssertion[] {
|
|
96
|
+
const bindings = importBindings(body.getSourceFile());
|
|
97
|
+
const assertions: OutcomeAssertion[] = [];
|
|
98
|
+
function visit(node: ts.Node): void {
|
|
99
|
+
if (ts.isFunctionLike(node) && node !== body) {
|
|
100
|
+
return;
|
|
101
|
+
}
|
|
102
|
+
if (ts.isCallExpression(node)) {
|
|
103
|
+
const direct = assertion(node, checker, bindings);
|
|
104
|
+
assertions.push(...(direct === undefined ? [] : [direct]), ...grouped(node, checker, bindings));
|
|
105
|
+
}
|
|
106
|
+
ts.forEachChild(node, visit);
|
|
107
|
+
}
|
|
108
|
+
visit(body);
|
|
109
|
+
return assertions;
|
|
110
|
+
}
|
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
import { Effect } from "effect";
|
|
2
2
|
import ts from "typescript";
|
|
3
|
-
import type { ImportAnalysisFailure } from "#adapters/
|
|
3
|
+
import type { ImportAnalysisFailure } from "#adapters/ImportAnalysisFailure.ts";
|
|
4
4
|
import { readPackageManifest } from "#adapters/manifestInventory.ts";
|
|
5
5
|
import { importGraph } from "#imports/graph.ts";
|
|
6
6
|
import { packageNameOf } from "#imports/packageName.ts";
|
|
@@ -0,0 +1,52 @@
|
|
|
1
|
+
import ts from "typescript";
|
|
2
|
+
import type { Finding, SourceFile } from "#rule.ts";
|
|
3
|
+
import type { storyOrigins } from "#rules/stories/origins.ts";
|
|
4
|
+
import { nodesWhere, unwrapped } from "#rules/stories/syntax.ts";
|
|
5
|
+
import { type OutcomeAssertion, outcomeAssertions } from "./outcomeAssertions.ts";
|
|
6
|
+
|
|
7
|
+
const MESSAGE =
|
|
8
|
+
"Only rules out an outcome. Assert the expected refusal's domain reason or public response positively on the same outcome in this story; an unrelated failure must fail the story too.";
|
|
9
|
+
|
|
10
|
+
function concrete(node: ts.Expression): boolean {
|
|
11
|
+
const value = unwrapped(node);
|
|
12
|
+
return (
|
|
13
|
+
(ts.isStringLiteralLike(value) && value.text.length > 0)
|
|
14
|
+
|| (ts.isObjectLiteralExpression(value)
|
|
15
|
+
&& value.properties.some((property) => ts.isPropertyAssignment(property) && concrete(property.initializer)))
|
|
16
|
+
);
|
|
17
|
+
}
|
|
18
|
+
|
|
19
|
+
function sameExpected(left: ts.Expression, right: ts.Expression): boolean {
|
|
20
|
+
const a = unwrapped(left);
|
|
21
|
+
const b = unwrapped(right);
|
|
22
|
+
return ts.isStringLiteralLike(a) && ts.isStringLiteralLike(b) ? a.text === b.text : a.getText() === b.getText();
|
|
23
|
+
}
|
|
24
|
+
|
|
25
|
+
function confirmsRefusal(positive: OutcomeAssertion, negative: OutcomeAssertion): boolean {
|
|
26
|
+
return (
|
|
27
|
+
!positive.negative && positive.subject === negative.subject && concrete(positive.expected) && !sameExpected(positive.expected, negative.expected)
|
|
28
|
+
);
|
|
29
|
+
}
|
|
30
|
+
|
|
31
|
+
export function positiveRefusalFindings(file: SourceFile, origins: ReturnType<typeof storyOrigins>): readonly Finding[] {
|
|
32
|
+
const source = origins.source(file.path);
|
|
33
|
+
if (source === undefined) {
|
|
34
|
+
return [];
|
|
35
|
+
}
|
|
36
|
+
return nodesWhere(source, (node) => ts.isCallExpression(node) && origins.origin(node.expression) === "story")
|
|
37
|
+
.filter(ts.isCallExpression)
|
|
38
|
+
.flatMap((story) => {
|
|
39
|
+
const body = story.arguments[2];
|
|
40
|
+
if (body === undefined) {
|
|
41
|
+
return [];
|
|
42
|
+
}
|
|
43
|
+
const assertions = outcomeAssertions(body, origins.checker);
|
|
44
|
+
return assertions
|
|
45
|
+
.filter((negative) => negative.negative && !assertions.some((positive) => confirmsRefusal(positive, negative)))
|
|
46
|
+
.map(({ node }) => ({
|
|
47
|
+
file: file.path,
|
|
48
|
+
line: source.getLineAndCharacterOfPosition(node.getStart(source)).line + 1,
|
|
49
|
+
message: MESSAGE,
|
|
50
|
+
}));
|
|
51
|
+
});
|
|
52
|
+
}
|
|
@@ -0,0 +1,98 @@
|
|
|
1
|
+
import { join } from "node:path";
|
|
2
|
+
import { Effect } from "effect";
|
|
3
|
+
import ts from "typescript";
|
|
4
|
+
import { importGraph } from "#imports/graph.ts";
|
|
5
|
+
import { isTestSupport } from "#naming/testName.ts";
|
|
6
|
+
import type { Finding, RuleInputs } from "#rule.ts";
|
|
7
|
+
import { effectProgram } from "#rules/effect/program.ts";
|
|
8
|
+
import { nodesWhere } from "#rules/stories/syntax.ts";
|
|
9
|
+
|
|
10
|
+
function boundaryName(declaration: ts.Declaration | undefined): string | undefined {
|
|
11
|
+
if (declaration === undefined || !ts.isFunctionDeclaration(declaration)) {
|
|
12
|
+
return undefined;
|
|
13
|
+
}
|
|
14
|
+
const name = declaration.name?.text;
|
|
15
|
+
const path = declaration.getSourceFile().fileName.replaceAll("\\", "/");
|
|
16
|
+
return /\/(?:@shivaedev\/)?errors\/(?:src|dist)\/(?:boundary|rpcBoundaryHandlers)\.(?:d\.)?ts$/u.test(path)
|
|
17
|
+
&& (name === "rpcBoundary" || name === "rpcBoundaryHandlers")
|
|
18
|
+
? name
|
|
19
|
+
: undefined;
|
|
20
|
+
}
|
|
21
|
+
|
|
22
|
+
function handlerBuilder(declaration: ts.Declaration | undefined): boolean {
|
|
23
|
+
if (declaration === undefined) {
|
|
24
|
+
return false;
|
|
25
|
+
}
|
|
26
|
+
const path = declaration.getSourceFile().fileName.replaceAll("\\", "/");
|
|
27
|
+
return (
|
|
28
|
+
ts.isMethodSignature(declaration)
|
|
29
|
+
&& ["toLayer", "toLayerHandler", "toHandlers", "of"].includes(declaration.name.getText())
|
|
30
|
+
&& /\/effect\/(?:src|dist(?:\/dts)?)\/(?:unstable\/)?rpc\/RpcGroup\.(?:d\.)?ts$/u.test(path)
|
|
31
|
+
);
|
|
32
|
+
}
|
|
33
|
+
|
|
34
|
+
function checkSources(inputs: RuleInputs): readonly Finding[] {
|
|
35
|
+
const program = effectProgram(inputs);
|
|
36
|
+
const checker = program.getTypeChecker();
|
|
37
|
+
return inputs.sources.flatMap((file) => {
|
|
38
|
+
const source = program.getSourceFile(join(inputs.root, file.path));
|
|
39
|
+
if (source === undefined) {
|
|
40
|
+
return [];
|
|
41
|
+
}
|
|
42
|
+
const calls = nodesWhere(source, ts.isCallExpression)
|
|
43
|
+
.filter(ts.isCallExpression)
|
|
44
|
+
.map((call) => ({ call, declaration: checker.getTypeAtLocation(call.expression).getCallSignatures()[0]?.getDeclaration() }));
|
|
45
|
+
if (
|
|
46
|
+
calls.some(({ declaration }) => handlerBuilder(declaration))
|
|
47
|
+
|| source.statements.some((statement) => ts.isFunctionDeclaration(statement) && boundaryName(statement) === "rpcBoundaryHandlers")
|
|
48
|
+
) {
|
|
49
|
+
return [];
|
|
50
|
+
}
|
|
51
|
+
return calls.flatMap(({ call, declaration }): readonly Finding[] => {
|
|
52
|
+
const name = boundaryName(declaration);
|
|
53
|
+
return name === undefined
|
|
54
|
+
? []
|
|
55
|
+
: [
|
|
56
|
+
{
|
|
57
|
+
file: file.path,
|
|
58
|
+
line: source.getLineAndCharacterOfPosition(call.getStart(source)).line + 1,
|
|
59
|
+
message: `Uses ${name} outside a module that builds RPC handlers. Move the boundary into the module calling the RPC group's toLayer, toLayerHandler, toHandlers or of; services must keep their own typed failures.`,
|
|
60
|
+
},
|
|
61
|
+
];
|
|
62
|
+
});
|
|
63
|
+
});
|
|
64
|
+
}
|
|
65
|
+
|
|
66
|
+
export const rpcBoundaryFindings = Effect.fn("RpcBoundary.rpcBoundaryFindings")(function* (inputs: RuleInputs) {
|
|
67
|
+
const candidates = new Set(inputs.sources.filter((source) => source.text.includes("rpcBoundary")).map((source) => source.path));
|
|
68
|
+
if (candidates.size === 0) {
|
|
69
|
+
return [];
|
|
70
|
+
}
|
|
71
|
+
const graph = yield* importGraph(inputs);
|
|
72
|
+
const importers = new Map<string, string[]>();
|
|
73
|
+
for (const edge of graph.edges) {
|
|
74
|
+
if (edge.to.kind === "file" && !edge.type) {
|
|
75
|
+
const paths = importers.get(edge.to.path) ?? [];
|
|
76
|
+
paths.push(edge.from);
|
|
77
|
+
importers.set(edge.to.path, paths);
|
|
78
|
+
}
|
|
79
|
+
}
|
|
80
|
+
for (const path of candidates) {
|
|
81
|
+
for (const importer of importers.get(path) ?? []) {
|
|
82
|
+
candidates.add(importer);
|
|
83
|
+
}
|
|
84
|
+
}
|
|
85
|
+
return yield* Effect.sync(() => {
|
|
86
|
+
const groups = new Map<string, RuleInputs["sources"][number][]>();
|
|
87
|
+
for (const source of inputs.sources) {
|
|
88
|
+
if (isTestSupport(source.path) || !/\.[cm]?[jt]sx?$/u.test(source.path) || !candidates.has(source.path)) {
|
|
89
|
+
continue;
|
|
90
|
+
}
|
|
91
|
+
const group = /^(?:packages|examples)\/[^/]+/u.exec(source.path)?.[0] ?? ".";
|
|
92
|
+
const sources = groups.get(group) ?? [];
|
|
93
|
+
sources.push(source);
|
|
94
|
+
groups.set(group, sources);
|
|
95
|
+
}
|
|
96
|
+
return [...groups.values()].flatMap((sources) => checkSources({ ...inputs, sources }));
|
|
97
|
+
});
|
|
98
|
+
});
|
|
@@ -0,0 +1,38 @@
|
|
|
1
|
+
import { basename } from "node:path";
|
|
2
|
+
import ts from "typescript";
|
|
3
|
+
import type { BodyReference } from "./bodyReferences.ts";
|
|
4
|
+
|
|
5
|
+
function nativeService({ module, path }: BodyReference): boolean {
|
|
6
|
+
const name = path[0];
|
|
7
|
+
return name !== undefined && (module === "effect" || module.startsWith("effect/")) && (basename(module) === name || path[1] === name);
|
|
8
|
+
}
|
|
9
|
+
|
|
10
|
+
function member(value: BodyReference): boolean {
|
|
11
|
+
return value.kind === "service" ? value.path.length > 0 : nativeService(value) && value.path.length > (value.path[0] === value.path[1] ? 2 : 1);
|
|
12
|
+
}
|
|
13
|
+
|
|
14
|
+
function outerExpression(node: ts.Node): ts.Node {
|
|
15
|
+
let use = node;
|
|
16
|
+
while (ts.isParenthesizedExpression(use.parent) || ts.isAsExpression(use.parent) || ts.isNonNullExpression(use.parent)) {
|
|
17
|
+
use = use.parent;
|
|
18
|
+
}
|
|
19
|
+
return use;
|
|
20
|
+
}
|
|
21
|
+
|
|
22
|
+
function readsService(called: BodyReference | undefined): boolean {
|
|
23
|
+
return called !== undefined && !called.path.at(-1)?.startsWith("provide") && ["effect", "effect/Effect", "effect/Context"].includes(called.module);
|
|
24
|
+
}
|
|
25
|
+
|
|
26
|
+
export function serviceAccess(node: ts.Node, value: BodyReference, reference: (node: ts.Node) => BodyReference | undefined): boolean {
|
|
27
|
+
if (!(value.kind === "service" || (value.kind === "import" && nativeService(value)))) {
|
|
28
|
+
return false;
|
|
29
|
+
}
|
|
30
|
+
if (value.kind === "service" && value.path.at(-1) === "of") {
|
|
31
|
+
return false;
|
|
32
|
+
}
|
|
33
|
+
if (member(value)) {
|
|
34
|
+
return true;
|
|
35
|
+
}
|
|
36
|
+
const use = outerExpression(node);
|
|
37
|
+
return ts.isYieldExpression(use.parent) || (ts.isCallExpression(use.parent) && readsService(reference(use.parent.expression)));
|
|
38
|
+
}
|
|
@@ -0,0 +1,93 @@
|
|
|
1
|
+
import ts from "typescript";
|
|
2
|
+
|
|
3
|
+
export interface ServiceAssemblyImports {
|
|
4
|
+
readonly definitions: ReadonlySet<string>;
|
|
5
|
+
readonly effects: ReadonlySet<string>;
|
|
6
|
+
readonly generics: ReadonlySet<string>;
|
|
7
|
+
readonly unsupported: readonly ts.Node[];
|
|
8
|
+
readonly values: ReadonlySet<string>;
|
|
9
|
+
}
|
|
10
|
+
|
|
11
|
+
function importedNames(clause: ts.ImportClause, name: string): readonly string[] {
|
|
12
|
+
const bindings = clause.namedBindings;
|
|
13
|
+
if (bindings === undefined || !ts.isNamedImports(bindings)) {
|
|
14
|
+
return [];
|
|
15
|
+
}
|
|
16
|
+
return bindings.elements.flatMap((element) =>
|
|
17
|
+
!element.isTypeOnly && (element.propertyName?.text ?? element.name.text) === name ? [element.name.text] : [],
|
|
18
|
+
);
|
|
19
|
+
}
|
|
20
|
+
|
|
21
|
+
function valueImport(statement: ts.Statement):
|
|
22
|
+
| {
|
|
23
|
+
readonly clause: ts.ImportClause;
|
|
24
|
+
readonly module: string;
|
|
25
|
+
}
|
|
26
|
+
| undefined {
|
|
27
|
+
if (
|
|
28
|
+
!(ts.isImportDeclaration(statement) && ts.isStringLiteral(statement.moduleSpecifier))
|
|
29
|
+
|| statement.importClause === undefined
|
|
30
|
+
|| statement.importClause.isTypeOnly
|
|
31
|
+
) {
|
|
32
|
+
return;
|
|
33
|
+
}
|
|
34
|
+
return {
|
|
35
|
+
clause: statement.importClause,
|
|
36
|
+
module: statement.moduleSpecifier.text,
|
|
37
|
+
};
|
|
38
|
+
}
|
|
39
|
+
|
|
40
|
+
function collectDefinitionImport(clause: ts.ImportClause, definitions: Set<string>, unsupported: ts.Node[]): void {
|
|
41
|
+
if (clause.namedBindings !== undefined && ts.isNamespaceImport(clause.namedBindings)) {
|
|
42
|
+
unsupported.push(clause.namedBindings);
|
|
43
|
+
}
|
|
44
|
+
for (const name of importedNames(clause, "defineService")) {
|
|
45
|
+
definitions.add(name);
|
|
46
|
+
}
|
|
47
|
+
}
|
|
48
|
+
|
|
49
|
+
function collectValueImports(clause: ts.ImportClause, values: Set<string>): void {
|
|
50
|
+
if (clause.namedBindings === undefined || !ts.isNamedImports(clause.namedBindings)) {
|
|
51
|
+
return;
|
|
52
|
+
}
|
|
53
|
+
for (const element of clause.namedBindings.elements) {
|
|
54
|
+
if (!element.isTypeOnly) {
|
|
55
|
+
values.add(element.name.text);
|
|
56
|
+
}
|
|
57
|
+
}
|
|
58
|
+
}
|
|
59
|
+
|
|
60
|
+
function effectNames(clause: ts.ImportClause, module: string): readonly string[] {
|
|
61
|
+
if (module === "effect") {
|
|
62
|
+
return importedNames(clause, "Effect");
|
|
63
|
+
}
|
|
64
|
+
const bindings = clause.namedBindings;
|
|
65
|
+
return module === "effect/Effect" && bindings !== undefined && ts.isNamespaceImport(bindings) ? [bindings.name.text] : [];
|
|
66
|
+
}
|
|
67
|
+
|
|
68
|
+
export function serviceAssemblyImports(source: ts.SourceFile): ServiceAssemblyImports {
|
|
69
|
+
const definitions = new Set<string>();
|
|
70
|
+
const effects = new Set<string>();
|
|
71
|
+
const generics = new Set<string>();
|
|
72
|
+
const unsupported: ts.Node[] = [];
|
|
73
|
+
const values = new Set<string>();
|
|
74
|
+
for (const statement of source.statements) {
|
|
75
|
+
const imported = valueImport(statement);
|
|
76
|
+
if (imported === undefined) {
|
|
77
|
+
continue;
|
|
78
|
+
}
|
|
79
|
+
collectValueImports(imported.clause, values);
|
|
80
|
+
if (imported.module === "@shivaedev/service/defineService.ts") {
|
|
81
|
+
collectDefinitionImport(imported.clause, definitions, unsupported);
|
|
82
|
+
}
|
|
83
|
+
if (imported.module === "@shivaedev/service/genericMethod.ts") {
|
|
84
|
+
for (const name of importedNames(imported.clause, "genericMethod")) {
|
|
85
|
+
generics.add(name);
|
|
86
|
+
}
|
|
87
|
+
}
|
|
88
|
+
for (const name of effectNames(imported.clause, imported.module)) {
|
|
89
|
+
effects.add(name);
|
|
90
|
+
}
|
|
91
|
+
}
|
|
92
|
+
return { definitions, effects, generics, unsupported, values };
|
|
93
|
+
}
|
|
@@ -0,0 +1,129 @@
|
|
|
1
|
+
import ts from "typescript";
|
|
2
|
+
|
|
3
|
+
export function unwrapExpression(expression: ts.Expression): ts.Expression {
|
|
4
|
+
if (ts.isParenthesizedExpression(expression) || ts.isAsExpression(expression) || ts.isSatisfiesExpression(expression)) {
|
|
5
|
+
return unwrapExpression(expression.expression);
|
|
6
|
+
}
|
|
7
|
+
return expression;
|
|
8
|
+
}
|
|
9
|
+
|
|
10
|
+
export function directServiceDefinitions(source: ts.SourceFile, names: ReadonlySet<string>): readonly ts.CallExpression[] {
|
|
11
|
+
const found: ts.CallExpression[] = [];
|
|
12
|
+
for (const statement of source.statements) {
|
|
13
|
+
if (!ts.isVariableStatement(statement)) {
|
|
14
|
+
continue;
|
|
15
|
+
}
|
|
16
|
+
for (const declaration of statement.declarationList.declarations) {
|
|
17
|
+
if (declaration.initializer === undefined) {
|
|
18
|
+
continue;
|
|
19
|
+
}
|
|
20
|
+
const value = unwrapExpression(declaration.initializer);
|
|
21
|
+
if (!ts.isCallExpression(value)) {
|
|
22
|
+
continue;
|
|
23
|
+
}
|
|
24
|
+
const called = unwrapExpression(value.expression);
|
|
25
|
+
if (ts.isIdentifier(called) && names.has(called.text)) {
|
|
26
|
+
found.push(value);
|
|
27
|
+
}
|
|
28
|
+
}
|
|
29
|
+
}
|
|
30
|
+
return found;
|
|
31
|
+
}
|
|
32
|
+
|
|
33
|
+
const CONFIG_MEMBERS = new Set(["id", "initialize", "methods", "requires"]);
|
|
34
|
+
|
|
35
|
+
export function invalidServiceMembers(config: ts.ObjectLiteralExpression): readonly ts.ObjectLiteralElementLike[] {
|
|
36
|
+
return config.properties.filter(
|
|
37
|
+
(member) =>
|
|
38
|
+
!(
|
|
39
|
+
(ts.isPropertyAssignment(member) || ts.isShorthandPropertyAssignment(member))
|
|
40
|
+
&& ts.isIdentifier(member.name)
|
|
41
|
+
&& CONFIG_MEMBERS.has(member.name.text)
|
|
42
|
+
),
|
|
43
|
+
);
|
|
44
|
+
}
|
|
45
|
+
|
|
46
|
+
export function serviceProperty(object: ts.ObjectLiteralExpression, name: string): ts.Expression | undefined {
|
|
47
|
+
const member = object.properties.find(
|
|
48
|
+
(candidate) =>
|
|
49
|
+
(ts.isPropertyAssignment(candidate) || ts.isShorthandPropertyAssignment(candidate))
|
|
50
|
+
&& ts.isIdentifier(candidate.name)
|
|
51
|
+
&& candidate.name.text === name,
|
|
52
|
+
);
|
|
53
|
+
if (member !== undefined && ts.isPropertyAssignment(member)) {
|
|
54
|
+
return member.initializer;
|
|
55
|
+
}
|
|
56
|
+
return member !== undefined && ts.isShorthandPropertyAssignment(member) ? member.name : undefined;
|
|
57
|
+
}
|
|
58
|
+
|
|
59
|
+
export function returnedServiceMethods(value: ts.Expression): ts.ObjectLiteralExpression | undefined {
|
|
60
|
+
if (!ts.isArrowFunction(value)) {
|
|
61
|
+
return;
|
|
62
|
+
}
|
|
63
|
+
if (!ts.isBlock(value.body)) {
|
|
64
|
+
const body = unwrapExpression(value.body);
|
|
65
|
+
return ts.isObjectLiteralExpression(body) ? body : undefined;
|
|
66
|
+
}
|
|
67
|
+
if (value.body.statements.length !== 1) {
|
|
68
|
+
return;
|
|
69
|
+
}
|
|
70
|
+
const [statement] = value.body.statements;
|
|
71
|
+
if (statement === undefined || !ts.isReturnStatement(statement) || statement.expression === undefined) {
|
|
72
|
+
return;
|
|
73
|
+
}
|
|
74
|
+
const result = unwrapExpression(statement.expression);
|
|
75
|
+
return ts.isObjectLiteralExpression(result) ? result : undefined;
|
|
76
|
+
}
|
|
77
|
+
|
|
78
|
+
export function isEffectVoid(value: ts.Expression, effects: ReadonlySet<string>): boolean {
|
|
79
|
+
return (
|
|
80
|
+
ts.isPropertyAccessExpression(value) && ts.isIdentifier(value.expression) && effects.has(value.expression.text) && value.name.text === "void"
|
|
81
|
+
);
|
|
82
|
+
}
|
|
83
|
+
|
|
84
|
+
export function isOperationReference(member: ts.ObjectLiteralElementLike, imports: ReadonlySet<string>, generics: ReadonlySet<string>): boolean {
|
|
85
|
+
if (ts.isShorthandPropertyAssignment(member)) {
|
|
86
|
+
return imports.has(member.name.text);
|
|
87
|
+
}
|
|
88
|
+
if (!ts.isPropertyAssignment(member) || ts.isComputedPropertyName(member.name)) {
|
|
89
|
+
return false;
|
|
90
|
+
}
|
|
91
|
+
const value = unwrapExpression(member.initializer);
|
|
92
|
+
if (ts.isIdentifier(value)) {
|
|
93
|
+
return imports.has(value.text);
|
|
94
|
+
}
|
|
95
|
+
if (ts.isCallExpression(value) && ts.isIdentifier(value.expression) && generics.has(value.expression.text)) {
|
|
96
|
+
const method = value.arguments[0];
|
|
97
|
+
return method !== undefined && isOperationValue(unwrapExpression(method), imports);
|
|
98
|
+
}
|
|
99
|
+
return isOperationValue(value, imports);
|
|
100
|
+
}
|
|
101
|
+
|
|
102
|
+
function isOperationValue(value: ts.Expression, imports: ReadonlySet<string>): boolean {
|
|
103
|
+
return (
|
|
104
|
+
(ts.isIdentifier(value) && imports.has(value.text))
|
|
105
|
+
|| (ts.isCallExpression(value)
|
|
106
|
+
&& ts.isIdentifier(unwrapExpression(value.expression))
|
|
107
|
+
&& imports.has(unwrapExpression(value.expression).getText()))
|
|
108
|
+
);
|
|
109
|
+
}
|
|
110
|
+
|
|
111
|
+
function isFunctionBody(node: ts.Node): node is ts.FunctionLikeDeclaration {
|
|
112
|
+
return (
|
|
113
|
+
(ts.isArrowFunction(node) || ts.isFunctionExpression(node) || ts.isFunctionDeclaration(node) || ts.isMethodDeclaration(node))
|
|
114
|
+
&& node.body !== undefined
|
|
115
|
+
);
|
|
116
|
+
}
|
|
117
|
+
|
|
118
|
+
export function implementationBodies(source: ts.SourceFile, allowed: ReadonlySet<ts.Node>): readonly ts.Node[] {
|
|
119
|
+
const found: ts.Node[] = [];
|
|
120
|
+
function visit(node: ts.Node): void {
|
|
121
|
+
if (isFunctionBody(node) && !allowed.has(node)) {
|
|
122
|
+
found.push(node);
|
|
123
|
+
return;
|
|
124
|
+
}
|
|
125
|
+
ts.forEachChild(node, visit);
|
|
126
|
+
}
|
|
127
|
+
visit(source);
|
|
128
|
+
return found;
|
|
129
|
+
}
|
|
@@ -0,0 +1,63 @@
|
|
|
1
|
+
import ts from "typescript";
|
|
2
|
+
import {
|
|
3
|
+
invalidServiceMembers,
|
|
4
|
+
isEffectVoid,
|
|
5
|
+
isOperationReference,
|
|
6
|
+
returnedServiceMethods,
|
|
7
|
+
serviceProperty,
|
|
8
|
+
unwrapExpression,
|
|
9
|
+
} from "#adapters/serviceAssemblySyntax.ts";
|
|
10
|
+
|
|
11
|
+
export interface ServiceAssemblyProblem {
|
|
12
|
+
readonly message: string;
|
|
13
|
+
readonly node: ts.Node;
|
|
14
|
+
}
|
|
15
|
+
|
|
16
|
+
export function serviceDefinitionProblems(
|
|
17
|
+
definition: ts.CallExpression,
|
|
18
|
+
effects: ReadonlySet<string>,
|
|
19
|
+
imports: ReadonlySet<string>,
|
|
20
|
+
allowedBodies: Set<ts.Node>,
|
|
21
|
+
generics: ReadonlySet<string>,
|
|
22
|
+
): readonly ServiceAssemblyProblem[] {
|
|
23
|
+
const config = definition.arguments[0];
|
|
24
|
+
if (config === undefined || !ts.isObjectLiteralExpression(config)) {
|
|
25
|
+
return [{ message: "Inline the service inventory.", node: definition }];
|
|
26
|
+
}
|
|
27
|
+
const found: ServiceAssemblyProblem[] = invalidServiceMembers(config).map((node) => ({
|
|
28
|
+
message: "List id, initialize, methods, and requires directly; computed members and spreads cannot hide the service inventory.",
|
|
29
|
+
node,
|
|
30
|
+
}));
|
|
31
|
+
const initialize = serviceProperty(config, "initialize");
|
|
32
|
+
if (
|
|
33
|
+
initialize !== undefined
|
|
34
|
+
&& !(ts.isIdentifier(unwrapExpression(initialize)) && imports.has(unwrapExpression(initialize).getText()))
|
|
35
|
+
&& !isEffectVoid(unwrapExpression(initialize), effects)
|
|
36
|
+
) {
|
|
37
|
+
found.push({
|
|
38
|
+
message: "Reference a named initializer export or use Effect.void.",
|
|
39
|
+
node: initialize,
|
|
40
|
+
});
|
|
41
|
+
}
|
|
42
|
+
const methodsValue = serviceProperty(config, "methods");
|
|
43
|
+
const methods = methodsValue && returnedServiceMethods(methodsValue);
|
|
44
|
+
if (methodsValue !== undefined && methods === undefined) {
|
|
45
|
+
found.push({
|
|
46
|
+
message: "Keep methods as a direct operation inventory.",
|
|
47
|
+
node: methodsValue,
|
|
48
|
+
});
|
|
49
|
+
return found;
|
|
50
|
+
}
|
|
51
|
+
if (methodsValue !== undefined) {
|
|
52
|
+
allowedBodies.add(methodsValue);
|
|
53
|
+
}
|
|
54
|
+
for (const operation of methods?.properties ?? []) {
|
|
55
|
+
if (!isOperationReference(operation, imports, generics)) {
|
|
56
|
+
found.push({
|
|
57
|
+
message: "Reference a named operation export or call its named state factory.",
|
|
58
|
+
node: operation,
|
|
59
|
+
});
|
|
60
|
+
}
|
|
61
|
+
}
|
|
62
|
+
return found;
|
|
63
|
+
}
|
|
@@ -1,6 +1,7 @@
|
|
|
1
1
|
import { join } from "node:path";
|
|
2
2
|
import { Effect } from "effect";
|
|
3
3
|
import ts from "typescript";
|
|
4
|
+
import { packageOf, type WorkspacePackage, workspacePackages } from "#imports/workspace.ts";
|
|
4
5
|
import type { Finding, RuleInputs } from "#rule.ts";
|
|
5
6
|
import { boundaryReference } from "#rules/effect/boundaryReference.ts";
|
|
6
7
|
|
|
@@ -64,17 +65,19 @@ function checkPackage(inputs: RuleInputs, prefix: string): readonly Finding[] {
|
|
|
64
65
|
});
|
|
65
66
|
}
|
|
66
67
|
|
|
67
|
-
export const serviceIdFindings = Effect.fn("ServiceIds.serviceIdFindings")((inputs: RuleInputs)
|
|
68
|
-
Effect.
|
|
69
|
-
|
|
70
|
-
|
|
71
|
-
|
|
72
|
-
|
|
73
|
-
|
|
74
|
-
|
|
75
|
-
|
|
76
|
-
|
|
68
|
+
export const serviceIdFindings = Effect.fn("ServiceIds.serviceIdFindings")(function* (inputs: RuleInputs) {
|
|
69
|
+
const packages = yield* Effect.promise(() => workspacePackages(inputs));
|
|
70
|
+
const groups = new Map<WorkspacePackage, RuleInputs["sources"][number][]>();
|
|
71
|
+
for (const source of inputs.sources) {
|
|
72
|
+
if (!source.path.startsWith("packages/")) {
|
|
73
|
+
continue;
|
|
74
|
+
}
|
|
75
|
+
const owner = packageOf(packages, source.path);
|
|
76
|
+
if (owner !== undefined) {
|
|
77
|
+
const files = groups.get(owner) ?? [];
|
|
78
|
+
files.push(source);
|
|
79
|
+
groups.set(owner, files);
|
|
77
80
|
}
|
|
78
|
-
|
|
79
|
-
})
|
|
80
|
-
);
|
|
81
|
+
}
|
|
82
|
+
return [...groups].flatMap(([owner, sources]) => checkPackage({ ...inputs, sources }, `${owner.name}/`));
|
|
83
|
+
});
|