@starci/eslint-canon-be 3.8.20 → 3.9.2
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 +16 -0
- package/package.json +1 -1
- package/runtime/bundle.json +192 -0
- package/runtime/engine/by-code-unit.mjs +6 -6
- package/runtime/engine/model-config.mjs +98 -76
- package/runtime/engine/orca-config.mjs +22 -17
- package/runtime/engine/release-config.mjs +22 -18
- package/runtime/engine/removed-vocabulary.mjs +21 -20
- package/runtime/engine/resources-config.mjs +42 -35
- package/runtime/engine/runtime-root.mjs +11 -13
- package/runtime/engine/secrets.mjs +170 -102
- package/runtime/engine/sonar-config.mjs +16 -13
- package/runtime/engine/temp-root.mjs +3 -9
- package/runtime/knowledge/hfs/canon-pins.yaml +10 -10
- package/runtime/knowledge/hfs/rules.yaml +6 -6
- package/runtime/knowledge/hfs/slots.yaml +2 -2
- package/runtime/knowledge/sonar-gate.yaml +1 -1
- package/runtime/packages/hfs/templates/app/package-scripts/package.json +1 -1
- package/runtime/scripts/api/git/cat-file.mjs +0 -1
- package/runtime/scripts/api/git/config-get.mjs +1 -2
- package/runtime/scripts/api/git/diff.mjs +0 -1
- package/runtime/scripts/api/git/lib.mjs +32 -32
- package/runtime/scripts/api/git/ls-files.mjs +0 -1
- package/runtime/scripts/api/git/ls-tree.mjs +0 -1
- package/runtime/scripts/api/git/merge-base.mjs +2 -3
- package/runtime/scripts/api/git/remote.mjs +0 -1
- package/runtime/scripts/api/git/rev-parse-query.mjs +0 -1
- package/runtime/scripts/api/git/show.mjs +0 -1
- package/runtime/scripts/hfs/allows.mjs +37 -38
- package/runtime/scripts/hfs/architecture/ast-walks.mjs +180 -163
- package/runtime/scripts/hfs/architecture/automatic-gates.mjs +80 -73
- package/runtime/scripts/hfs/architecture/backend-app-files.mjs +88 -77
- package/runtime/scripts/hfs/architecture/backend.mjs +378 -357
- package/runtime/scripts/hfs/architecture/background-unowned.mjs +201 -187
- package/runtime/scripts/hfs/architecture/canon-clones.mjs +260 -209
- package/runtime/scripts/hfs/architecture/canon-jsx-clones.mjs +149 -116
- package/runtime/scripts/hfs/architecture/client-reaches-server.mjs +72 -68
- package/runtime/scripts/hfs/architecture/clones.mjs +212 -217
- package/runtime/scripts/hfs/architecture/config-unread.mjs +7 -9
- package/runtime/scripts/hfs/architecture/config.mjs +302 -268
- package/runtime/scripts/hfs/architecture/connection-map.mjs +258 -225
- package/runtime/scripts/hfs/architecture/constructor-deps.mjs +80 -71
- package/runtime/scripts/hfs/architecture/context-coupling.mjs +82 -77
- package/runtime/scripts/hfs/architecture/context-map.mjs +267 -234
- package/runtime/scripts/hfs/architecture/context-owner.mjs +73 -61
- package/runtime/scripts/hfs/architecture/context-platform-tables.mjs +47 -43
- package/runtime/scripts/hfs/architecture/context-transaction.mjs +54 -52
- package/runtime/scripts/hfs/architecture/contract-fixture-guard.mjs +113 -104
- package/runtime/scripts/hfs/architecture/contracts-readonly.mjs +288 -270
- package/runtime/scripts/hfs/architecture/contracts.mjs +408 -393
- package/runtime/scripts/hfs/architecture/cross-app-duplicate.mjs +50 -51
- package/runtime/scripts/hfs/architecture/dead-exports-bindings.mjs +143 -119
- package/runtime/scripts/hfs/architecture/dead-exports.mjs +286 -228
- package/runtime/scripts/hfs/architecture/default-deny.mjs +129 -110
- package/runtime/scripts/hfs/architecture/doc-language.mjs +24 -19
- package/runtime/scripts/hfs/architecture/entity-registry.mjs +20 -22
- package/runtime/scripts/hfs/architecture/entrypoint.mjs +47 -45
- package/runtime/scripts/hfs/architecture/error-codes.mjs +37 -35
- package/runtime/scripts/hfs/architecture/error-masked.mjs +55 -59
- package/runtime/scripts/hfs/architecture/fe-slot-allows.mjs +24 -23
- package/runtime/scripts/hfs/architecture/feature-shape.mjs +40 -38
- package/runtime/scripts/hfs/architecture/framework-pinned.mjs +21 -21
- package/runtime/scripts/hfs/architecture/frontend-block-render.mjs +106 -98
- package/runtime/scripts/hfs/architecture/frontend-grammar.mjs +153 -150
- package/runtime/scripts/hfs/architecture/frontend-routing.mjs +161 -149
- package/runtime/scripts/hfs/architecture/frontend-world-render.mjs +343 -305
- package/runtime/scripts/hfs/architecture/frontend-world.mjs +340 -294
- package/runtime/scripts/hfs/architecture/frontend.mjs +174 -184
- package/runtime/scripts/hfs/architecture/function-spec-providers.mjs +124 -106
- package/runtime/scripts/hfs/architecture/hfs-graph.mjs +52 -48
- package/runtime/scripts/hfs/architecture/hooks-are-hooks.mjs +81 -71
- package/runtime/scripts/hfs/architecture/i18n-keys.mjs +155 -141
- package/runtime/scripts/hfs/architecture/identity.mjs +141 -125
- package/runtime/scripts/hfs/architecture/index.mjs +272 -272
- package/runtime/scripts/hfs/architecture/injection-token-exported.mjs +45 -43
- package/runtime/scripts/hfs/architecture/jwt-ast.mjs +195 -176
- package/runtime/scripts/hfs/architecture/machine-ast.mjs +163 -155
- package/runtime/scripts/hfs/architecture/managed-scripts.mjs +19 -20
- package/runtime/scripts/hfs/architecture/module-per-transport.mjs +177 -172
- package/runtime/scripts/hfs/architecture/next-data-contract.mjs +100 -78
- package/runtime/scripts/hfs/architecture/next-data-inference.mjs +170 -154
- package/runtime/scripts/hfs/architecture/next-data-key.mjs +311 -275
- package/runtime/scripts/hfs/architecture/next-data-symbols.mjs +17 -17
- package/runtime/scripts/hfs/architecture/next-data.mjs +351 -334
- package/runtime/scripts/hfs/architecture/operation-contract-roots.mjs +39 -37
- package/runtime/scripts/hfs/architecture/owners.mjs +97 -98
- package/runtime/scripts/hfs/architecture/package-shape.mjs +56 -55
- package/runtime/scripts/hfs/architecture/presentation.mjs +138 -130
- package/runtime/scripts/hfs/architecture/reachability.mjs +258 -241
- package/runtime/scripts/hfs/architecture/register-once.mjs +152 -139
- package/runtime/scripts/hfs/architecture/registration.mjs +301 -267
- package/runtime/scripts/hfs/architecture/required-files.mjs +172 -167
- package/runtime/scripts/hfs/architecture/route-files-thin.mjs +85 -77
- package/runtime/scripts/hfs/architecture/schema-owner.mjs +206 -181
- package/runtime/scripts/hfs/architecture/server-action.mjs +48 -48
- package/runtime/scripts/hfs/architecture/side-boundary.mjs +2 -5
- package/runtime/scripts/hfs/architecture/source-names-shape.mjs +261 -259
- package/runtime/scripts/hfs/architecture/source-names.mjs +304 -278
- package/runtime/scripts/hfs/architecture/sql-keys.mjs +277 -194
- package/runtime/scripts/hfs/architecture/sql-owner.mjs +236 -194
- package/runtime/scripts/hfs/architecture/sql-returning.mjs +46 -45
- package/runtime/scripts/hfs/architecture/sql-token-forms.mjs +86 -74
- package/runtime/scripts/hfs/architecture/sql-tokens.mjs +456 -341
- package/runtime/scripts/hfs/architecture/staged-consumers.mjs +35 -30
- package/runtime/scripts/hfs/architecture/surface.mjs +64 -74
- package/runtime/scripts/hfs/architecture/symbols.mjs +209 -216
- package/runtime/scripts/hfs/architecture/test-world-files.mjs +165 -155
- package/runtime/scripts/hfs/architecture/tiers.mjs +161 -154
- package/runtime/scripts/hfs/architecture/transport-owner.mjs +155 -149
- package/runtime/scripts/hfs/architecture/type-context.mjs +255 -250
- package/runtime/scripts/hfs/architecture/typescript.mjs +358 -318
- package/runtime/scripts/hfs/architecture/unit-spec-providers.mjs +110 -92
- package/runtime/scripts/hfs/declaration-shape.mjs +140 -103
- package/runtime/scripts/hfs/declaration-slots.mjs +64 -61
- package/runtime/scripts/hfs/edition-slots.mjs +43 -40
- package/runtime/scripts/hfs/linear-text.mjs +20 -20
- package/runtime/scripts/hfs/param-names.mjs +6 -11
- package/runtime/scripts/hfs/path-findings.mjs +120 -100
- package/runtime/scripts/hfs/repo-identity.mjs +55 -42
- package/runtime/scripts/hfs/rule-catalog.mjs +353 -257
- package/runtime/scripts/hfs/rule-params-shape.mjs +60 -47
- package/runtime/scripts/hfs/rules/database-migrations.mjs +428 -388
- package/runtime/scripts/hfs/rules/fe-no-tests.mjs +37 -36
- package/runtime/scripts/hfs/rules/read.mjs +19 -15
- package/runtime/scripts/hfs/rules/secrets.mjs +1 -1
- package/runtime/scripts/hfs/rules/spec-placement.mjs +12 -13
- package/runtime/scripts/hfs/slot-app-view.mjs +69 -74
- package/runtime/scripts/hfs/slot-classify.mjs +42 -38
- package/runtime/scripts/hfs/slot-errors.mjs +8 -7
- package/runtime/scripts/hfs/slot-imports.mjs +70 -63
- package/runtime/scripts/hfs/slot-manifest-shape.mjs +74 -52
- package/runtime/scripts/hfs/slot-match.mjs +122 -111
- package/runtime/scripts/hfs/slot-path.mjs +0 -2
- package/runtime/scripts/hfs/slot-required.mjs +65 -59
- package/runtime/scripts/hfs/slot-semantic-problems.mjs +138 -112
- package/runtime/scripts/hfs/slot-side-problems.mjs +23 -19
- package/runtime/scripts/hfs/slots.mjs +175 -152
- package/runtime/scripts/hfs/test-world-slot.mjs +0 -1
- package/runtime/scripts/hfs/trailing-slashes.mjs +4 -4
- package/runtime/scripts/hfs/typescript-programs.mjs +66 -69
- package/runtime/scripts/hfs/view.mjs +38 -40
- package/runtime/scripts/lib/dockerfile.mjs +131 -114
- package/runtime/scripts/lib/env.mjs +3 -6
- package/runtime/scripts/lib/event-contract.mjs +73 -78
- package/runtime/scripts/lib/git.mjs +15 -16
- package/runtime/scripts/lib/glob.mjs +23 -14
- package/runtime/scripts/lib/grammar-lint.mjs +33 -37
- package/runtime/scripts/lib/i18n.mjs +32 -35
- package/runtime/scripts/lib/in-order.mjs +57 -38
- package/runtime/scripts/lib/json-clone.mjs +45 -36
- package/runtime/scripts/lib/json.mjs +26 -14
- package/runtime/scripts/lib/language.mjs +133 -129
- package/runtime/scripts/lib/list.mjs +9 -14
- package/runtime/scripts/lib/mutation-fence.mjs +10 -5
- package/runtime/scripts/lib/path-key.mjs +53 -38
- package/runtime/scripts/lib/read-text.mjs +30 -17
- package/runtime/scripts/lib/regex.mjs +1 -2
- package/runtime/scripts/lib/same-text.mjs +0 -1
- package/runtime/scripts/lib/sops-envelope.mjs +148 -120
- package/runtime/scripts/lib/stack-services.mjs +128 -129
- package/runtime/scripts/lib/ts-analysis.mjs +28 -26
- package/runtime/scripts/lib/ts-ast.mjs +36 -42
- package/runtime/scripts/lib/walk.mjs +33 -27
- package/runtime/scripts/lib/yaml-cached.mjs +4 -4
|
@@ -11,398 +11,415 @@ import { inferredFetcher, inferredIdentities, inferredKeyBindings } from './next
|
|
|
11
11
|
export const SWR_KEY_RULE_ID = 'FE_SWR_KEY_IDENTITY';
|
|
12
12
|
export const SWR_MUTATION_RULE_ID = 'FE_SWR_MUTATION_RESOURCE_IDENTITY';
|
|
13
13
|
export const SWR_DATA_RULE_IDS = [SWR_KEY_RULE_ID, SWR_MUTATION_RULE_ID];
|
|
14
|
-
|
|
15
14
|
const SWR_SPECIFIERS = new Set(['swr', 'swr/immutable', 'swr/mutation']);
|
|
16
|
-
|
|
17
15
|
/* null when the expression selects no name at all (the shared default traces the unselected node itself). */
|
|
18
|
-
const valueSymbol = (ts, checker, expression, seen = new Set()) =>
|
|
19
|
-
sharedValueSymbol(ts, checker, expression, seen, { unselected: 'null' });
|
|
20
|
-
|
|
16
|
+
const valueSymbol = (ts, checker, expression, seen = new Set()) => sharedValueSymbol(ts, checker, expression, seen, { unselected: 'null' });
|
|
21
17
|
function declarationsInside(symbol, root) {
|
|
22
|
-
|
|
23
|
-
|
|
18
|
+
const declarations = symbol?.getDeclarations?.() ?? [];
|
|
19
|
+
return declarations.length > 0 && declarations.every(declaration => isInside(root, canonical(declaration.getSourceFile().fileName)));
|
|
24
20
|
}
|
|
25
|
-
|
|
26
21
|
function selectedImportBindings(ts, statement, selected) {
|
|
27
|
-
|
|
28
|
-
|
|
29
|
-
|
|
30
|
-
|
|
31
|
-
|
|
32
|
-
|
|
33
|
-
|
|
34
|
-
|
|
35
|
-
|
|
36
|
-
|
|
22
|
+
if (!ts.isImportDeclaration(statement) || !statement.importClause)
|
|
23
|
+
return 0;
|
|
24
|
+
const clause = statement.importClause;
|
|
25
|
+
let count = clause.name && selected.has('default') ? 1 : 0;
|
|
26
|
+
const bindings = clause.namedBindings;
|
|
27
|
+
if (bindings && ts.isNamespaceImport(bindings))
|
|
28
|
+
count += 1;
|
|
29
|
+
if (bindings && ts.isNamedImports(bindings))
|
|
30
|
+
count += bindings.elements
|
|
31
|
+
.filter(element => selected.has(element.propertyName?.text ?? element.name.text)).length;
|
|
32
|
+
return count;
|
|
33
|
+
}
|
|
37
34
|
function addOfficialExports(official, checker, statement, selected, targets) {
|
|
38
|
-
|
|
39
|
-
|
|
40
|
-
|
|
41
|
-
|
|
42
|
-
|
|
43
|
-
|
|
44
|
-
|
|
45
|
-
|
|
46
|
-
|
|
47
|
-
|
|
48
|
-
|
|
49
|
-
|
|
50
|
-
|
|
35
|
+
const { config, context, installed, reasons } = official;
|
|
36
|
+
const moduleSymbol = checker.getSymbolAtLocation(statement.moduleSpecifier);
|
|
37
|
+
if (!moduleSymbol) {
|
|
38
|
+
reasons.push(`${relativePath(config.root, statement.getSourceFile().fileName)} cannot resolve ${statement.moduleSpecifier.text} through the target TypeScript program`);
|
|
39
|
+
return false;
|
|
40
|
+
}
|
|
41
|
+
const exports = new Map(checker.getExportsOfModule(moduleSymbol).map((symbol) => [symbol.getName(), normalizedSymbolValue(context.ts, checker, symbol)]));
|
|
42
|
+
for (const [name, kind] of selected) {
|
|
43
|
+
const target = exports.get(name);
|
|
44
|
+
if (!target)
|
|
45
|
+
continue;
|
|
46
|
+
if (!declarationsInside(target, installed.root)) {
|
|
47
|
+
reasons.push(`${relativePath(config.root, statement.getSourceFile().fileName)} resolves ${statement.moduleSpecifier.text}#${name} outside installed swr ${installed.version}`);
|
|
48
|
+
continue;
|
|
49
|
+
}
|
|
50
|
+
targets.set(target, kind);
|
|
51
51
|
}
|
|
52
|
-
|
|
53
|
-
}
|
|
54
|
-
return true;
|
|
52
|
+
return true;
|
|
55
53
|
}
|
|
56
|
-
|
|
57
54
|
function addOfficialStatement(official, wanted, checker, statement, targets) {
|
|
58
|
-
|
|
59
|
-
|
|
60
|
-
|
|
61
|
-
|
|
62
|
-
|
|
63
|
-
|
|
64
|
-
|
|
65
|
-
|
|
66
|
-
|
|
55
|
+
const ts = official.context.ts;
|
|
56
|
+
if (!ts.isImportDeclaration(statement) && !ts.isExportDeclaration(statement))
|
|
57
|
+
return 0;
|
|
58
|
+
if (!statement.moduleSpecifier || !ts.isStringLiteralLike(statement.moduleSpecifier))
|
|
59
|
+
return 0;
|
|
60
|
+
const selected = wanted.get(statement.moduleSpecifier.text);
|
|
61
|
+
if (!selected)
|
|
62
|
+
return 0;
|
|
63
|
+
if (!addOfficialExports(official, checker, statement, selected, targets))
|
|
64
|
+
return 0;
|
|
65
|
+
return selectedImportBindings(ts, statement, selected);
|
|
66
|
+
}
|
|
67
67
|
function officialTargets(config, context, installed, reasons) {
|
|
68
|
-
|
|
69
|
-
|
|
70
|
-
|
|
71
|
-
|
|
72
|
-
|
|
73
|
-
|
|
74
|
-
|
|
75
|
-
|
|
76
|
-
|
|
77
|
-
|
|
78
|
-
|
|
79
|
-
|
|
80
|
-
|
|
68
|
+
const wanted = new Map([
|
|
69
|
+
['swr', new Map([['default', 'query'], ['mutate', 'global-mutate'], ['useSWRConfig', 'config']])],
|
|
70
|
+
['swr/immutable', new Map([['default', 'query']])],
|
|
71
|
+
['swr/mutation', new Map([['default', 'mutation'], ['useSWRMutation', 'mutation']])],
|
|
72
|
+
]);
|
|
73
|
+
const targets = new Map();
|
|
74
|
+
const official = { config, context, installed, reasons };
|
|
75
|
+
let selectedBindings = 0;
|
|
76
|
+
for (const source of context.files) {
|
|
77
|
+
const checker = context.checkerFor(source.fileName);
|
|
78
|
+
for (const statement of source.statements)
|
|
79
|
+
selectedBindings += addOfficialStatement(official, wanted, checker, statement, targets);
|
|
80
|
+
}
|
|
81
|
+
return { targets, selectedBindings };
|
|
81
82
|
}
|
|
82
|
-
|
|
83
83
|
function callKind(ts, checker, call, targets, configMutates = new Set()) {
|
|
84
|
-
|
|
85
|
-
|
|
84
|
+
const symbol = valueSymbol(ts, checker, call.expression);
|
|
85
|
+
return configMutates.has(symbol) ? 'global-mutate' : (symbol ? targets.get(symbol) : undefined) ?? null;
|
|
86
86
|
}
|
|
87
|
-
|
|
88
87
|
function bindingNames(ts, name) {
|
|
89
|
-
|
|
90
|
-
|
|
91
|
-
if (
|
|
92
|
-
|
|
93
|
-
|
|
94
|
-
|
|
95
|
-
|
|
96
|
-
|
|
88
|
+
if (ts.isIdentifier(name))
|
|
89
|
+
return [name.text];
|
|
90
|
+
if (ts.isObjectBindingPattern(name) || ts.isArrayBindingPattern(name))
|
|
91
|
+
return name.elements.flatMap(element => {
|
|
92
|
+
if (!element || ts.isOmittedExpression(element))
|
|
93
|
+
return [];
|
|
94
|
+
return bindingNames(ts, element.name);
|
|
95
|
+
});
|
|
96
|
+
return [];
|
|
97
|
+
}
|
|
97
98
|
function resultBindings(ts, call) {
|
|
98
|
-
|
|
99
|
-
|
|
100
|
-
|
|
101
|
-
|
|
102
|
-
|
|
103
|
-
|
|
104
|
-
|
|
105
|
-
|
|
106
|
-
|
|
107
|
-
}
|
|
108
|
-
|
|
99
|
+
let current = call;
|
|
100
|
+
while (current.parent && (ts.isParenthesizedExpression(current.parent) || ts.isAsExpression(current.parent)
|
|
101
|
+
|| ts.isTypeAssertionExpression(current.parent) || ts.isNonNullExpression(current.parent)
|
|
102
|
+
|| (ts.isSatisfiesExpression?.(current.parent) ?? false)
|
|
103
|
+
|| ((ts.isPropertyAccessExpression(current.parent) || ts.isElementAccessExpression(current.parent)) && current.parent.expression === current))) {
|
|
104
|
+
current = current.parent;
|
|
105
|
+
}
|
|
106
|
+
return current.parent && ts.isVariableDeclaration(current.parent) && current.parent.initializer === current
|
|
107
|
+
? bindingNames(ts, current.parent.name) : [];
|
|
108
|
+
}
|
|
109
109
|
function nearestFunction(ts, node) {
|
|
110
|
-
|
|
111
|
-
|
|
112
|
-
|
|
110
|
+
for (let current = node.parent; current; current = current.parent)
|
|
111
|
+
if (ts.isFunctionDeclaration(current)
|
|
112
|
+
|| ts.isFunctionExpression(current) || ts.isArrowFunction(current) || ts.isMethodDeclaration(current))
|
|
113
|
+
return current;
|
|
114
|
+
return null;
|
|
113
115
|
}
|
|
114
|
-
|
|
115
116
|
function configElementProperty(ts, element) {
|
|
116
|
-
|
|
117
|
-
|
|
117
|
+
return element.propertyName && ts.isIdentifier(element.propertyName) ? element.propertyName.text
|
|
118
|
+
: (ts.isIdentifier(element.name) && element.name.text) || null;
|
|
118
119
|
}
|
|
119
|
-
|
|
120
120
|
function addConfigMutateSymbols(ts, checker, node, targets, symbols) {
|
|
121
|
-
|
|
122
|
-
|
|
123
|
-
|
|
124
|
-
|
|
125
|
-
|
|
126
|
-
|
|
127
|
-
|
|
128
|
-
|
|
129
|
-
|
|
130
|
-
|
|
131
|
-
|
|
132
|
-
|
|
133
|
-
const
|
|
134
|
-
const
|
|
135
|
-
|
|
136
|
-
|
|
137
|
-
|
|
138
|
-
|
|
139
|
-
|
|
140
|
-
|
|
121
|
+
if (!(ts.isVariableDeclaration(node) && ts.isObjectBindingPattern(node.name) && node.initializer))
|
|
122
|
+
return;
|
|
123
|
+
const call = unwrapExpression(ts, node.initializer);
|
|
124
|
+
if (!ts.isCallExpression(call) || callKind(ts, checker, call, targets) !== 'config')
|
|
125
|
+
return;
|
|
126
|
+
for (const element of node.name.elements) {
|
|
127
|
+
if (configElementProperty(ts, element) === 'mutate' && ts.isIdentifier(element.name))
|
|
128
|
+
symbols.add(normalizedSymbol(ts, checker, element.name));
|
|
129
|
+
}
|
|
130
|
+
}
|
|
131
|
+
function configMutateSymbols(_config, context, targets) {
|
|
132
|
+
const { ts } = context;
|
|
133
|
+
const symbols = new Set();
|
|
134
|
+
for (const source of context.files) {
|
|
135
|
+
const checker = context.checkerFor(source.fileName);
|
|
136
|
+
const visit = (node) => {
|
|
137
|
+
addConfigMutateSymbols(ts, checker, node, targets, symbols);
|
|
138
|
+
ts.forEachChild(node, visit);
|
|
139
|
+
};
|
|
140
|
+
visit(source);
|
|
141
|
+
}
|
|
142
|
+
return symbols;
|
|
141
143
|
}
|
|
142
|
-
|
|
143
144
|
function discoverCalls(config, context, targets) {
|
|
144
|
-
|
|
145
|
-
|
|
146
|
-
|
|
147
|
-
|
|
148
|
-
|
|
149
|
-
|
|
150
|
-
|
|
151
|
-
|
|
152
|
-
|
|
153
|
-
|
|
154
|
-
|
|
155
|
-
|
|
156
|
-
|
|
157
|
-
|
|
145
|
+
const configMutates = configMutateSymbols(config, context, targets);
|
|
146
|
+
const calls = [];
|
|
147
|
+
for (const source of context.files) {
|
|
148
|
+
const checker = context.checkerFor(source.fileName);
|
|
149
|
+
const visit = (node) => {
|
|
150
|
+
if (context.ts.isCallExpression(node)) {
|
|
151
|
+
const kind = callKind(context.ts, checker, node, targets, configMutates);
|
|
152
|
+
if (kind && kind !== 'config')
|
|
153
|
+
calls.push({ kind, node, source, checker, owner: nearestFunction(context.ts, node), bindings: resultBindings(context.ts, node) });
|
|
154
|
+
}
|
|
155
|
+
context.ts.forEachChild(node, visit);
|
|
156
|
+
};
|
|
157
|
+
visit(source);
|
|
158
|
+
}
|
|
159
|
+
return calls;
|
|
158
160
|
}
|
|
159
|
-
|
|
160
161
|
function exportedHook(config, context, entry, reasons) {
|
|
161
|
-
|
|
162
|
-
|
|
163
|
-
|
|
164
|
-
|
|
165
|
-
|
|
166
|
-
|
|
167
|
-
|
|
168
|
-
|
|
169
|
-
|
|
170
|
-
|
|
171
|
-
|
|
172
|
-
|
|
173
|
-
|
|
174
|
-
|
|
175
|
-
|
|
176
|
-
|
|
162
|
+
const source = context.files.find(candidate => canonical(candidate.fileName) === canonical(path.join(config.root, ...entry.path.split('/'))));
|
|
163
|
+
if (!source) {
|
|
164
|
+
reasons.push(`${entry.path} is outside the canonical production TypeScript program`);
|
|
165
|
+
return null;
|
|
166
|
+
}
|
|
167
|
+
const checker = context.checkerFor(source.fileName);
|
|
168
|
+
const moduleSymbol = checker.getSymbolAtLocation(source);
|
|
169
|
+
const exported = moduleSymbol ? checker.getExportsOfModule(moduleSymbol).find(symbol => symbol.getName() === entry.export) : null;
|
|
170
|
+
const symbol = normalizedSymbolValue(context.ts, checker, exported);
|
|
171
|
+
const declarations = (symbol?.getDeclarations?.() ?? []).filter(declaration => canonical(declaration.getSourceFile().fileName) === canonical(source.fileName));
|
|
172
|
+
const functions = declarations.map(declaration => functionNode(context.ts, declaration)).filter((fn) => fn !== null);
|
|
173
|
+
if (functions.length !== 1) {
|
|
174
|
+
reasons.push(`${entry.path}#${entry.export} does not resolve to one local exported hook implementation`);
|
|
175
|
+
return null;
|
|
176
|
+
}
|
|
177
|
+
return { source, checker, fn: functions[0] };
|
|
177
178
|
}
|
|
178
|
-
|
|
179
179
|
function addBindingName(ts, checker, found, name) {
|
|
180
|
-
|
|
181
|
-
|
|
182
|
-
|
|
183
|
-
|
|
184
|
-
|
|
185
|
-
|
|
186
|
-
|
|
187
|
-
|
|
188
|
-
|
|
189
|
-
|
|
190
|
-
|
|
191
|
-
|
|
180
|
+
if (ts.isIdentifier(name)) {
|
|
181
|
+
const symbol = normalizedSymbol(ts, checker, name);
|
|
182
|
+
if (!symbol)
|
|
183
|
+
return;
|
|
184
|
+
if (!found.has(name.text))
|
|
185
|
+
found.set(name.text, new Set());
|
|
186
|
+
found.get(name.text)?.add(symbol);
|
|
187
|
+
return;
|
|
188
|
+
}
|
|
189
|
+
if (ts.isObjectBindingPattern(name) || ts.isArrayBindingPattern(name))
|
|
190
|
+
for (const element of name.elements) {
|
|
191
|
+
if (element && !ts.isOmittedExpression(element))
|
|
192
|
+
addBindingName(ts, checker, found, element.name);
|
|
193
|
+
}
|
|
194
|
+
}
|
|
192
195
|
function bindingSymbols(ts, checker, fn) {
|
|
193
|
-
|
|
194
|
-
|
|
195
|
-
|
|
196
|
-
|
|
197
|
-
|
|
198
|
-
|
|
199
|
-
|
|
200
|
-
|
|
201
|
-
|
|
202
|
-
}
|
|
203
|
-
|
|
196
|
+
const found = new Map();
|
|
197
|
+
for (const parameter of fn.parameters)
|
|
198
|
+
addBindingName(ts, checker, found, parameter.name);
|
|
199
|
+
const visit = (node) => {
|
|
200
|
+
if (node !== fn && (ts.isFunctionDeclaration(node) || ts.isFunctionExpression(node) || ts.isArrowFunction(node) || ts.isMethodDeclaration(node)))
|
|
201
|
+
return;
|
|
202
|
+
if (ts.isVariableDeclaration(node))
|
|
203
|
+
addBindingName(ts, checker, found, node.name);
|
|
204
|
+
ts.forEachChild(node, visit);
|
|
205
|
+
};
|
|
206
|
+
if (fn.body)
|
|
207
|
+
visit(fn.body);
|
|
208
|
+
return found;
|
|
209
|
+
}
|
|
204
210
|
function resolvedIdentities(ts, checker, fn, entry, reasons) {
|
|
205
|
-
|
|
206
|
-
|
|
207
|
-
|
|
208
|
-
|
|
209
|
-
|
|
210
|
-
|
|
211
|
-
|
|
212
|
-
|
|
211
|
+
const symbols = bindingSymbols(ts, checker, fn);
|
|
212
|
+
const identities = [];
|
|
213
|
+
for (const identity of entry.identities) {
|
|
214
|
+
const parts = identity.binding.split('.');
|
|
215
|
+
const candidates = symbols.get(parts[0]) ?? new Set();
|
|
216
|
+
if (candidates.size !== 1) {
|
|
217
|
+
reasons.push(`${entry.path}#${entry.export} cannot resolve one local binding for identity ${identity.id} (${identity.binding})`);
|
|
218
|
+
continue;
|
|
219
|
+
}
|
|
220
|
+
identities.push({ ...identity, parts, symbol: [...candidates][0] });
|
|
213
221
|
}
|
|
214
|
-
identities.
|
|
215
|
-
}
|
|
216
|
-
return identities.length === entry.identities.length ? identities : null;
|
|
222
|
+
return identities.length === entry.identities.length ? identities : null;
|
|
217
223
|
}
|
|
218
|
-
|
|
219
224
|
function violation(config, call, ruleId, message, extra = {}) {
|
|
220
|
-
|
|
225
|
+
return { ruleId, path: relativePath(config.root, call.source.fileName), ...sourceLocation(call.source, call.node), message, ...extra };
|
|
221
226
|
}
|
|
222
|
-
|
|
223
227
|
const keyInspectorDependencies = { anyDescendant, normalizedSymbol, unwrapExpression, constInitializer, sourceLocation, violation,
|
|
224
|
-
|
|
228
|
+
SWR_KEY_RULE_ID, SWR_MUTATION_RULE_ID };
|
|
225
229
|
const inspectKey = createNextDataKeyInspector(keyInspectorDependencies);
|
|
226
|
-
|
|
227
230
|
const inspectInferredKey = createNextDataKeyInspector({ ...keyInspectorDependencies, normalizedSymbol: inferredSymbol });
|
|
228
|
-
|
|
229
231
|
function isUnshadowedCommonJsRequire(ts, checker, expression, seen = new Set(), depth = 0) {
|
|
230
|
-
|
|
231
|
-
|
|
232
|
-
|
|
233
|
-
|
|
234
|
-
|
|
235
|
-
|
|
236
|
-
|
|
237
|
-
|
|
238
|
-
|
|
239
|
-
|
|
240
|
-
|
|
241
|
-
|
|
232
|
+
expression = unwrapExpression(ts, expression);
|
|
233
|
+
if (!ts.isIdentifier(expression) || depth > 10)
|
|
234
|
+
return false;
|
|
235
|
+
const symbol = checker.getSymbolAtLocation(expression);
|
|
236
|
+
const declarations = symbol?.getDeclarations?.() ?? [];
|
|
237
|
+
if (expression.text === 'require' && (!symbol
|
|
238
|
+
|| declarations.every(declaration => declaration.getSourceFile().isDeclarationFile)))
|
|
239
|
+
return true;
|
|
240
|
+
const normalized = symbolOfRequireAlias(ts, checker, expression);
|
|
241
|
+
if (!normalized || seen.has(normalized))
|
|
242
|
+
return false;
|
|
243
|
+
const initializer = constInitializer(ts, normalized);
|
|
244
|
+
return initializer ? isUnshadowedCommonJsRequire(ts, checker, initializer, new Set(seen).add(normalized), depth + 1) : false;
|
|
245
|
+
}
|
|
242
246
|
function symbolOfRequireAlias(ts, checker, expression) {
|
|
243
|
-
|
|
244
|
-
|
|
247
|
+
const symbol = checker.getSymbolAtLocation(expression);
|
|
248
|
+
return normalizedSymbolValue(ts, checker, symbol);
|
|
245
249
|
}
|
|
246
|
-
|
|
247
250
|
function isSwrModuleDeclaration(ts, node) {
|
|
248
|
-
|
|
249
|
-
|
|
251
|
+
return (ts.isImportDeclaration(node) || ts.isExportDeclaration(node)) && node.moduleSpecifier
|
|
252
|
+
&& ts.isStringLiteralLike(node.moduleSpecifier) && SWR_SPECIFIERS.has(node.moduleSpecifier.text);
|
|
250
253
|
}
|
|
251
|
-
|
|
252
254
|
/** The kind of unsupported SWR binding the node declares, else null. */
|
|
253
255
|
function unsupportedSwrBinding(ts, checker, node) {
|
|
254
|
-
|
|
255
|
-
|
|
256
|
-
|
|
257
|
-
|
|
258
|
-
&&
|
|
259
|
-
|
|
260
|
-
|
|
261
|
-
|
|
262
|
-
|
|
263
|
-
|
|
264
|
-
|
|
256
|
+
if (ts.isImportEqualsDeclaration(node) && ts.isExternalModuleReference(node.moduleReference)
|
|
257
|
+
&& node.moduleReference.expression && ts.isStringLiteralLike(node.moduleReference.expression)
|
|
258
|
+
&& SWR_SPECIFIERS.has(node.moduleReference.expression.text))
|
|
259
|
+
return 'import-equals binding';
|
|
260
|
+
if (ts.isCallExpression(node) && node.arguments.length >= 1 && ts.isStringLiteralLike(node.arguments[0])
|
|
261
|
+
&& SWR_SPECIFIERS.has(node.arguments[0].text)) {
|
|
262
|
+
if (node.expression.kind === ts.SyntaxKind.ImportKeyword)
|
|
263
|
+
return 'dynamic import binding';
|
|
264
|
+
if (isUnshadowedCommonJsRequire(ts, checker, node.expression))
|
|
265
|
+
return 'CommonJS require binding';
|
|
266
|
+
}
|
|
267
|
+
return null;
|
|
268
|
+
}
|
|
265
269
|
function swrReferences(config, context) {
|
|
266
|
-
|
|
267
|
-
|
|
268
|
-
|
|
269
|
-
|
|
270
|
-
|
|
271
|
-
|
|
272
|
-
|
|
273
|
-
|
|
274
|
-
|
|
275
|
-
|
|
276
|
-
|
|
277
|
-
|
|
278
|
-
|
|
279
|
-
|
|
280
|
-
|
|
281
|
-
|
|
282
|
-
|
|
270
|
+
const { ts } = context;
|
|
271
|
+
let found = false;
|
|
272
|
+
const unsupported = [];
|
|
273
|
+
for (const source of context.files) {
|
|
274
|
+
const checker = context.checkerFor(source.fileName);
|
|
275
|
+
const visit = (node) => {
|
|
276
|
+
if (isSwrModuleDeclaration(ts, node))
|
|
277
|
+
found = true;
|
|
278
|
+
const kind = unsupportedSwrBinding(ts, checker, node);
|
|
279
|
+
if (kind) {
|
|
280
|
+
found = true;
|
|
281
|
+
unsupported.push(`${relativePath(config.root, source.fileName)}:${sourceLocation(source, node).line} uses unsupported ${kind} for SWR`);
|
|
282
|
+
}
|
|
283
|
+
ts.forEachChild(node, visit);
|
|
284
|
+
};
|
|
285
|
+
visit(source);
|
|
286
|
+
}
|
|
287
|
+
return { found, unsupported };
|
|
283
288
|
}
|
|
284
|
-
|
|
285
289
|
function unavailableDataLifecycle(ruleIds, details) {
|
|
286
|
-
|
|
290
|
+
return { violations: [], coverage: { status: 'unavailable', ruleIds, details } };
|
|
287
291
|
}
|
|
288
|
-
|
|
289
292
|
function lifecycleCallSets(config, context, installed, reasons) {
|
|
290
|
-
|
|
291
|
-
|
|
292
|
-
|
|
293
|
-
|
|
294
|
-
|
|
295
|
-
|
|
296
|
-
|
|
297
|
-
}
|
|
298
|
-
|
|
293
|
+
const official = officialTargets(config, context, installed, reasons);
|
|
294
|
+
const calls = discoverCalls(config, context, official.targets);
|
|
295
|
+
const lifecycleCalls = calls.filter(call => call.kind === 'query' || call.kind === 'mutation');
|
|
296
|
+
const globalMutates = calls.filter(call => call.kind === 'global-mutate');
|
|
297
|
+
if (official.selectedBindings && lifecycleCalls.length === 0)
|
|
298
|
+
reasons.push('selected SWR hook imports have no statically resolved lifecycle call');
|
|
299
|
+
for (const call of globalMutates)
|
|
300
|
+
reasons.push(`${relativePath(config.root, call.source.fileName)}:${sourceLocation(call.source, call.node).line} uses global mutate; resource matching or filter semantics are not statically declared`);
|
|
301
|
+
return { lifecycleCalls };
|
|
302
|
+
}
|
|
299
303
|
function hookEntries(config, context, contract, reasons) {
|
|
300
|
-
|
|
301
|
-
|
|
302
|
-
|
|
303
|
-
|
|
304
|
-
|
|
305
|
-
|
|
306
|
-
|
|
307
|
-
|
|
308
|
-
|
|
309
|
-
}
|
|
310
|
-
|
|
304
|
+
const hookCache = new Map();
|
|
305
|
+
const entriesByHook = new Map();
|
|
306
|
+
for (const entry of contract.hooks) {
|
|
307
|
+
const key = `${entry.path}\0${entry.export}`;
|
|
308
|
+
if (!entriesByHook.has(key))
|
|
309
|
+
entriesByHook.set(key, []);
|
|
310
|
+
entriesByHook.get(key)?.push(entry);
|
|
311
|
+
if (!hookCache.has(key))
|
|
312
|
+
hookCache.set(key, exportedHook(config, context, entry, reasons));
|
|
313
|
+
}
|
|
314
|
+
return { hookCache, entriesByHook };
|
|
315
|
+
}
|
|
311
316
|
function inspectLifecycleEntry(scope, entry, hookCalls, mapped) {
|
|
312
|
-
|
|
313
|
-
|
|
314
|
-
|
|
315
|
-
|
|
316
|
-
|
|
317
|
-
|
|
318
|
-
|
|
319
|
-
|
|
320
|
-
|
|
321
|
-
|
|
322
|
-
mapped.set(call, (mapped.get(call) ?? 0) + 1);
|
|
323
|
-
if (call.kind !== entry.kind) {
|
|
324
|
-
reasons.push(`${entry.path}#${entry.export} lifecycle ${entry.id} declares ${entry.kind} but resolves ${call.kind}`);
|
|
325
|
-
return;
|
|
326
|
-
}
|
|
327
|
-
const identities = resolvedIdentities(context.ts, hook.checker, hook.fn, entry, reasons);
|
|
328
|
-
if (identities) inspectKey(config, context, entry, call, identities, violations, reasons);
|
|
329
|
-
}
|
|
330
|
-
|
|
331
|
-
function inspectHookLifecycle(config, context, lifecycleCalls, hookCache, entriesByHook, violations, reasons) {
|
|
332
|
-
const mapped = new Map();
|
|
333
|
-
const scope = { config, context, violations, reasons };
|
|
334
|
-
for (const [key, entries] of entriesByHook) {
|
|
335
|
-
const hook = hookCache.get(key);
|
|
336
|
-
if (!hook) continue;
|
|
337
|
-
const owned = lifecycleCalls.filter(call => call.owner === hook.fn);
|
|
338
|
-
if (!owned.length) {
|
|
339
|
-
reasons.push(`${entries[0].path}#${entries[0].export} contains no statically resolved SWR lifecycle call`);
|
|
340
|
-
continue;
|
|
317
|
+
const { config, context, violations, reasons } = scope;
|
|
318
|
+
const { entries, owned, hook } = hookCalls;
|
|
319
|
+
let candidates;
|
|
320
|
+
if (entry.resultBinding !== undefined)
|
|
321
|
+
candidates = owned.filter(call => call.bindings.includes(entry.resultBinding));
|
|
322
|
+
else
|
|
323
|
+
candidates = owned.length === 1 && entries.length === 1 ? owned : [];
|
|
324
|
+
if (candidates.length !== 1) {
|
|
325
|
+
reasons.push(`${entry.path}#${entry.export} lifecycle ${entry.id} must select exactly one SWR call${owned.length > 1 ? ' with resultBinding' : ''}`);
|
|
326
|
+
return;
|
|
341
327
|
}
|
|
342
|
-
|
|
343
|
-
|
|
344
|
-
|
|
328
|
+
const call = candidates[0];
|
|
329
|
+
mapped.set(call, (mapped.get(call) ?? 0) + 1);
|
|
330
|
+
if (call.kind !== entry.kind) {
|
|
331
|
+
reasons.push(`${entry.path}#${entry.export} lifecycle ${entry.id} declares ${entry.kind} but resolves ${call.kind}`);
|
|
332
|
+
return;
|
|
333
|
+
}
|
|
334
|
+
const identities = resolvedIdentities(context.ts, hook.checker, hook.fn, entry, reasons);
|
|
335
|
+
if (identities)
|
|
336
|
+
inspectKey(config, context, entry, call, identities, violations, reasons);
|
|
337
|
+
}
|
|
338
|
+
function inspectHookLifecycle(config, context, lifecycleCalls, hookCache, entriesByHook, violations, reasons) {
|
|
339
|
+
const mapped = new Map();
|
|
340
|
+
const scope = { config, context, violations, reasons };
|
|
341
|
+
for (const [key, entries] of entriesByHook) {
|
|
342
|
+
const hook = hookCache.get(key);
|
|
343
|
+
if (!hook)
|
|
344
|
+
continue;
|
|
345
|
+
const owned = lifecycleCalls.filter(call => call.owner === hook.fn);
|
|
346
|
+
if (!owned.length) {
|
|
347
|
+
reasons.push(`${entries[0].path}#${entries[0].export} contains no statically resolved SWR lifecycle call`);
|
|
348
|
+
continue;
|
|
349
|
+
}
|
|
350
|
+
for (const entry of entries)
|
|
351
|
+
inspectLifecycleEntry(scope, entry, { entries, owned, hook }, mapped);
|
|
352
|
+
for (const call of owned)
|
|
353
|
+
if ((mapped.get(call) ?? 0) !== 1) {
|
|
354
|
+
reasons.push(`${relativePath(config.root, call.source.fileName)}:${sourceLocation(call.source, call.node).line} SWR call is not matched by exactly one declared lifecycle`);
|
|
355
|
+
}
|
|
345
356
|
}
|
|
346
|
-
|
|
347
|
-
return mapped;
|
|
357
|
+
return mapped;
|
|
348
358
|
}
|
|
349
|
-
|
|
350
359
|
function addUndeclaredLifecycleReasons(config, lifecycleCalls, hookCache, reasons) {
|
|
351
|
-
|
|
352
|
-
|
|
353
|
-
|
|
354
|
-
|
|
360
|
+
const declaredFunctions = new Set([...hookCache.values()].filter((item) => item !== null).map(item => item.fn));
|
|
361
|
+
for (const call of lifecycleCalls)
|
|
362
|
+
if (!declaredFunctions.has(call.owner)) {
|
|
363
|
+
reasons.push(`${relativePath(config.root, call.source.fileName)}:${sourceLocation(call.source, call.node).line} SWR call is outside every declared lifecycle hook`);
|
|
364
|
+
}
|
|
355
365
|
}
|
|
356
|
-
|
|
357
366
|
function lifecycleCoverage(ruleIds, contract, installed, calls, details) {
|
|
358
|
-
|
|
359
|
-
|
|
360
|
-
|
|
361
|
-
|
|
367
|
+
return details.length ? { status: 'unavailable', ruleIds, hooks: contract.hooks.length, calls,
|
|
368
|
+
swr: { name: installed.name, version: installed.version, major: installed.major }, details }
|
|
369
|
+
: { status: 'checked', ruleIds, hooks: contract.hooks.length, calls,
|
|
370
|
+
swr: { name: installed.name, version: installed.version, major: installed.major } };
|
|
362
371
|
}
|
|
363
|
-
|
|
364
372
|
function inspectDefaultLifecycle(config, context, installed, lifecycleCalls, violations, reasons) {
|
|
365
|
-
|
|
366
|
-
|
|
367
|
-
|
|
368
|
-
|
|
369
|
-
|
|
373
|
+
for (const call of lifecycleCalls) {
|
|
374
|
+
const fetcher = inferredFetcher(context.ts, call.checker, call.node.arguments[1]);
|
|
375
|
+
if (!fetcher) {
|
|
376
|
+
reasons.push(`${relativePath(config.root, call.source.fileName)}:${sourceLocation(call.source, call.node).line} fetcher inputs cannot be inferred; dataLifecycle is required to declare identities`);
|
|
377
|
+
continue;
|
|
378
|
+
}
|
|
379
|
+
const entry = { id: `swr:${relativePath(config.root, call.source.fileName)}:${sourceLocation(call.source, call.node).line}`,
|
|
380
|
+
path: relativePath(config.root, call.source.fileName), export: call.owner?.name?.text ?? '<inferred hook>', kind: call.kind };
|
|
381
|
+
const identities = inferredIdentities(context, call, fetcher, reasons);
|
|
382
|
+
const selected = new Set(identities.map(identity => identity.id));
|
|
383
|
+
const findings = [];
|
|
384
|
+
inspectInferredKey(config, context, entry, call, [...identities, ...inferredKeyBindings(context, call, reasons)], findings, reasons);
|
|
385
|
+
violations.push(...findings.filter(finding => finding.identity === undefined || selected.has(finding.identity)));
|
|
370
386
|
}
|
|
371
|
-
const
|
|
372
|
-
|
|
373
|
-
|
|
374
|
-
const selected = new Set(identities.map(identity => identity.id));
|
|
375
|
-
const findings = [];
|
|
376
|
-
inspectInferredKey(config, context, entry, call, [...identities, ...inferredKeyBindings(context, call, reasons)], findings, reasons);
|
|
377
|
-
violations.push(...findings.filter(finding => finding.identity === undefined || selected.has(finding.identity)));
|
|
378
|
-
}
|
|
379
|
-
const details = [...new Set(reasons)].sort(byCodeUnit);
|
|
380
|
-
return { violations, coverage: lifecycleCoverage([...SWR_DATA_RULE_IDS], { hooks: lifecycleCalls }, installed, lifecycleCalls.length, details) };
|
|
381
|
-
}
|
|
382
|
-
|
|
387
|
+
const details = [...new Set(reasons)].sort(byCodeUnit);
|
|
388
|
+
return { violations, coverage: lifecycleCoverage([...SWR_DATA_RULE_IDS], { hooks: lifecycleCalls }, installed, lifecycleCalls.length, details) };
|
|
389
|
+
}
|
|
383
390
|
/** Check declared lifecycles, or infer captured request identities when production SWR has no declaration. */
|
|
384
391
|
export function checkFrontendDataLifecycle(config, context) {
|
|
385
|
-
|
|
386
|
-
|
|
387
|
-
|
|
388
|
-
|
|
389
|
-
|
|
390
|
-
|
|
391
|
-
|
|
392
|
-
|
|
393
|
-
|
|
394
|
-
|
|
395
|
-
|
|
396
|
-
|
|
397
|
-
|
|
398
|
-
|
|
399
|
-
|
|
400
|
-
|
|
401
|
-
|
|
402
|
-
|
|
403
|
-
|
|
404
|
-
|
|
405
|
-
|
|
406
|
-
|
|
407
|
-
|
|
392
|
+
const ruleIds = [...SWR_DATA_RULE_IDS];
|
|
393
|
+
const references = swrReferences(config, context);
|
|
394
|
+
let contract;
|
|
395
|
+
try {
|
|
396
|
+
contract = parseContract(config);
|
|
397
|
+
}
|
|
398
|
+
catch (error) {
|
|
399
|
+
return unavailableDataLifecycle(ruleIds, [String(error.message ?? error)]);
|
|
400
|
+
}
|
|
401
|
+
if (!contract && !references.found)
|
|
402
|
+
return { violations: [], coverage: { status: 'not-applicable', ruleIds } };
|
|
403
|
+
const reasons = [];
|
|
404
|
+
const violations = [];
|
|
405
|
+
reasons.push(...references.unsupported);
|
|
406
|
+
if (!contract && references.unsupported.length)
|
|
407
|
+
reasons.push('package.json#starci.codePatterns.next.dataLifecycle is required for unsupported SWR bindings');
|
|
408
|
+
let installed;
|
|
409
|
+
try {
|
|
410
|
+
installed = installedSWR(config.packageRoot ?? config.root);
|
|
411
|
+
}
|
|
412
|
+
catch (error) {
|
|
413
|
+
return { violations, coverage: { status: 'unavailable', ruleIds, details: [String(error.message ?? error)] } };
|
|
414
|
+
}
|
|
415
|
+
if (contract && installed.major !== contract.swr.major)
|
|
416
|
+
reasons.push(`installed swr ${installed.version} does not match declared major ${contract.swr.major}`);
|
|
417
|
+
const { lifecycleCalls } = lifecycleCallSets(config, context, installed, reasons);
|
|
418
|
+
if (!contract)
|
|
419
|
+
return inspectDefaultLifecycle(config, context, installed, lifecycleCalls, violations, reasons);
|
|
420
|
+
const { hookCache, entriesByHook } = hookEntries(config, context, contract, reasons);
|
|
421
|
+
inspectHookLifecycle(config, context, lifecycleCalls, hookCache, entriesByHook, violations, reasons);
|
|
422
|
+
addUndeclaredLifecycleReasons(config, lifecycleCalls, hookCache, reasons);
|
|
423
|
+
const details = [...new Set(reasons)].sort(byCodeUnit);
|
|
424
|
+
return { violations, coverage: lifecycleCoverage(ruleIds, contract, installed, lifecycleCalls.length, details) };
|
|
408
425
|
}
|