@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
|
@@ -7,465 +7,480 @@ import { hasAnyFlag } from '../../lib/ts-ast.mjs';
|
|
|
7
7
|
import { canonical, checkInjectedClass, checkMessageReadonly, isPublicMember, messageClass } from './contracts-readonly.mjs';
|
|
8
8
|
export const PUBLIC_CONTRACT_RULE_ID = 'BE_PUBLIC_CONTRACT_FORM';
|
|
9
9
|
export { READONLY_BOUNDARY_RULE_ID } from './contracts-readonly.mjs';
|
|
10
|
-
|
|
11
10
|
const FRAMEWORK_EXPORTS = new Map([
|
|
12
|
-
|
|
13
|
-
|
|
14
|
-
|
|
11
|
+
['@nestjs/common', new Set(['Controller', 'Inject', 'Injectable', 'Module'])],
|
|
12
|
+
['@nestjs/cqrs', new Set(['CommandHandler', 'QueryHandler'])],
|
|
13
|
+
['@nestjs/graphql', new Set(['Resolver'])],
|
|
15
14
|
]);
|
|
16
15
|
const NEST_CREATED = new Set(['CommandHandler', 'Controller', 'Injectable', 'QueryHandler', 'Resolver']);
|
|
17
16
|
const MESSAGE_HANDLERS = new Set(['CommandHandler', 'QueryHandler']);
|
|
18
17
|
const NON_API_SOURCE_ROLES = new Set(['config', 'configuration', 'constants', 'main', 'module', 'module-definition', 'providers']);
|
|
19
18
|
const SOURCE_EXTENSION = /\.[cm]?[jt]sx?$/i;
|
|
20
|
-
|
|
19
|
+
/** The checker of a file in the program; every file the contexts hand in belongs to one. */
|
|
20
|
+
const checkerFor = (context, fileName) => context.checkerFor(fileName);
|
|
21
21
|
function frameworkKindForSymbol(symbol, targets) {
|
|
22
|
-
|
|
23
|
-
|
|
24
|
-
|
|
25
|
-
|
|
26
|
-
|
|
27
|
-
|
|
28
|
-
const
|
|
29
|
-
|
|
30
|
-
|
|
31
|
-
|
|
32
|
-
|
|
33
|
-
|
|
22
|
+
const selected = symbol ? targets.get(symbol) : undefined;
|
|
23
|
+
if (selected)
|
|
24
|
+
return selected;
|
|
25
|
+
const name = symbol?.getName?.();
|
|
26
|
+
if (!name)
|
|
27
|
+
return null;
|
|
28
|
+
for (const [packageName, exports] of FRAMEWORK_EXPORTS) {
|
|
29
|
+
if (!exports.has(name))
|
|
30
|
+
continue;
|
|
31
|
+
const marker = `/node_modules/${packageName}/`;
|
|
32
|
+
if ((symbol?.getDeclarations?.() ?? []).some((declaration) => declaration.getSourceFile().fileName.replaceAll('\\', '/').includes(marker)))
|
|
33
|
+
return name;
|
|
34
|
+
}
|
|
35
|
+
return null;
|
|
36
|
+
}
|
|
34
37
|
/* This module's trace through frameworkKindForSymbol (name lookup and node_modules marker) instead of the
|
|
35
38
|
* default symbol->kind map, plus the shorthand/property-assignment descent. */
|
|
36
39
|
const FRAMEWORK_TRACE = {
|
|
37
|
-
|
|
38
|
-
|
|
40
|
+
directOf: (ts, checker, { selected, targets }) => frameworkKindForSymbol(valueSymbol(ts, checker, selected), targets),
|
|
41
|
+
shorthandOf: (_ts, _checker, target, targets) => frameworkKindForSymbol(target, targets),
|
|
39
42
|
};
|
|
40
|
-
|
|
41
43
|
function addFrameworkTargets(config, context, checker, sourceFile, statement, bySymbol, reasons) {
|
|
42
|
-
|
|
43
|
-
|
|
44
|
-
|
|
45
|
-
|
|
46
|
-
|
|
47
|
-
|
|
48
|
-
|
|
49
|
-
const
|
|
50
|
-
|
|
51
|
-
|
|
52
|
-
|
|
53
|
-
|
|
54
|
-
|
|
44
|
+
const bound = moduleExportsOf(context.ts, checker, statement);
|
|
45
|
+
if (!bound || !FRAMEWORK_EXPORTS.has(bound.specifier))
|
|
46
|
+
return;
|
|
47
|
+
if (!bound.symbol) {
|
|
48
|
+
reasons.push(`${relativePath(config.root, sourceFile.fileName)} cannot resolve ${bound.specifier}`);
|
|
49
|
+
return;
|
|
50
|
+
}
|
|
51
|
+
for (const name of referencedExports(context.ts, statement, FRAMEWORK_EXPORTS.get(bound.specifier))) {
|
|
52
|
+
const target = bound.exports.get(name);
|
|
53
|
+
if (target)
|
|
54
|
+
bySymbol.set(target, name);
|
|
55
|
+
else
|
|
56
|
+
reasons.push(`${relativePath(config.root, sourceFile.fileName)} cannot resolve ${name} from ${bound.specifier}`);
|
|
57
|
+
}
|
|
58
|
+
}
|
|
55
59
|
function frameworkTargets(config, context, checker, localFiles) {
|
|
56
|
-
|
|
57
|
-
|
|
58
|
-
|
|
59
|
-
|
|
60
|
-
|
|
61
|
-
for (const
|
|
62
|
-
|
|
63
|
-
|
|
64
|
-
|
|
65
|
-
|
|
66
|
-
}
|
|
67
|
-
|
|
60
|
+
const bySymbol = new Map();
|
|
61
|
+
const reasons = [];
|
|
62
|
+
const files = programSourcesOf(context, checker, localFiles, { root: config.root });
|
|
63
|
+
if (!files)
|
|
64
|
+
return { bySymbol, reasons: ['a TypeScript program checker could not be associated with its source'] };
|
|
65
|
+
for (const sourceFile of files) {
|
|
66
|
+
for (const statement of sourceFile.statements)
|
|
67
|
+
addFrameworkTargets(config, context, checker, sourceFile, statement, bySymbol, reasons);
|
|
68
|
+
commonJsRequireReasons(context.ts, checker, sourceFile, (specifier) => FRAMEWORK_EXPORTS.has(specifier), reasons, relativePath(config.root, sourceFile.fileName), 'binding whose contract role cannot be proved');
|
|
69
|
+
}
|
|
70
|
+
return { bySymbol, reasons };
|
|
71
|
+
}
|
|
68
72
|
function decoratorKind(ts, checker, decorator, targets) {
|
|
69
|
-
|
|
70
|
-
|
|
73
|
+
const selected = selectedNode(ts, decoratorCallee(ts, decorator));
|
|
74
|
+
return selected ? frameworkKindForSymbol(valueSymbol(ts, checker, selected), targets) : null;
|
|
71
75
|
}
|
|
72
|
-
|
|
73
|
-
const constructedDecoratorKind = (ts, checker, decorator, targets) =>
|
|
74
|
-
sharedConstructedDecoratorKind(ts, checker, decorator, targets, FRAMEWORK_TRACE);
|
|
75
|
-
|
|
76
|
+
const constructedDecoratorKind = (ts, checker, decorator, targets) => sharedConstructedDecoratorKind(ts, checker, decorator, targets, FRAMEWORK_TRACE);
|
|
76
77
|
function sourceRole(sourceFile) {
|
|
77
|
-
|
|
78
|
-
|
|
79
|
-
|
|
80
|
-
|
|
81
|
-
|
|
78
|
+
const normalized = sourceFile.fileName.replaceAll('\\', '/');
|
|
79
|
+
const base = path.basename(sourceFile.fileName).replace(SOURCE_EXTENSION, '').toLowerCase();
|
|
80
|
+
const segments = base.split('.');
|
|
81
|
+
const role = segments.length > 1 ? segments.at(-1) : ((base === 'use-case' || base.endsWith('-use-case')) && 'use-case') || null;
|
|
82
|
+
return { base, role, transport: normalized.includes('/transport/') };
|
|
82
83
|
}
|
|
83
|
-
|
|
84
84
|
function isFrameworkHelper(sourceFile, declaration, framework) {
|
|
85
|
-
|
|
86
|
-
|
|
87
|
-
|
|
88
|
-
|
|
89
|
-
|
|
90
|
-
|
|
91
|
-
|
|
92
|
-
|
|
93
|
-
function builtinSymbol(
|
|
94
|
-
|
|
95
|
-
|
|
96
|
-
|
|
97
|
-
&&
|
|
98
|
-
|
|
99
|
-
|
|
85
|
+
const role = sourceRole(sourceFile);
|
|
86
|
+
if (role.transport || NON_API_SOURCE_ROLES.has(role.role ?? '') || NON_API_SOURCE_ROLES.has(role.base))
|
|
87
|
+
return true;
|
|
88
|
+
if (declaration?.name && (declaration.name.text ?? '').endsWith('Module')) {
|
|
89
|
+
return nodeDecorators(framework.ts, declaration).some((decorator) => decoratorKind(framework.ts, framework.checker, decorator, framework.targets) === 'Module');
|
|
90
|
+
}
|
|
91
|
+
return false;
|
|
92
|
+
}
|
|
93
|
+
function builtinSymbol(_ts, symbol, name) {
|
|
94
|
+
if (!symbol || symbol.getName?.() !== name)
|
|
95
|
+
return false;
|
|
96
|
+
const declarations = symbol.getDeclarations?.() ?? [];
|
|
97
|
+
return declarations.length > 0 && declarations.every((declaration) => declaration.getSourceFile().isDeclarationFile
|
|
98
|
+
&& /(?:^|[/\\])lib\.[^/\\]+\.d\.ts$/i.test(declaration.getSourceFile().fileName));
|
|
99
|
+
}
|
|
100
100
|
function typeReferenceStatus(ts, checker, node, seen, depth) {
|
|
101
|
-
|
|
102
|
-
|
|
103
|
-
|
|
104
|
-
|| builtinSymbol(ts, symbol, '
|
|
105
|
-
|
|
106
|
-
|
|
107
|
-
|
|
108
|
-
|
|
109
|
-
|
|
110
|
-
|
|
111
|
-
|
|
112
|
-
|
|
113
|
-
|
|
114
|
-
|
|
115
|
-
|
|
101
|
+
const symbol = normalizedSymbol(ts, checker, node.typeName);
|
|
102
|
+
if (!symbol)
|
|
103
|
+
return 'unavailable';
|
|
104
|
+
if (builtinSymbol(ts, symbol, 'Promise') || builtinSymbol(ts, symbol, 'Readonly') || builtinSymbol(ts, symbol, 'Awaited')
|
|
105
|
+
|| builtinSymbol(ts, symbol, 'Array') || builtinSymbol(ts, symbol, 'ReadonlyArray')) {
|
|
106
|
+
return node.typeArguments?.length === 1 ? contractTypeStatus(ts, checker, node.typeArguments[0], seen, depth + 1) : 'unavailable';
|
|
107
|
+
}
|
|
108
|
+
if (builtinSymbol(ts, symbol, 'Record') || builtinSymbol(ts, symbol, 'Partial') || builtinSymbol(ts, symbol, 'Pick')
|
|
109
|
+
|| builtinSymbol(ts, symbol, 'Omit') || builtinSymbol(ts, symbol, 'Required'))
|
|
110
|
+
return 'inline';
|
|
111
|
+
const declarations = symbol.getDeclarations?.() ?? [];
|
|
112
|
+
if (!declarations.length)
|
|
113
|
+
return 'unavailable';
|
|
114
|
+
return declarations.every((declaration) => ts.isTypeParameterDeclaration(declaration)
|
|
115
|
+
|| ts.isInterfaceDeclaration(declaration) || ts.isTypeAliasDeclaration(declaration)
|
|
116
|
+
|| ts.isClassDeclaration(declaration) || ts.isEnumDeclaration(declaration)) ? 'named' : 'unavailable';
|
|
117
|
+
}
|
|
116
118
|
function isInlineContractType(ts, node) {
|
|
117
|
-
|
|
118
|
-
|
|
119
|
+
return ts.isTypeLiteralNode(node) || ts.isMappedTypeNode(node) || ts.isUnionTypeNode(node)
|
|
120
|
+
|| ts.isIntersectionTypeNode(node) || ts.isTupleTypeNode(node) || ts.isFunctionTypeNode(node);
|
|
119
121
|
}
|
|
120
|
-
|
|
121
122
|
function isUnavailableContractType(ts, node) {
|
|
122
|
-
|
|
123
|
-
|
|
123
|
+
return ts.isConditionalTypeNode(node) || ts.isIndexedAccessTypeNode(node) || ts.isInferTypeNode(node)
|
|
124
|
+
|| ts.isTypeQueryNode(node) || ts.isImportTypeNode(node);
|
|
124
125
|
}
|
|
125
|
-
|
|
126
126
|
function contractTypeStatus(ts, checker, node, seen = new Set(), depth = 0) {
|
|
127
|
-
|
|
128
|
-
|
|
129
|
-
|
|
130
|
-
|
|
131
|
-
|
|
132
|
-
|
|
133
|
-
|
|
134
|
-
|
|
135
|
-
|
|
136
|
-
|
|
137
|
-
|
|
138
|
-
|
|
127
|
+
if (!node || depth > 12)
|
|
128
|
+
return 'unavailable';
|
|
129
|
+
if (ts.isParenthesizedTypeNode(node))
|
|
130
|
+
return contractTypeStatus(ts, checker, node.type, seen, depth + 1);
|
|
131
|
+
if (ts.isTypeOperatorNode(node) && node.operator === ts.SyntaxKind.ReadonlyKeyword) {
|
|
132
|
+
return contractTypeStatus(ts, checker, node.type, seen, depth + 1);
|
|
133
|
+
}
|
|
134
|
+
if (ts.isTypeReferenceNode(node))
|
|
135
|
+
return typeReferenceStatus(ts, checker, node, seen, depth);
|
|
136
|
+
if (ts.isArrayTypeNode(node))
|
|
137
|
+
return contractTypeStatus(ts, checker, node.elementType, seen, depth + 1);
|
|
138
|
+
if (isInlineContractType(ts, node))
|
|
139
|
+
return 'inline';
|
|
140
|
+
if (isUnavailableContractType(ts, node))
|
|
141
|
+
return 'unavailable';
|
|
142
|
+
return 'scalar';
|
|
143
|
+
}
|
|
139
144
|
function wrappedTypeStatus(ts, checker, type, named, nextSeen, depth) {
|
|
140
|
-
|
|
141
|
-
|
|
142
|
-
|
|
143
|
-
|
|
144
|
-
|
|
145
|
-
|
|
146
|
-
|
|
147
|
-
|
|
148
|
-
|
|
145
|
+
for (const wrapper of ['Promise', 'Readonly', 'Awaited', 'Array', 'ReadonlyArray'])
|
|
146
|
+
if (builtinSymbol(ts, named, wrapper)) {
|
|
147
|
+
const argumentsList = type.aliasTypeArguments ?? (typeof checker.getTypeArguments === 'function' && hasAnyFlag(type.objectFlags, ts.ObjectFlags.Reference)
|
|
148
|
+
? checker.getTypeArguments(type) : type.typeArguments) ?? [];
|
|
149
|
+
return argumentsList.length === 1 ? contractTypeStatusFromType(ts, checker, argumentsList[0], nextSeen, depth + 1) : 'unavailable';
|
|
150
|
+
}
|
|
151
|
+
for (const anonymous of ['Record', 'Partial', 'Pick', 'Omit', 'Required'])
|
|
152
|
+
if (builtinSymbol(ts, named, anonymous))
|
|
153
|
+
return 'inline';
|
|
154
|
+
return null;
|
|
155
|
+
}
|
|
149
156
|
function objectContractTypeStatus(ts, checker, type, nextSeen, depth) {
|
|
150
|
-
|
|
151
|
-
|
|
152
|
-
|
|
153
|
-
|
|
154
|
-
|
|
155
|
-
|
|
156
|
-
|
|
157
|
-
|
|
158
|
-
|
|
159
|
-
|
|
160
|
-
|
|
157
|
+
if (checker.isTupleType?.(type))
|
|
158
|
+
return 'inline';
|
|
159
|
+
if (checker.isArrayType?.(type)) {
|
|
160
|
+
const argumentsList = checker.getTypeArguments?.(type) ?? [];
|
|
161
|
+
return argumentsList.length === 1 ? contractTypeStatusFromType(ts, checker, argumentsList[0], nextSeen, depth + 1) : 'unavailable';
|
|
162
|
+
}
|
|
163
|
+
const declarations = type.symbol?.getDeclarations?.() ?? [];
|
|
164
|
+
if (type.symbol?.getName().startsWith('__') === false && declarations.some((declaration) => ts.isInterfaceDeclaration(declaration)
|
|
165
|
+
|| ts.isClassDeclaration(declaration) || ts.isTypeAliasDeclaration(declaration) || ts.isEnumDeclaration(declaration)))
|
|
166
|
+
return 'named';
|
|
167
|
+
return 'inline';
|
|
168
|
+
}
|
|
161
169
|
function contractTypeStatusFromType(ts, checker, type, seen = new Set(), depth = 0) {
|
|
162
|
-
|
|
163
|
-
|
|
164
|
-
|
|
165
|
-
|
|
166
|
-
|
|
167
|
-
|
|
168
|
-
|
|
169
|
-
|
|
170
|
-
|
|
171
|
-
|
|
172
|
-
|
|
173
|
-
|
|
174
|
-
|
|
175
|
-
|
|
176
|
-
|
|
177
|
-
|
|
170
|
+
if (!type || depth > 12 || seen.has(type))
|
|
171
|
+
return 'unavailable';
|
|
172
|
+
if (hasAnyFlag(type.flags, ts.TypeFlags.Any | ts.TypeFlags.Unknown))
|
|
173
|
+
return 'unavailable';
|
|
174
|
+
const nextSeen = new Set(seen).add(type);
|
|
175
|
+
const named = type.aliasSymbol ?? type.symbol ?? null;
|
|
176
|
+
const wrapperStatus = wrappedTypeStatus(ts, checker, type, named, nextSeen, depth);
|
|
177
|
+
if (wrapperStatus !== null)
|
|
178
|
+
return wrapperStatus;
|
|
179
|
+
if (type.aliasSymbol)
|
|
180
|
+
return 'named';
|
|
181
|
+
if ((type.symbol?.getDeclarations?.() ?? []).some((declaration) => ts.isEnumDeclaration(declaration)))
|
|
182
|
+
return 'named';
|
|
183
|
+
if (hasAnyFlag(type.flags, ts.TypeFlags.TypeParameter))
|
|
184
|
+
return 'named';
|
|
185
|
+
if (hasAnyFlag(type.flags, ts.TypeFlags.Boolean))
|
|
186
|
+
return 'scalar';
|
|
187
|
+
if (hasAnyFlag(type.flags, ts.TypeFlags.Union | ts.TypeFlags.Intersection))
|
|
188
|
+
return 'inline';
|
|
189
|
+
if (hasAnyFlag(type.flags, ts.TypeFlags.Object))
|
|
190
|
+
return objectContractTypeStatus(ts, checker, type, nextSeen, depth);
|
|
191
|
+
if (hasAnyFlag(type.flags, ts.TypeFlags.Conditional | ts.TypeFlags.IndexedAccess | ts.TypeFlags.Substitution))
|
|
192
|
+
return 'unavailable';
|
|
193
|
+
return 'scalar';
|
|
194
|
+
}
|
|
178
195
|
function callableSignatures(ts, symbol, checker, location) {
|
|
179
|
-
|
|
180
|
-
|
|
181
|
-
|
|
182
|
-
|
|
196
|
+
const type = checker.getTypeOfSymbolAtLocation(symbol, location);
|
|
197
|
+
const signatures = checker.getSignaturesOfType(type, ts.SignatureKind.Call);
|
|
198
|
+
const bodyless = signatures.filter((signature) => signature.getDeclaration() && !signature.getDeclaration().body);
|
|
199
|
+
return bodyless.length ? bodyless : signatures.filter((signature) => signature.getDeclaration());
|
|
183
200
|
}
|
|
184
|
-
|
|
185
201
|
function signatureParameterStatus(ts, checker, signature, location, parameter, signatureIndex) {
|
|
186
|
-
|
|
187
|
-
|
|
188
|
-
|
|
189
|
-
|
|
190
|
-
|
|
191
|
-
|
|
192
|
-
|
|
193
|
-
}
|
|
194
|
-
|
|
202
|
+
const parameterSymbol = signature.getParameters()[signatureIndex];
|
|
203
|
+
const actual = parameterSymbol ? checker.getTypeOfSymbolAtLocation(parameterSymbol, location) : null;
|
|
204
|
+
if (actual && parameter.questionToken && !ts.isUnionTypeNode(parameter.type) && hasAnyFlag(actual.flags, ts.TypeFlags.Union)) {
|
|
205
|
+
const selected = actual.types.filter((type) => !hasAnyFlag(type.flags, ts.TypeFlags.Undefined));
|
|
206
|
+
return selected.length === 1 ? contractTypeStatusFromType(ts, checker, selected[0]) : 'inline';
|
|
207
|
+
}
|
|
208
|
+
return actual ? contractTypeStatusFromType(ts, checker, actual) : contractTypeStatus(ts, checker, parameter.type);
|
|
209
|
+
}
|
|
195
210
|
function checkSignatureInputs(state, declaration) {
|
|
196
|
-
|
|
197
|
-
|
|
198
|
-
|
|
199
|
-
|
|
200
|
-
|
|
201
|
-
|
|
202
|
-
|
|
203
|
-
|
|
204
|
-
|
|
205
|
-
|
|
206
|
-
|
|
211
|
+
const { config, context, checker, signature, location, reportSource, reportNode, displayName, violations, reasons } = state;
|
|
212
|
+
const ts = context.ts;
|
|
213
|
+
let signatureIndex = 0;
|
|
214
|
+
for (let index = 0; index < (declaration.parameters?.length ?? 0); index += 1) {
|
|
215
|
+
const parameter = declaration.parameters[index];
|
|
216
|
+
if (parameter.name && ts.isIdentifier(parameter.name) && parameter.name.text === 'this')
|
|
217
|
+
continue;
|
|
218
|
+
if (!parameter.type) {
|
|
219
|
+
violations.push(violation(config, reportSource, reportNode ?? parameter, PUBLIC_CONTRACT_RULE_ID, `${displayName} must declare the type of each public input.`));
|
|
220
|
+
signatureIndex += 1;
|
|
221
|
+
continue;
|
|
222
|
+
}
|
|
223
|
+
const status = signatureParameterStatus(ts, checker, signature, location, parameter, signatureIndex);
|
|
224
|
+
signatureIndex += 1;
|
|
225
|
+
if (status === 'inline')
|
|
226
|
+
violations.push(violation(config, reportSource, reportNode ?? parameter.type, PUBLIC_CONTRACT_RULE_ID, `${displayName} uses an inline object/union input; expose a named contract or a positional primitive.`));
|
|
227
|
+
else if (status === 'unavailable')
|
|
228
|
+
reasons.push(`${relativePath(config.root, reportSource.fileName)} cannot prove the public input type of ${displayName}`);
|
|
207
229
|
}
|
|
208
|
-
|
|
209
|
-
signatureIndex += 1;
|
|
210
|
-
if (status === 'inline') violations.push(violation(config, reportSource, reportNode ?? parameter.type, PUBLIC_CONTRACT_RULE_ID,
|
|
211
|
-
`${displayName} uses an inline object/union input; expose a named contract or a positional primitive.`));
|
|
212
|
-
else if (status === 'unavailable') reasons.push(`${relativePath(config.root, reportSource.fileName)} cannot prove the public input type of ${displayName}`);
|
|
213
|
-
}
|
|
214
|
-
}
|
|
215
|
-
|
|
230
|
+
}
|
|
216
231
|
function checkSignatureOutput(state, declaration) {
|
|
217
|
-
|
|
218
|
-
|
|
219
|
-
|
|
220
|
-
|
|
221
|
-
|
|
222
|
-
|
|
223
|
-
|
|
224
|
-
|
|
225
|
-
|
|
226
|
-
|
|
227
|
-
|
|
228
|
-
|
|
229
|
-
}
|
|
230
|
-
|
|
232
|
+
const { config, context, checker, signature, reportSource, reportNode, displayName, violations, reasons } = state;
|
|
233
|
+
const ts = context.ts;
|
|
234
|
+
if (!declaration.type) {
|
|
235
|
+
violations.push(violation(config, reportSource, reportNode ?? declaration, PUBLIC_CONTRACT_RULE_ID, `${displayName} must declare an explicit public output type.`));
|
|
236
|
+
return;
|
|
237
|
+
}
|
|
238
|
+
const actual = checker.getReturnTypeOfSignature(signature);
|
|
239
|
+
const status = actual ? contractTypeStatusFromType(ts, checker, actual) : contractTypeStatus(ts, checker, declaration.type);
|
|
240
|
+
if (status === 'inline')
|
|
241
|
+
violations.push(violation(config, reportSource, reportNode ?? declaration.type, PUBLIC_CONTRACT_RULE_ID, `${displayName} uses an inline object/union output; expose a named result contract or a primitive.`));
|
|
242
|
+
else if (status === 'unavailable')
|
|
243
|
+
reasons.push(`${relativePath(config.root, reportSource.fileName)} cannot prove the public output type of ${displayName}`);
|
|
244
|
+
}
|
|
231
245
|
function checkSignature(state) {
|
|
232
|
-
|
|
233
|
-
|
|
234
|
-
|
|
246
|
+
const declaration = state.signature.getDeclaration();
|
|
247
|
+
checkSignatureInputs(state, declaration);
|
|
248
|
+
checkSignatureOutput(state, declaration);
|
|
235
249
|
}
|
|
236
|
-
|
|
237
250
|
function symbolName(symbol) {
|
|
238
|
-
|
|
239
|
-
|
|
251
|
+
const name = symbol.getName?.() ?? '(anonymous)';
|
|
252
|
+
return name === '__call' ? '(callable)' : name;
|
|
240
253
|
}
|
|
241
|
-
|
|
242
254
|
function isRepositoryDeclaration(declaration, localFiles) {
|
|
243
|
-
|
|
255
|
+
return localFiles.has(canonical(declaration.getSourceFile().fileName));
|
|
244
256
|
}
|
|
245
|
-
|
|
246
257
|
const isPublicCallableDeclaration = (ts, declaration) => ts.isMethodDeclaration(declaration) || ts.isMethodSignature(declaration)
|
|
247
|
-
|
|
248
|
-
|
|
258
|
+
|| ts.isPropertyDeclaration(declaration) || ts.isPropertySignature(declaration) || ts.isGetAccessorDeclaration(declaration);
|
|
249
259
|
function isCallableMember(ts, checker, member, location, localFiles) {
|
|
250
|
-
|
|
251
|
-
|
|
252
|
-
|
|
253
|
-
|
|
254
|
-
|
|
260
|
+
if (member.getName() === 'prototype')
|
|
261
|
+
return false;
|
|
262
|
+
const selected = member.getDeclarations?.() ?? [];
|
|
263
|
+
return Boolean(selected.some((declaration) => isPublicCallableDeclaration(ts, declaration)
|
|
264
|
+
&& isPublicMember(ts, declaration) && isRepositoryDeclaration(declaration, localFiles))
|
|
265
|
+
&& checker.getSignaturesOfType(checker.getTypeOfSymbolAtLocation(member, location), ts.SignatureKind.Call).length);
|
|
255
266
|
}
|
|
256
|
-
|
|
257
267
|
function callableMembers(ts, checker, symbol, location, localFiles) {
|
|
258
|
-
|
|
259
|
-
|
|
260
|
-
|
|
261
|
-
|
|
262
|
-
|
|
263
|
-
|
|
264
|
-
|
|
265
|
-
|
|
266
|
-
|
|
267
|
-
|
|
268
|
-
|
|
269
|
-
|
|
270
|
-
|
|
271
|
-
|
|
272
|
-
|
|
268
|
+
const declarations = symbol.getDeclarations?.() ?? [];
|
|
269
|
+
const classExpressions = declarations.flatMap((declaration) => ts.isVariableDeclaration(declaration)
|
|
270
|
+
&& declaration.initializer && ts.isClassExpression(unwrapExpression(ts, declaration.initializer))
|
|
271
|
+
? [unwrapExpression(ts, declaration.initializer)] : []);
|
|
272
|
+
const valueType = checker.getTypeOfSymbolAtLocation(symbol, location);
|
|
273
|
+
const declaredClassLike = declarations.some(declaration => ts.isClassDeclaration(declaration) || ts.isInterfaceDeclaration(declaration));
|
|
274
|
+
const primary = declaredClassLike ? checker.getDeclaredTypeOfSymbol(symbol) : valueType;
|
|
275
|
+
const types = [primary];
|
|
276
|
+
if (declaredClassLike || classExpressions.length)
|
|
277
|
+
types.push(valueType);
|
|
278
|
+
for (const signature of checker.getSignaturesOfType(valueType, ts.SignatureKind.Construct))
|
|
279
|
+
types.push(checker.getReturnTypeOfSignature(signature));
|
|
280
|
+
const direct = checker.getSignaturesOfType(primary, ts.SignatureKind.Call).length ? [symbol] : [];
|
|
281
|
+
const members = types.flatMap((type) => checker.getPropertiesOfType(type)).filter((member) => isCallableMember(ts, checker, member, location, localFiles));
|
|
282
|
+
return [...new Set([...direct, ...members])];
|
|
283
|
+
}
|
|
273
284
|
function exportedSymbols(ts, checker, sourceFile) {
|
|
274
|
-
|
|
275
|
-
|
|
285
|
+
const moduleSymbol = checker.getSymbolAtLocation(sourceFile);
|
|
286
|
+
return moduleSymbol ? checker.getExportsOfModule(moduleSymbol).map((symbol) => normalizedSymbolValue(ts, checker, symbol)).filter((symbol) => Boolean(symbol)) : [];
|
|
276
287
|
}
|
|
277
|
-
|
|
278
288
|
function checkCallableSymbol({ config, context, checker, symbol, location, reportSource, reportNode, violations, reasons, seen, localFiles }) {
|
|
279
|
-
|
|
280
|
-
|
|
281
|
-
|
|
282
|
-
|
|
283
|
-
|
|
284
|
-
|
|
285
|
-
|
|
286
|
-
|
|
287
|
-
|
|
288
|
-
|
|
289
|
+
if (seen.has(symbol))
|
|
290
|
+
return 0;
|
|
291
|
+
seen.add(symbol);
|
|
292
|
+
let checked = 0;
|
|
293
|
+
for (const callable of callableMembers(context.ts, checker, symbol, location, localFiles)) {
|
|
294
|
+
if (callable !== symbol && seen.has(callable))
|
|
295
|
+
continue;
|
|
296
|
+
seen.add(callable);
|
|
297
|
+
const signatures = callableSignatures(context.ts, callable, checker, location);
|
|
298
|
+
if (!signatures.length) {
|
|
299
|
+
reasons.push(`${relativePath(config.root, reportSource.fileName)} cannot resolve the callable signature of ${symbolName(callable)}`);
|
|
300
|
+
continue;
|
|
301
|
+
}
|
|
302
|
+
for (const signature of signatures) {
|
|
303
|
+
checked += 1;
|
|
304
|
+
checkSignature({ config, context, checker, signature, location, reportSource, reportNode,
|
|
305
|
+
displayName: callable === symbol ? symbolName(symbol) : `${symbolName(symbol)}.${symbolName(callable)}`,
|
|
306
|
+
violations, reasons });
|
|
307
|
+
}
|
|
289
308
|
}
|
|
290
|
-
|
|
291
|
-
checked += 1;
|
|
292
|
-
checkSignature({ config, context, checker, signature, location, reportSource, reportNode,
|
|
293
|
-
displayName: callable === symbol ? symbolName(symbol) : `${symbolName(symbol)}.${symbolName(callable)}`,
|
|
294
|
-
violations, reasons });
|
|
295
|
-
}
|
|
296
|
-
}
|
|
297
|
-
return checked;
|
|
309
|
+
return checked;
|
|
298
310
|
}
|
|
299
|
-
|
|
300
311
|
function frameworkFor(state, checker) {
|
|
301
|
-
|
|
302
|
-
|
|
303
|
-
|
|
304
|
-
|
|
305
|
-
|
|
306
|
-
|
|
307
|
-
}
|
|
308
|
-
|
|
312
|
+
if (!state.frameworkByChecker.has(checker)) {
|
|
313
|
+
const selected = frameworkTargets(state.config, state.context, checker, state.localFiles);
|
|
314
|
+
state.frameworkByChecker.set(checker, { ...selected, ts: state.ts, checker, targets: selected.bySymbol });
|
|
315
|
+
state.readonlyReasons.push(...selected.reasons);
|
|
316
|
+
}
|
|
317
|
+
return state.frameworkByChecker.get(checker);
|
|
318
|
+
}
|
|
309
319
|
function checkOwnerCoverage(state) {
|
|
310
|
-
|
|
311
|
-
|
|
312
|
-
|
|
313
|
-
|
|
314
|
-
|
|
315
|
-
|
|
316
|
-
|
|
317
|
-
|
|
318
|
-
}
|
|
319
|
-
|
|
320
|
+
const { config, context, publicReasons } = state;
|
|
321
|
+
if (!config.owners?.length)
|
|
322
|
+
publicReasons.push('no slot owner with an entry file exists, so capability API discovery has no owners to list');
|
|
323
|
+
const ownerRoots = (config.owners ?? []).map((owner) => path.resolve(config.root, ...owner.root.split('/')));
|
|
324
|
+
const publicSourceRoots = [...config.backend.features, ...config.backend.modules].map((root) => path.resolve(config.root, ...root.split('/')));
|
|
325
|
+
for (const sourceFile of context.files)
|
|
326
|
+
if (publicSourceRoots.some((root) => isInside(root, sourceFile.fileName))
|
|
327
|
+
&& !ownerRoots.some((root) => isInside(root, sourceFile.fileName))) {
|
|
328
|
+
publicReasons.push(`${relativePath(config.root, sourceFile.fileName)} is outside every declared owner root`);
|
|
329
|
+
}
|
|
330
|
+
}
|
|
320
331
|
function checkExportedSymbol(state, checker, framework, symbol) {
|
|
321
|
-
|
|
322
|
-
|
|
323
|
-
|
|
324
|
-
|
|
325
|
-
|
|
326
|
-
|
|
327
|
-
|
|
328
|
-
|
|
329
|
-
|
|
330
|
-
|
|
332
|
+
const { context, localFiles, publicReasons, violations, publicSeen } = state;
|
|
333
|
+
const declarations = (symbol.getDeclarations?.() ?? []).filter((declaration) => localFiles.has(canonical(declaration.getSourceFile().fileName))) ?? [];
|
|
334
|
+
if (!declarations.length)
|
|
335
|
+
return;
|
|
336
|
+
const representative = declarations[0];
|
|
337
|
+
if (isFrameworkHelper(representative.getSourceFile(), representative, framework))
|
|
338
|
+
return;
|
|
339
|
+
state.callableSignatures += checkCallableSymbol({ config: state.config, context, checker, symbol, location: representative,
|
|
340
|
+
reportSource: representative.getSourceFile(), reportNode: representative.name ?? representative,
|
|
341
|
+
violations, reasons: publicReasons, seen: publicSeen, localFiles });
|
|
342
|
+
}
|
|
331
343
|
function checkOwnerEntry(state, owner) {
|
|
332
|
-
|
|
333
|
-
|
|
334
|
-
|
|
335
|
-
|
|
336
|
-
|
|
337
|
-
|
|
338
|
-
|
|
339
|
-
|
|
340
|
-
|
|
341
|
-
|
|
342
|
-
|
|
343
|
-
|
|
344
|
-
|
|
345
|
-
|
|
344
|
+
const { config, context, ts, sourceFiles, publicReasons } = state;
|
|
345
|
+
const entry = sourceFiles.get(canonical(path.resolve(config.root, ...owner.entry.split('/'))));
|
|
346
|
+
if (!entry) {
|
|
347
|
+
publicReasons.push(`${owner.entry} is outside the checked production program`);
|
|
348
|
+
return;
|
|
349
|
+
}
|
|
350
|
+
const checker = checkerFor(context, entry.fileName);
|
|
351
|
+
const framework = frameworkFor(state, checker);
|
|
352
|
+
if (entry.statements.some((statement) => ts.isExportAssignment(statement) && statement.isExportEquals)) {
|
|
353
|
+
publicReasons.push(`${owner.entry} uses export =, so named capability API discovery is unavailable`);
|
|
354
|
+
}
|
|
355
|
+
for (const symbol of exportedSymbols(ts, checker, entry))
|
|
356
|
+
checkExportedSymbol(state, checker, framework, symbol);
|
|
357
|
+
}
|
|
346
358
|
function checkPublicOwners(state) {
|
|
347
|
-
|
|
359
|
+
for (const owner of state.config.owners ?? [])
|
|
360
|
+
checkOwnerEntry(state, owner);
|
|
348
361
|
}
|
|
349
|
-
|
|
350
362
|
function classesInSource(ts, sourceFile) {
|
|
351
|
-
|
|
352
|
-
|
|
353
|
-
|
|
354
|
-
|
|
355
|
-
|
|
356
|
-
|
|
357
|
-
|
|
358
|
-
|
|
359
|
-
|
|
363
|
+
const classes = [];
|
|
364
|
+
const collect = (node) => {
|
|
365
|
+
if (ts.isClassDeclaration(node) || ts.isClassExpression(node))
|
|
366
|
+
classes.push(node);
|
|
367
|
+
ts.forEachChild(node, collect);
|
|
368
|
+
};
|
|
369
|
+
collect(sourceFile);
|
|
370
|
+
return classes;
|
|
371
|
+
}
|
|
360
372
|
function checkConstructedClassDecorators(state, sourceFile, checker, decorators, kinds, targets) {
|
|
361
|
-
|
|
362
|
-
|
|
363
|
-
|
|
364
|
-
|
|
365
|
-
|
|
366
|
-
|
|
373
|
+
for (const [index, decorator] of decorators.entries())
|
|
374
|
+
if (!kinds[index]) {
|
|
375
|
+
const constructed = constructedDecoratorKind(state.ts, checker, decorator, targets);
|
|
376
|
+
if (constructed && (NEST_CREATED.has(constructed) || MESSAGE_HANDLERS.has(constructed) || constructed.includes('framework'))) {
|
|
377
|
+
state.readonlyReasons.push(`${relativePath(state.config.root, sourceFile.fileName)} has a constructed ${constructed} decorator identity`);
|
|
378
|
+
}
|
|
379
|
+
}
|
|
367
380
|
}
|
|
368
|
-
|
|
369
381
|
function checkConstructedMemberDecorator(state, sourceFile, checker, decorator, targets) {
|
|
370
|
-
|
|
371
|
-
|
|
372
|
-
|
|
373
|
-
|
|
374
|
-
|
|
375
|
-
|
|
376
|
-
}
|
|
377
|
-
|
|
382
|
+
const { ts, config, readonlyReasons } = state;
|
|
383
|
+
if (decoratorKind(ts, checker, decorator, targets))
|
|
384
|
+
return;
|
|
385
|
+
const constructed = constructedDecoratorKind(ts, checker, decorator, targets);
|
|
386
|
+
if (constructed === 'Inject' || constructed === 'unproven framework') {
|
|
387
|
+
readonlyReasons.push(`${relativePath(config.root, sourceFile.fileName)} has a constructed ${constructed} injection decorator identity`);
|
|
388
|
+
}
|
|
389
|
+
}
|
|
378
390
|
function checkConstructedMemberDecorators(state, sourceFile, declaration, checker, targets) {
|
|
379
|
-
|
|
380
|
-
|
|
381
|
-
|
|
382
|
-
|
|
391
|
+
const { ts } = state;
|
|
392
|
+
for (const member of declaration.members)
|
|
393
|
+
for (const decorated of [member, ...(ts.isConstructorDeclaration(member) ? member.parameters : [])]) {
|
|
394
|
+
for (const decorator of nodeDecorators(ts, decorated))
|
|
395
|
+
checkConstructedMemberDecorator(state, sourceFile, checker, decorator, targets);
|
|
396
|
+
}
|
|
383
397
|
}
|
|
384
|
-
|
|
385
398
|
function hasInjectedMember(ts, checker, declaration, targets) {
|
|
386
|
-
|
|
387
|
-
|
|
388
|
-
|
|
389
|
-
}
|
|
390
|
-
|
|
391
|
-
|
|
392
|
-
|
|
393
|
-
|
|
394
|
-
|
|
395
|
-
|
|
396
|
-
|
|
397
|
-
|
|
398
|
-
|
|
399
|
-
|
|
400
|
-
|
|
401
|
-
|
|
402
|
-
|
|
403
|
-
|
|
404
|
-
}
|
|
405
|
-
|
|
399
|
+
return declaration.members.some((member) => nodeDecorators(ts, member).some((decorator) => decoratorKind(ts, checker, decorator, targets) === 'Inject')
|
|
400
|
+
|| (ts.isConstructorDeclaration(member) && member.parameters.some((parameter) => nodeDecorators(ts, parameter)
|
|
401
|
+
.some((decorator) => decoratorKind(ts, checker, decorator, targets) === 'Inject'))));
|
|
402
|
+
}
|
|
403
|
+
function checkMessageHandlers(state, checker, decorators, kinds) {
|
|
404
|
+
for (const [index, decorator] of decorators.entries()) {
|
|
405
|
+
const kind = kinds[index];
|
|
406
|
+
if (!kind || !MESSAGE_HANDLERS.has(kind))
|
|
407
|
+
continue;
|
|
408
|
+
const message = messageClass(state.config, state.context, checker, decorator, state.localFiles, state.readonlyReasons);
|
|
409
|
+
if (!message)
|
|
410
|
+
continue;
|
|
411
|
+
const key = `${message.getSourceFile().fileName}:${message.pos}`;
|
|
412
|
+
if (state.messageSeen.has(key))
|
|
413
|
+
continue;
|
|
414
|
+
state.messageSeen.add(key);
|
|
415
|
+
state.messages += 1;
|
|
416
|
+
checkMessageReadonly(state.config, state.context, checkerFor(state.context, message.getSourceFile().fileName), message, state.localFiles, state.violations, state.readonlyReasons);
|
|
417
|
+
}
|
|
418
|
+
}
|
|
406
419
|
function checkUseCase(state, role, sourceFile, checker, declaration) {
|
|
407
|
-
|
|
408
|
-
|
|
409
|
-
|
|
410
|
-
|
|
411
|
-
|
|
412
|
-
|
|
413
|
-
|
|
414
|
-
|
|
415
|
-
|
|
416
|
-
|
|
417
|
-
}
|
|
418
|
-
|
|
420
|
+
const { ts, config, context, publicReasons, publicSeen, localFiles, violations } = state;
|
|
421
|
+
if (!(role.role === 'use-case' && !role.transport && ts.isClassDeclaration(declaration) && declaration.name))
|
|
422
|
+
return;
|
|
423
|
+
const exported = exportedSymbols(ts, checker, sourceFile).some((symbol) => (symbol.getDeclarations?.() ?? []).includes(declaration));
|
|
424
|
+
if (!exported)
|
|
425
|
+
return;
|
|
426
|
+
const classSymbol = normalizedSymbol(ts, checker, declaration.name);
|
|
427
|
+
const instanceType = classSymbol ? checker.getDeclaredTypeOfSymbol(classSymbol) : null;
|
|
428
|
+
const execute = instanceType ? checker.getPropertyOfType(instanceType, 'execute') : null;
|
|
429
|
+
if (!execute)
|
|
430
|
+
publicReasons.push(`${relativePath(config.root, sourceFile.fileName)} exports a use-case class without a statically resolved execute contract`);
|
|
431
|
+
else
|
|
432
|
+
state.callableSignatures += checkCallableSymbol({ config, context, checker, symbol: execute, location: declaration,
|
|
433
|
+
reportSource: sourceFile, reportNode: declaration.name, violations, reasons: publicReasons, seen: publicSeen, localFiles });
|
|
434
|
+
}
|
|
419
435
|
function checkClassContracts(state, sourceFile, checker, role, declaration, framework) {
|
|
420
|
-
|
|
421
|
-
|
|
422
|
-
|
|
423
|
-
|
|
424
|
-
|
|
425
|
-
|
|
426
|
-
|
|
427
|
-
|
|
428
|
-
|
|
429
|
-
|
|
430
|
-
|
|
431
|
-
|
|
432
|
-
|
|
433
|
-
|
|
434
|
-
|
|
435
|
-
}
|
|
436
|
-
|
|
436
|
+
const { ts, config, context, violations, readonlyReasons, localFiles } = state;
|
|
437
|
+
const decorators = nodeDecorators(ts, declaration);
|
|
438
|
+
const kinds = decorators.map((decorator) => decoratorKind(ts, checker, decorator, framework.targets));
|
|
439
|
+
const directKinds = kinds.filter((kind) => Boolean(kind));
|
|
440
|
+
checkConstructedClassDecorators(state, sourceFile, checker, decorators, kinds, framework.targets);
|
|
441
|
+
const classKind = directKinds.find((kind) => NEST_CREATED.has(kind)) ?? null;
|
|
442
|
+
const targets = framework.targets;
|
|
443
|
+
checkConstructedMemberDecorators(state, sourceFile, declaration, checker, targets);
|
|
444
|
+
if (classKind || hasInjectedMember(ts, checker, declaration, targets)) {
|
|
445
|
+
state.injectedClasses += 1;
|
|
446
|
+
checkInjectedClass({ config, context, checker, declaration, classKind, targets, decoratorKind,
|
|
447
|
+
localFiles, violations, reasons: readonlyReasons });
|
|
448
|
+
}
|
|
449
|
+
checkMessageHandlers(state, checker, decorators, kinds);
|
|
450
|
+
checkUseCase(state, role, sourceFile, checker, declaration);
|
|
451
|
+
}
|
|
437
452
|
function checkSourceFile(state, sourceFile) {
|
|
438
|
-
|
|
439
|
-
|
|
440
|
-
|
|
441
|
-
|
|
453
|
+
const checker = checkerFor(state.context, sourceFile.fileName);
|
|
454
|
+
const framework = frameworkFor(state, checker);
|
|
455
|
+
const role = sourceRole(sourceFile);
|
|
456
|
+
for (const declaration of classesInSource(state.ts, sourceFile))
|
|
457
|
+
checkClassContracts(state, sourceFile, checker, role, declaration, framework);
|
|
442
458
|
}
|
|
443
|
-
|
|
444
459
|
function contractCoverage(state) {
|
|
445
|
-
|
|
446
|
-
|
|
447
|
-
|
|
448
|
-
|
|
449
|
-
|
|
450
|
-
|
|
451
|
-
|
|
452
|
-
|
|
453
|
-
|
|
454
|
-
|
|
455
|
-
|
|
456
|
-
}
|
|
457
|
-
|
|
460
|
+
const publicDetails = [...new Set(state.publicReasons)].sort(byCodeUnit);
|
|
461
|
+
const readonlyDetails = [...new Set(state.readonlyReasons)].sort(byCodeUnit);
|
|
462
|
+
return {
|
|
463
|
+
violations: state.violations,
|
|
464
|
+
coverage: {
|
|
465
|
+
publicContracts: publicDetails.length ? { status: 'unavailable', callableSignatures: state.callableSignatures, details: publicDetails }
|
|
466
|
+
: { status: 'checked', callableSignatures: state.callableSignatures },
|
|
467
|
+
readonlyBoundaries: readonlyDetails.length ? { status: 'unavailable', injectedClasses: state.injectedClasses, messages: state.messages, details: readonlyDetails }
|
|
468
|
+
: { status: 'checked', injectedClasses: state.injectedClasses, messages: state.messages },
|
|
469
|
+
},
|
|
470
|
+
};
|
|
471
|
+
}
|
|
458
472
|
/** Enforce mechanically selected public contract and readonly boundaries without treating DTOs or arbitrary interfaces as APIs. */
|
|
459
473
|
export function checkBackendContracts(config, context) {
|
|
460
|
-
|
|
461
|
-
|
|
462
|
-
|
|
463
|
-
|
|
464
|
-
|
|
465
|
-
|
|
466
|
-
|
|
467
|
-
|
|
468
|
-
|
|
469
|
-
|
|
470
|
-
|
|
474
|
+
const state = {
|
|
475
|
+
config, context, ts: context.ts,
|
|
476
|
+
localFiles: new Set(context.files.map((file) => canonical(file.fileName))),
|
|
477
|
+
sourceFiles: new Map(context.files.map((file) => [canonical(file.fileName), file])),
|
|
478
|
+
frameworkByChecker: new Map(), violations: [], publicReasons: [], readonlyReasons: [],
|
|
479
|
+
publicSeen: new Set(), messageSeen: new Set(), callableSignatures: 0, injectedClasses: 0, messages: 0,
|
|
480
|
+
};
|
|
481
|
+
checkOwnerCoverage(state);
|
|
482
|
+
checkPublicOwners(state);
|
|
483
|
+
for (const sourceFile of context.files)
|
|
484
|
+
checkSourceFile(state, sourceFile);
|
|
485
|
+
return contractCoverage(state);
|
|
471
486
|
}
|