@starci/eslint-canon-be 3.8.20 → 3.9.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 +8 -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
|
@@ -1,143 +1,176 @@
|
|
|
1
|
-
/** Imported JSX components receive repeated data contracts; executable prop values remain compared. */
|
|
2
1
|
import { unwrapExpression as unwrap } from '../../lib/ts-analysis.mjs';
|
|
3
|
-
|
|
4
2
|
const TRANSLATION_MODULES = new Set(['next-intl', 'next-intl/server']);
|
|
5
3
|
const TRANSLATION_FACTORIES = new Set(['useTranslations', 'getTranslations']);
|
|
6
4
|
const uppercase = (name) => /^[A-Z]/.test(name);
|
|
7
|
-
|
|
8
5
|
function bindName(ts, scope, name, binding) {
|
|
9
|
-
|
|
10
|
-
|
|
11
|
-
|
|
12
|
-
|
|
6
|
+
if (ts.isIdentifier(name))
|
|
7
|
+
scope.bindings.set(name.text, binding);
|
|
8
|
+
else if (ts.isObjectBindingPattern(name) || ts.isArrayBindingPattern(name)) {
|
|
9
|
+
for (const element of name.elements)
|
|
10
|
+
if (ts.isBindingElement(element))
|
|
11
|
+
bindName(ts, scope, element.name, binding);
|
|
12
|
+
}
|
|
13
13
|
}
|
|
14
|
-
|
|
15
14
|
function importBindings(ts, scope, statement) {
|
|
16
|
-
|
|
17
|
-
|
|
18
|
-
|
|
19
|
-
|
|
20
|
-
|
|
21
|
-
|
|
22
|
-
|
|
23
|
-
|
|
24
|
-
|
|
25
|
-
|
|
26
|
-
|
|
27
|
-
|
|
28
|
-
|
|
15
|
+
const clause = statement.importClause;
|
|
16
|
+
if (!clause || clause.isTypeOnly || !ts.isStringLiteral(statement.moduleSpecifier))
|
|
17
|
+
return;
|
|
18
|
+
const module = statement.moduleSpecifier.text;
|
|
19
|
+
if (clause.name)
|
|
20
|
+
scope.bindings.set(clause.name.text, { kind: 'component' });
|
|
21
|
+
const named = clause.namedBindings;
|
|
22
|
+
if (!named)
|
|
23
|
+
return;
|
|
24
|
+
if (ts.isNamespaceImport(named))
|
|
25
|
+
scope.bindings.set(named.name.text, { kind: 'namespace', module });
|
|
26
|
+
else
|
|
27
|
+
for (const element of named.elements) {
|
|
28
|
+
if (element.isTypeOnly)
|
|
29
|
+
continue;
|
|
30
|
+
const imported = element.propertyName?.text ?? element.name.text;
|
|
31
|
+
const kind = TRANSLATION_MODULES.has(module) && TRANSLATION_FACTORIES.has(imported) ? 'translation-factory' : 'component';
|
|
32
|
+
scope.bindings.set(element.name.text, { kind });
|
|
33
|
+
}
|
|
29
34
|
}
|
|
30
|
-
|
|
31
35
|
function lexicalBindings(ts, sourceFile) {
|
|
32
|
-
|
|
33
|
-
|
|
34
|
-
|
|
35
|
-
|
|
36
|
-
|
|
37
|
-
|
|
38
|
-
|
|
39
|
-
|
|
40
|
-
|
|
41
|
-
|
|
42
|
-
|
|
43
|
-
|
|
44
|
-
|
|
45
|
-
|
|
46
|
-
|
|
47
|
-
|
|
48
|
-
|
|
49
|
-
|
|
50
|
-
|
|
51
|
-
|
|
52
|
-
|
|
53
|
-
|
|
54
|
-
|
|
55
|
-
|
|
56
|
-
|
|
57
|
-
|
|
58
|
-
return
|
|
59
|
-
|
|
36
|
+
const scopes = new WeakMap();
|
|
37
|
+
const root = { parent: null, bindings: new Map(), functionScope: null };
|
|
38
|
+
root.functionScope = root;
|
|
39
|
+
const visit = (node, outer) => {
|
|
40
|
+
if ((ts.isFunctionDeclaration(node) || ts.isClassDeclaration(node)) && node.name)
|
|
41
|
+
bindName(ts, outer, node.name, { kind: 'local' });
|
|
42
|
+
const functionScope = ts.isFunctionLike(node);
|
|
43
|
+
const nested = functionScope || ts.isBlock(node) || ts.isCatchClause(node) || ts.isClassExpression(node)
|
|
44
|
+
|| ts.isForStatement(node) || ts.isForOfStatement(node) || ts.isForInStatement(node);
|
|
45
|
+
const scope = nested ? { parent: outer, bindings: new Map(), functionScope: functionScope ? null : outer.functionScope } : outer;
|
|
46
|
+
if (functionScope)
|
|
47
|
+
scope.functionScope = scope;
|
|
48
|
+
scopes.set(node, scope);
|
|
49
|
+
if (ts.isImportDeclaration(node))
|
|
50
|
+
importBindings(ts, scope, node);
|
|
51
|
+
if (ts.isParameter(node))
|
|
52
|
+
bindName(ts, scope, node.name, { kind: 'local' });
|
|
53
|
+
if (ts.isFunctionExpression(node) && node.name)
|
|
54
|
+
bindName(ts, scope, node.name, { kind: 'local' });
|
|
55
|
+
if (ts.isVariableDeclaration(node)) {
|
|
56
|
+
const flags = node.parent?.flags ?? ts.NodeFlags.Const;
|
|
57
|
+
bindName(ts, flags & ts.NodeFlags.BlockScoped ? scope : scope.functionScope, node.name, { kind: flags & ts.NodeFlags.Const ? 'constant' : 'local', declaration: node });
|
|
58
|
+
}
|
|
59
|
+
ts.forEachChild(node, (child) => { visit(child, scope); });
|
|
60
|
+
};
|
|
61
|
+
visit(sourceFile, root);
|
|
62
|
+
return (identifier) => {
|
|
63
|
+
for (let scope = scopes.get(identifier); scope; scope = scope.parent) {
|
|
64
|
+
if (scope.bindings.has(identifier.text))
|
|
65
|
+
return scope.bindings.get(identifier.text);
|
|
66
|
+
}
|
|
67
|
+
return null;
|
|
68
|
+
};
|
|
60
69
|
}
|
|
61
|
-
|
|
62
70
|
function translationFactory(ts, node, bindingOf) {
|
|
63
|
-
|
|
64
|
-
|
|
65
|
-
|
|
66
|
-
|
|
67
|
-
|
|
71
|
+
node = unwrap(ts, node);
|
|
72
|
+
if (ts.isIdentifier(node))
|
|
73
|
+
return bindingOf(node)?.kind === 'translation-factory';
|
|
74
|
+
if (!(ts.isPropertyAccessExpression(node) && ts.isIdentifier(node.expression) && TRANSLATION_FACTORIES.has(node.name.text)))
|
|
75
|
+
return false;
|
|
76
|
+
const namespace = bindingOf(node.expression);
|
|
77
|
+
return namespace?.kind === 'namespace' && TRANSLATION_MODULES.has(namespace.module);
|
|
68
78
|
}
|
|
69
|
-
|
|
70
79
|
function translator(ts, node, bindingOf) {
|
|
71
|
-
|
|
72
|
-
|
|
73
|
-
|
|
74
|
-
|
|
75
|
-
|
|
76
|
-
|
|
80
|
+
if (!ts.isIdentifier(node))
|
|
81
|
+
return false;
|
|
82
|
+
const binding = bindingOf(node);
|
|
83
|
+
if (binding?.kind !== 'constant')
|
|
84
|
+
return false;
|
|
85
|
+
let initializer = unwrap(ts, binding.declaration.initializer);
|
|
86
|
+
if (initializer && ts.isAwaitExpression(initializer))
|
|
87
|
+
initializer = unwrap(ts, initializer.expression);
|
|
88
|
+
return Boolean(initializer && ts.isCallExpression(initializer) && translationFactory(ts, initializer.expression, bindingOf));
|
|
77
89
|
}
|
|
78
|
-
|
|
79
90
|
function importedComponent(ts, tag, bindingOf) {
|
|
80
|
-
|
|
81
|
-
|
|
82
|
-
|
|
83
|
-
|
|
84
|
-
|
|
91
|
+
if (ts.isIdentifier(tag))
|
|
92
|
+
return uppercase(tag.text) && bindingOf(tag)?.kind === 'component';
|
|
93
|
+
if (!ts.isPropertyAccessExpression(tag) || !uppercase(tag.name.text))
|
|
94
|
+
return false;
|
|
95
|
+
let root = tag.expression;
|
|
96
|
+
while (ts.isPropertyAccessExpression(root))
|
|
97
|
+
root = root.expression;
|
|
98
|
+
return ts.isIdentifier(root) && bindingOf(root)?.kind === 'namespace';
|
|
85
99
|
}
|
|
86
|
-
|
|
87
100
|
function dataProperty(ts, property, mapping) {
|
|
88
|
-
|
|
89
|
-
|
|
90
|
-
|
|
91
|
-
|
|
101
|
+
if (ts.isSpreadAssignment(property))
|
|
102
|
+
return mapping(property.expression);
|
|
103
|
+
if (ts.isShorthandPropertyAssignment(property))
|
|
104
|
+
return !property.objectAssignmentInitializer;
|
|
105
|
+
if (!ts.isPropertyAssignment(property))
|
|
106
|
+
return false;
|
|
107
|
+
return (!ts.isComputedPropertyName(property.name) || mapping(property.name.expression)) && mapping(property.initializer);
|
|
92
108
|
}
|
|
93
|
-
|
|
94
109
|
function dataMapping(ts, expression, bindingOf) {
|
|
95
|
-
|
|
96
|
-
|
|
97
|
-
|
|
98
|
-
|
|
99
|
-
|
|
100
|
-
|
|
101
|
-
|
|
102
|
-
|
|
103
|
-
|
|
104
|
-
|
|
105
|
-
|
|
106
|
-
|
|
107
|
-
|
|
108
|
-
|
|
110
|
+
const node = unwrap(ts, expression);
|
|
111
|
+
if (!node)
|
|
112
|
+
return false;
|
|
113
|
+
const mapping = (value) => dataMapping(ts, value, bindingOf);
|
|
114
|
+
if (ts.isIdentifier(node) || ts.isLiteralExpression(node) || node.kind === ts.SyntaxKind.TrueKeyword
|
|
115
|
+
|| node.kind === ts.SyntaxKind.FalseKeyword || node.kind === ts.SyntaxKind.NullKeyword || node.kind === ts.SyntaxKind.ThisKeyword)
|
|
116
|
+
return true;
|
|
117
|
+
if (ts.isPropertyAccessExpression(node))
|
|
118
|
+
return mapping(node.expression);
|
|
119
|
+
if (ts.isElementAccessExpression(node))
|
|
120
|
+
return mapping(node.expression) && mapping(node.argumentExpression);
|
|
121
|
+
if (ts.isObjectLiteralExpression(node))
|
|
122
|
+
return node.properties.every((property) => dataProperty(ts, property, mapping));
|
|
123
|
+
if (ts.isArrayLiteralExpression(node))
|
|
124
|
+
return node.elements.every((element) => ts.isOmittedExpression(element)
|
|
125
|
+
|| mapping(ts.isSpreadElement(element) ? element.expression : element));
|
|
126
|
+
if (ts.isTemplateExpression(node))
|
|
127
|
+
return node.templateSpans.every((span) => mapping(span.expression));
|
|
128
|
+
if (ts.isPrefixUnaryExpression(node))
|
|
129
|
+
return [ts.SyntaxKind.PlusToken, ts.SyntaxKind.MinusToken].includes(node.operator)
|
|
130
|
+
&& ts.isNumericLiteral(node.operand);
|
|
131
|
+
return ts.isCallExpression(node) && translator(ts, node.expression, bindingOf) && node.arguments.every(mapping);
|
|
109
132
|
}
|
|
110
|
-
|
|
111
133
|
/** Only object/array values belong to the prop contract; do not descend into a call or function body. */
|
|
112
134
|
function nestedDataObjects(ts, expression, bindingOf, excluded) {
|
|
113
|
-
|
|
114
|
-
|
|
115
|
-
|
|
116
|
-
if (
|
|
117
|
-
|
|
118
|
-
|
|
135
|
+
const node = unwrap(ts, expression);
|
|
136
|
+
if (!node)
|
|
137
|
+
return;
|
|
138
|
+
if (ts.isObjectLiteralExpression(node)) {
|
|
139
|
+
if (dataMapping(ts, node, bindingOf)) {
|
|
140
|
+
excluded.add(node);
|
|
141
|
+
return;
|
|
142
|
+
}
|
|
143
|
+
for (const property of node.properties)
|
|
144
|
+
if (ts.isPropertyAssignment(property)) {
|
|
145
|
+
nestedDataObjects(ts, property.initializer, bindingOf, excluded);
|
|
146
|
+
}
|
|
147
|
+
}
|
|
148
|
+
else if (ts.isArrayLiteralExpression(node)) {
|
|
149
|
+
for (const element of node.elements)
|
|
150
|
+
if (!ts.isSpreadElement(element))
|
|
151
|
+
nestedDataObjects(ts, element, bindingOf, excluded);
|
|
119
152
|
}
|
|
120
|
-
} else if (ts.isArrayLiteralExpression(node)) {
|
|
121
|
-
for (const element of node.elements) if (!ts.isSpreadElement(element)) nestedDataObjects(ts, element, bindingOf, excluded);
|
|
122
|
-
}
|
|
123
153
|
}
|
|
124
|
-
|
|
125
154
|
/** Canon data prop objects qualify through an imported component binding, never its chosen name or file path. */
|
|
126
155
|
export function canonJsxCloneNodes(ts, sourceFile) {
|
|
127
|
-
|
|
128
|
-
|
|
129
|
-
|
|
130
|
-
|
|
131
|
-
|
|
132
|
-
|
|
133
|
-
|
|
134
|
-
|
|
135
|
-
|
|
136
|
-
|
|
137
|
-
|
|
138
|
-
|
|
139
|
-
|
|
140
|
-
|
|
141
|
-
|
|
142
|
-
|
|
156
|
+
const bindingOf = lexicalBindings(ts, sourceFile);
|
|
157
|
+
const excluded = new Set();
|
|
158
|
+
const visit = (node) => {
|
|
159
|
+
if ((ts.isJsxOpeningElement(node) || ts.isJsxSelfClosingElement(node)) && importedComponent(ts, node.tagName, bindingOf)) {
|
|
160
|
+
for (const attribute of node.attributes.properties) {
|
|
161
|
+
if (!ts.isJsxAttribute(attribute) || !attribute.initializer || !ts.isJsxExpression(attribute.initializer))
|
|
162
|
+
continue;
|
|
163
|
+
const value = unwrap(ts, attribute.initializer.expression);
|
|
164
|
+
if (!value || !ts.isObjectLiteralExpression(value))
|
|
165
|
+
continue;
|
|
166
|
+
if (dataMapping(ts, value, bindingOf))
|
|
167
|
+
excluded.add(attribute);
|
|
168
|
+
else
|
|
169
|
+
nestedDataObjects(ts, value, bindingOf, excluded);
|
|
170
|
+
}
|
|
171
|
+
}
|
|
172
|
+
ts.forEachChild(node, visit);
|
|
173
|
+
};
|
|
174
|
+
visit(sourceFile);
|
|
175
|
+
return excluded;
|
|
143
176
|
}
|
|
@@ -1,6 +1,5 @@
|
|
|
1
1
|
import { builtinModules } from 'node:module';
|
|
2
2
|
import { sourceLocation } from '../../lib/ts-ast.mjs';
|
|
3
|
-
|
|
4
3
|
/**
|
|
5
4
|
* R55 `client-reaches-server` (FE_CLIENT_REACHES_SERVER), the repository half of the eslint rule `client-no-server-import`,
|
|
6
5
|
* which sees one hop from a file that carries the directive. The machine walks the resolved import graph from every module
|
|
@@ -15,84 +14,89 @@ import { sourceLocation } from '../../lib/ts-ast.mjs';
|
|
|
15
14
|
* `type`, and `export type` re-exports are skipped.
|
|
16
15
|
*/
|
|
17
16
|
export const CLIENT_REACHES_SERVER_RULE_IDS = ['FE_CLIENT_REACHES_SERVER'];
|
|
18
|
-
|
|
19
17
|
const RULE = 'FE_CLIENT_REACHES_SERVER';
|
|
20
18
|
const SERVER_MODULES = new Set(['server-only', 'next/headers', 'next/server', 'next-intl/server']);
|
|
21
19
|
const NODE_BUILTINS = new Set(builtinModules.map(name => name.replace(/^node:/u, '').split('/')[0]));
|
|
22
|
-
|
|
23
|
-
const isServerSpecifier = specifier => SERVER_MODULES.has(specifier) || specifier.startsWith('node:') || NODE_BUILTINS.has(specifier.split('/')[0]);
|
|
20
|
+
const isServerSpecifier = (specifier) => SERVER_MODULES.has(specifier) || specifier.startsWith('node:') || NODE_BUILTINS.has(specifier.split('/')[0]);
|
|
24
21
|
const isClientEntry = (ts, file) => {
|
|
25
|
-
|
|
26
|
-
|
|
27
|
-
|
|
28
|
-
|
|
29
|
-
|
|
22
|
+
for (const statement of file.sourceFile.statements) {
|
|
23
|
+
if (!ts.isExpressionStatement(statement) || !ts.isStringLiteral(statement.expression))
|
|
24
|
+
return false;
|
|
25
|
+
if (statement.expression.text === 'use client')
|
|
26
|
+
return true;
|
|
27
|
+
}
|
|
28
|
+
return false;
|
|
30
29
|
};
|
|
31
|
-
|
|
32
30
|
const reachesBundle = (ts, declaration) => {
|
|
33
|
-
|
|
34
|
-
|
|
35
|
-
|
|
36
|
-
|
|
37
|
-
|
|
38
|
-
|
|
39
|
-
|
|
31
|
+
if (ts.isImportDeclaration(declaration)) {
|
|
32
|
+
const clause = declaration.importClause;
|
|
33
|
+
if (!clause)
|
|
34
|
+
return true;
|
|
35
|
+
if (clause.isTypeOnly)
|
|
36
|
+
return false;
|
|
37
|
+
if (!clause.name && clause.namedBindings && ts.isNamedImports(clause.namedBindings)) {
|
|
38
|
+
const elements = clause.namedBindings.elements;
|
|
39
|
+
return elements.length === 0 || !elements.every(element => element.isTypeOnly);
|
|
40
|
+
}
|
|
41
|
+
return true;
|
|
40
42
|
}
|
|
41
|
-
return
|
|
42
|
-
}
|
|
43
|
-
return !declaration.isTypeOnly;
|
|
43
|
+
return !declaration.isTypeOnly;
|
|
44
44
|
};
|
|
45
|
-
|
|
46
45
|
const serverImports = (ts, file) => {
|
|
47
|
-
|
|
48
|
-
|
|
49
|
-
|
|
50
|
-
|
|
51
|
-
|
|
52
|
-
|
|
53
|
-
|
|
54
|
-
|
|
55
|
-
|
|
56
|
-
|
|
46
|
+
const found = [];
|
|
47
|
+
const visit = (node) => {
|
|
48
|
+
let specifier = null;
|
|
49
|
+
if ((ts.isImportDeclaration(node) || ts.isExportDeclaration(node)) && node.moduleSpecifier && reachesBundle(ts, node))
|
|
50
|
+
specifier = node.moduleSpecifier;
|
|
51
|
+
else if (ts.isCallExpression(node) && (node.expression.kind === ts.SyntaxKind.ImportKeyword || (ts.isIdentifier(node.expression) && node.expression.text === 'require')))
|
|
52
|
+
specifier = node.arguments[0];
|
|
53
|
+
if (specifier && ts.isStringLiteralLike(specifier) && isServerSpecifier(specifier.text))
|
|
54
|
+
found.push({ specifier: specifier.text, node });
|
|
55
|
+
ts.forEachChild(node, visit);
|
|
56
|
+
};
|
|
57
|
+
visit(file.sourceFile);
|
|
58
|
+
return found;
|
|
57
59
|
};
|
|
58
|
-
|
|
59
|
-
const
|
|
60
|
-
|
|
61
|
-
|
|
62
|
-
|
|
63
|
-
|
|
64
|
-
|
|
65
|
-
|
|
66
|
-
|
|
67
|
-
|
|
68
|
-
|
|
69
|
-
|
|
70
|
-
|
|
71
|
-
|
|
72
|
-
|
|
73
|
-
|
|
74
|
-
|
|
60
|
+
const scanClientEntry = (entry, { graph, runtime, violations }) => {
|
|
61
|
+
const seen = new Map([[entry.rel, { chain: [entry.rel], first: null }]]);
|
|
62
|
+
const queue = [entry.rel];
|
|
63
|
+
for (const rel of queue) {
|
|
64
|
+
const state = seen.get(rel); // every queued module was recorded in `seen` when it was queued
|
|
65
|
+
for (const hit of runtime.serverOf(rel)) {
|
|
66
|
+
const at = state.first ?? sourceLocation(graph.files.get(rel).sourceFile, hit.node);
|
|
67
|
+
violations.push({
|
|
68
|
+
ruleId: RULE, path: entry.rel, line: at.line, column: at.column, clientEntry: entry.rel, importer: rel, specifier: hit.specifier, dependencyChain: state.chain,
|
|
69
|
+
message: `${entry.rel} is a client module ("use client") and reaches ${hit.specifier} through ${[...state.chain, hit.specifier].join(' -> ')}; a server-only surface never enters the client bundle. Read on the server and pass the value down, or move the import out of the client graph.`,
|
|
70
|
+
});
|
|
71
|
+
}
|
|
72
|
+
for (const edge of runtime.edges.get(rel) ?? []) {
|
|
73
|
+
if (seen.has(edge.to))
|
|
74
|
+
continue;
|
|
75
|
+
seen.set(edge.to, { chain: [...state.chain, edge.to], first: state.first ?? { line: edge.line, column: edge.column } });
|
|
76
|
+
queue.push(edge.to);
|
|
77
|
+
}
|
|
75
78
|
}
|
|
76
|
-
}
|
|
77
79
|
};
|
|
78
|
-
|
|
79
80
|
export function checkClientReachesServer({ graph, context }) {
|
|
80
|
-
|
|
81
|
-
|
|
82
|
-
|
|
83
|
-
|
|
84
|
-
|
|
85
|
-
|
|
86
|
-
|
|
87
|
-
|
|
88
|
-
|
|
89
|
-
|
|
90
|
-
|
|
91
|
-
|
|
92
|
-
|
|
93
|
-
|
|
94
|
-
|
|
95
|
-
|
|
96
|
-
|
|
97
|
-
|
|
81
|
+
const ts = context.ts;
|
|
82
|
+
const runtime = new Map();
|
|
83
|
+
for (const edge of graph.edges) {
|
|
84
|
+
if (!edge.runtime)
|
|
85
|
+
continue;
|
|
86
|
+
if (!runtime.has(edge.from))
|
|
87
|
+
runtime.set(edge.from, []);
|
|
88
|
+
runtime.get(edge.from)?.push(edge);
|
|
89
|
+
}
|
|
90
|
+
const serverByFile = new Map();
|
|
91
|
+
const serverOf = (rel) => {
|
|
92
|
+
if (!serverByFile.has(rel))
|
|
93
|
+
serverByFile.set(rel, serverImports(ts, graph.files.get(rel)));
|
|
94
|
+
return serverByFile.get(rel);
|
|
95
|
+
};
|
|
96
|
+
const violations = [];
|
|
97
|
+
const entries = [...graph.files.values()].filter(file => isClientEntry(ts, file)).sort((a, b) => a.rel.localeCompare(b.rel));
|
|
98
|
+
const scanRuntime = { ts, graph, edges: runtime, serverOf, violations };
|
|
99
|
+
for (const entry of entries)
|
|
100
|
+
scanClientEntry(entry, { graph, runtime: scanRuntime, violations });
|
|
101
|
+
return { violations, coverage: { status: 'checked', clientEntries: entries.length } };
|
|
98
102
|
}
|