@shivaedev/quality 0.74.1 → 0.74.3
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/README.md +6 -6
- package/dist/adapters/clientHandle.d.ts +3 -0
- package/dist/adapters/clientHandle.d.ts.map +1 -0
- package/dist/adapters/clientHandle.js +6 -0
- package/dist/adapters/clientHandle.js.map +1 -0
- package/dist/adapters/declarationTagParameter.d.ts +3 -0
- package/dist/adapters/declarationTagParameter.d.ts.map +1 -0
- package/dist/adapters/declarationTagParameter.js +125 -0
- package/dist/adapters/declarationTagParameter.js.map +1 -0
- package/dist/adapters/frameworkCallback.d.ts +1 -0
- package/dist/adapters/frameworkCallback.d.ts.map +1 -1
- package/dist/adapters/frameworkCallback.js +1 -1
- package/dist/adapters/frameworkCallback.js.map +1 -1
- package/dist/adapters/imports/departures.d.ts.map +1 -1
- package/dist/adapters/imports/departures.js +7 -1
- package/dist/adapters/imports/departures.js.map +1 -1
- package/dist/adapters/isToolConfig.d.ts.map +1 -1
- package/dist/adapters/isToolConfig.js +5 -1
- package/dist/adapters/isToolConfig.js.map +1 -1
- package/dist/adapters/outsideImportFindings.d.ts.map +1 -1
- package/dist/adapters/outsideImportFindings.js +21 -15
- package/dist/adapters/outsideImportFindings.js.map +1 -1
- package/dist/adapters/plainFunction.d.ts +3 -0
- package/dist/adapters/plainFunction.d.ts.map +1 -0
- package/dist/adapters/plainFunction.js +19 -0
- package/dist/adapters/plainFunction.js.map +1 -0
- package/dist/adapters/serviceModelSyntax.d.ts +1 -0
- package/dist/adapters/serviceModelSyntax.d.ts.map +1 -1
- package/dist/adapters/serviceModelSyntax.js +1 -1
- package/dist/adapters/serviceModelSyntax.js.map +1 -1
- package/dist/adapters/valueType.d.ts +3 -0
- package/dist/adapters/valueType.d.ts.map +1 -0
- package/dist/adapters/valueType.js +16 -0
- package/dist/adapters/valueType.js.map +1 -0
- package/dist/imports/isTooling.d.ts +1 -0
- package/dist/imports/isTooling.d.ts.map +1 -1
- package/dist/imports/isTooling.js +6 -3
- package/dist/imports/isTooling.js.map +1 -1
- package/dist/rules/effect/adapterImports.js +1 -1
- package/dist/rules/effect/adapterImports.js.map +1 -1
- package/dist/rules/effect/boundary.d.ts.map +1 -1
- package/dist/rules/effect/boundary.js +9 -7
- package/dist/rules/effect/boundary.js.map +1 -1
- package/dist/rules/effect/boundaryReference.d.ts +3 -0
- package/dist/rules/effect/boundaryReference.d.ts.map +1 -1
- package/dist/rules/effect/boundaryReference.js +23 -2
- package/dist/rules/effect/boundaryReference.js.map +1 -1
- package/dist/rules/effect/serviceCatalog.d.ts +1 -0
- package/dist/rules/effect/serviceCatalog.d.ts.map +1 -1
- package/dist/rules/effect/serviceFindings.d.ts.map +1 -1
- package/dist/rules/effect/serviceFindings.js +7 -1
- package/dist/rules/effect/serviceFindings.js.map +1 -1
- package/dist/rules/effect/serviceParameters.js +1 -1
- package/dist/rules/effect/serviceParameters.js.map +1 -1
- package/dist/rules/effect/serviceTypes.d.ts +1 -0
- package/dist/rules/effect/serviceTypes.d.ts.map +1 -1
- package/dist/rules/effect/serviceTypes.js +15 -19
- package/dist/rules/effect/serviceTypes.js.map +1 -1
- package/dist/rules/imports/aliased.js +1 -1
- package/dist/rules/imports/aliased.js.map +1 -1
- package/package.json +4 -4
- package/src/adapters/clientHandle.ts +11 -0
- package/src/adapters/declarationTagParameter.ts +146 -0
- package/src/adapters/frameworkCallback.ts +1 -1
- package/src/adapters/imports/departures.ts +7 -1
- package/src/adapters/isToolConfig.ts +7 -3
- package/src/adapters/outsideImportFindings.ts +22 -15
- package/src/adapters/plainFunction.ts +22 -0
- package/src/adapters/serviceModelSyntax.ts +1 -1
- package/src/adapters/valueType.ts +18 -0
- package/src/imports/isTooling.ts +7 -3
- package/src/rules/effect/adapterImports.ts +1 -1
- package/src/rules/effect/boundary.ts +25 -17
- package/src/rules/effect/boundaryReference.ts +30 -2
- package/src/rules/effect/serviceFindings.ts +7 -1
- package/src/rules/effect/serviceParameters.ts +1 -1
- package/src/rules/effect/serviceTypes.ts +15 -21
- package/src/rules/imports/aliased.ts +1 -1
|
@@ -0,0 +1,146 @@
|
|
|
1
|
+
import ts from "typescript";
|
|
2
|
+
import { declarationOf, resolvedValue } from "#adapters/serviceModelSyntax.ts";
|
|
3
|
+
|
|
4
|
+
const RPC_MIDDLEWARE = "~effect/rpc/RpcMiddleware";
|
|
5
|
+
|
|
6
|
+
function implementationParameter(checker: ts.TypeChecker, parameter: ts.ParameterDeclaration): ts.ParameterDeclaration {
|
|
7
|
+
const fn = parameter.parent;
|
|
8
|
+
if (!(ts.isFunctionDeclaration(fn) || ts.isMethodDeclaration(fn)) || fn.body !== undefined || fn.name === undefined) {
|
|
9
|
+
return parameter;
|
|
10
|
+
}
|
|
11
|
+
const implementation = checker
|
|
12
|
+
.getSymbolAtLocation(fn.name)
|
|
13
|
+
?.declarations?.find(
|
|
14
|
+
(declaration) => (ts.isFunctionDeclaration(declaration) || ts.isMethodDeclaration(declaration)) && declaration.body !== undefined,
|
|
15
|
+
);
|
|
16
|
+
return implementation !== undefined && (ts.isFunctionDeclaration(implementation) || ts.isMethodDeclaration(implementation))
|
|
17
|
+
? (implementation.parameters[fn.parameters.indexOf(parameter)] ?? parameter)
|
|
18
|
+
: parameter;
|
|
19
|
+
}
|
|
20
|
+
|
|
21
|
+
function functionBody(parameter: ts.ParameterDeclaration): ts.Node | undefined {
|
|
22
|
+
const fn = parameter.parent;
|
|
23
|
+
return ts.isFunctionDeclaration(fn) || ts.isFunctionExpression(fn) || ts.isArrowFunction(fn) || ts.isMethodDeclaration(fn) ? fn.body : undefined;
|
|
24
|
+
}
|
|
25
|
+
|
|
26
|
+
function contextPick(checker: ts.TypeChecker, callee: ts.Expression): boolean {
|
|
27
|
+
const declaration = declarationOf(checker, ts.isPropertyAccessExpression(callee) ? callee.name : callee);
|
|
28
|
+
return (
|
|
29
|
+
declaration !== undefined
|
|
30
|
+
&& ts.isVariableDeclaration(declaration)
|
|
31
|
+
&& declaration.name.getText() === "pick"
|
|
32
|
+
&& /\/effect\/(?:src|dist(?:\/dts)?)\/Context\.(?:d\.)?ts$/u.test(declaration.getSourceFile().fileName.replaceAll("\\", "/"))
|
|
33
|
+
);
|
|
34
|
+
}
|
|
35
|
+
|
|
36
|
+
function middlewareMember(expression: ts.Expression): boolean {
|
|
37
|
+
return ts.isPropertyAccessExpression(expression) && expression.name.text === "middleware";
|
|
38
|
+
}
|
|
39
|
+
|
|
40
|
+
function middlewareCall(checker: ts.TypeChecker, callee: ts.Expression): boolean {
|
|
41
|
+
if (middlewareMember(callee)) {
|
|
42
|
+
return true;
|
|
43
|
+
}
|
|
44
|
+
const value = resolvedValue(checker, callee);
|
|
45
|
+
return (
|
|
46
|
+
ts.isCallExpression(value)
|
|
47
|
+
&& ts.isPropertyAccessExpression(value.expression)
|
|
48
|
+
&& value.expression.name.text === "bind"
|
|
49
|
+
&& middlewareMember(value.expression.expression)
|
|
50
|
+
);
|
|
51
|
+
}
|
|
52
|
+
|
|
53
|
+
function referredSymbol(checker: ts.TypeChecker, node: ts.Identifier): ts.Symbol | undefined {
|
|
54
|
+
return ts.isShorthandPropertyAssignment(node.parent) ? checker.getShorthandAssignmentValueSymbol(node.parent) : checker.getSymbolAtLocation(node);
|
|
55
|
+
}
|
|
56
|
+
|
|
57
|
+
function everyReference(checker: ts.TypeChecker, body: ts.Node, name: ts.Identifier, permitted: (reference: ts.Identifier) => boolean): boolean {
|
|
58
|
+
const symbol = checker.getSymbolAtLocation(name);
|
|
59
|
+
function visit(node: ts.Node): boolean {
|
|
60
|
+
if (ts.isIdentifier(node) && node !== name && referredSymbol(checker, node) === symbol && !permitted(node)) {
|
|
61
|
+
return false;
|
|
62
|
+
}
|
|
63
|
+
return ts.forEachChild(node, (child) => !visit(child)) !== true;
|
|
64
|
+
}
|
|
65
|
+
return visit(body);
|
|
66
|
+
}
|
|
67
|
+
|
|
68
|
+
function calledMethod(checker: ts.TypeChecker, member: ts.Expression): boolean {
|
|
69
|
+
if (!(ts.isCallExpression(member.parent) && member.parent.expression === member)) {
|
|
70
|
+
return false;
|
|
71
|
+
}
|
|
72
|
+
return (
|
|
73
|
+
!ts.isPropertyAccessExpression(member)
|
|
74
|
+
|| ((checker.getSymbolAtLocation(member.name)?.flags ?? ts.SymbolFlags.Method) & ts.SymbolFlags.Method) !== 0
|
|
75
|
+
);
|
|
76
|
+
}
|
|
77
|
+
|
|
78
|
+
export function declarationTagParameter(checker: ts.TypeChecker, carries: (type: ts.Type) => boolean) {
|
|
79
|
+
const known = new Map<ts.ParameterDeclaration, boolean>();
|
|
80
|
+
function middlewareTag(node: ts.Node): boolean {
|
|
81
|
+
return checker.getApparentType(checker.getTypeAtLocation(node)).getProperty(RPC_MIDDLEWARE) !== undefined;
|
|
82
|
+
}
|
|
83
|
+
function middlewareSignature(parameter: ts.ParameterDeclaration): boolean {
|
|
84
|
+
const member = ts.isFunctionTypeNode(parameter.parent) ? parameter.parent.parent : parameter.parent;
|
|
85
|
+
return (ts.isPropertySignature(member) || ts.isMethodSignature(member)) && member.name.getText() === "middleware" && middlewareTag(parameter);
|
|
86
|
+
}
|
|
87
|
+
function forwardsDeclaration(call: ts.CallExpression, argument: ts.Expression): boolean {
|
|
88
|
+
const target = checker.getResolvedSignature(call)?.declaration?.parameters[call.arguments.indexOf(argument)];
|
|
89
|
+
return target !== undefined && ts.isParameter(target) && !ts.isSpreadElement(argument) && declarationOnly(target);
|
|
90
|
+
}
|
|
91
|
+
function declares(value: ts.Expression): boolean {
|
|
92
|
+
const argument = ts.isSpreadElement(value.parent) ? value.parent : value;
|
|
93
|
+
const call = argument.parent;
|
|
94
|
+
if (!(ts.isCallExpression(call) && call.arguments.includes(argument))) {
|
|
95
|
+
return false;
|
|
96
|
+
}
|
|
97
|
+
return (
|
|
98
|
+
contextPick(checker, call.expression)
|
|
99
|
+
|| (middlewareCall(checker, call.expression) && middlewareTag(value))
|
|
100
|
+
|| forwardsDeclaration(call, argument)
|
|
101
|
+
);
|
|
102
|
+
}
|
|
103
|
+
function carrier(value: ts.Expression): ts.Expression {
|
|
104
|
+
const parent = value.parent;
|
|
105
|
+
if (ts.isNonNullExpression(parent) || ts.isParenthesizedExpression(parent)) {
|
|
106
|
+
return carrier(parent);
|
|
107
|
+
}
|
|
108
|
+
if ((ts.isPropertyAccessExpression(parent) || ts.isElementAccessExpression(parent)) && parent.expression === value) {
|
|
109
|
+
return carries(checker.getTypeAtLocation(parent)) ? carrier(parent) : parent;
|
|
110
|
+
}
|
|
111
|
+
return value;
|
|
112
|
+
}
|
|
113
|
+
function onlyDeclared(body: ts.Node, name: ts.BindingName, seen: { declared: boolean }): boolean {
|
|
114
|
+
if (!ts.isIdentifier(name)) {
|
|
115
|
+
return name.elements.every(
|
|
116
|
+
(element) => ts.isOmittedExpression(element) || !carries(checker.getTypeAtLocation(element.name)) || onlyDeclared(body, element.name, seen),
|
|
117
|
+
);
|
|
118
|
+
}
|
|
119
|
+
return everyReference(checker, body, name, (reference) => {
|
|
120
|
+
const value = carrier(reference);
|
|
121
|
+
if (!carries(checker.getTypeAtLocation(value))) {
|
|
122
|
+
return !calledMethod(checker, value);
|
|
123
|
+
}
|
|
124
|
+
if (ts.isVariableDeclaration(value.parent) && value.parent.initializer === value) {
|
|
125
|
+
return onlyDeclared(body, value.parent.name, seen);
|
|
126
|
+
}
|
|
127
|
+
const declaration = declares(value);
|
|
128
|
+
seen.declared ||= declaration;
|
|
129
|
+
return declaration;
|
|
130
|
+
});
|
|
131
|
+
}
|
|
132
|
+
function declarationOnly(declared: ts.ParameterDeclaration): boolean {
|
|
133
|
+
const parameter = implementationParameter(checker, declared);
|
|
134
|
+
const cached = known.get(parameter);
|
|
135
|
+
if (cached !== undefined) {
|
|
136
|
+
return cached;
|
|
137
|
+
}
|
|
138
|
+
known.set(parameter, false);
|
|
139
|
+
const body = functionBody(parameter);
|
|
140
|
+
const seen = { declared: false };
|
|
141
|
+
const result = middlewareSignature(parameter) || (body !== undefined && onlyDeclared(body, parameter.name, seen) && seen.declared);
|
|
142
|
+
known.set(parameter, result);
|
|
143
|
+
return result;
|
|
144
|
+
}
|
|
145
|
+
return declarationOnly;
|
|
146
|
+
}
|
|
@@ -8,7 +8,7 @@ function supplied(signature: ts.Signature, local: ReadonlySet<ts.SourceFile>): b
|
|
|
8
8
|
return signature.declaration !== undefined && !local.has(signature.declaration.getSourceFile());
|
|
9
9
|
}
|
|
10
10
|
|
|
11
|
-
function wrapsEffectFunction(checker: ts.TypeChecker, expression: ts.Expression): boolean {
|
|
11
|
+
export function wrapsEffectFunction(checker: ts.TypeChecker, expression: ts.Expression): boolean {
|
|
12
12
|
let callee = expression;
|
|
13
13
|
let value: ts.Node = ts.isIdentifier(callee) ? resolvedValue(checker, callee) : callee;
|
|
14
14
|
while (ts.isCallExpression(value)) {
|
|
@@ -4,6 +4,7 @@ import { type Project, projectsFor } from "#adapters/imports/projects.ts";
|
|
|
4
4
|
import { resolveImport } from "#adapters/imports/resolve.ts";
|
|
5
5
|
import type { Departure } from "#imports/departures.ts";
|
|
6
6
|
import type { ImportRequest } from "#imports/extract.ts";
|
|
7
|
+
import { isPackageRootConfig } from "#imports/isTooling.ts";
|
|
7
8
|
import { type SpecifierSite, specifierSites } from "#imports/specifiers.ts";
|
|
8
9
|
import { packageOf, type WorkspacePackage } from "#imports/workspace.ts";
|
|
9
10
|
import type { RuleInputs } from "#rule.ts";
|
|
@@ -36,7 +37,12 @@ function departureAt(context: FileContext, site: SpecifierSite): Departure | und
|
|
|
36
37
|
const target = resolveImport(context.root, noAmbient, request, context.from, context.project);
|
|
37
38
|
const local = target?.kind === "file" ? target.path : undefined;
|
|
38
39
|
const owner = local === undefined ? undefined : packageOf(context.packages, local);
|
|
39
|
-
const
|
|
40
|
+
const home = packageOf(context.packages, context.path);
|
|
41
|
+
const directory = home?.directory ?? ".";
|
|
42
|
+
if (local !== undefined && isPackageRootConfig(directory, context.path) && isPackageRootConfig(directory, local)) {
|
|
43
|
+
return undefined;
|
|
44
|
+
}
|
|
45
|
+
const workspace = owner !== undefined && owner !== home ? owner.name : undefined;
|
|
40
46
|
return { ...site, file: context.path, installed: target?.kind === "external" ? target.package : undefined, workspace };
|
|
41
47
|
}
|
|
42
48
|
|
|
@@ -1,9 +1,13 @@
|
|
|
1
1
|
import { posix } from "node:path";
|
|
2
2
|
import preset from "#biome-preset" with { type: "json" };
|
|
3
3
|
|
|
4
|
-
const PATTERNS =
|
|
5
|
-
|
|
6
|
-
)
|
|
4
|
+
const PATTERNS = [
|
|
5
|
+
...preset.overrides.flatMap((override) =>
|
|
6
|
+
override.includes.includes("**/*.config.*") && override.linter?.rules?.style?.noDefaultExport === "off" ? override.includes : [],
|
|
7
|
+
),
|
|
8
|
+
// @shivaedev/deploy loads this module from its default path, so no import reaches it.
|
|
9
|
+
"**/.railway/postgres-schedules.ts",
|
|
10
|
+
];
|
|
7
11
|
|
|
8
12
|
export function isToolConfig(path: string): boolean {
|
|
9
13
|
return PATTERNS.some((pattern) => posix.matchesGlob(path, pattern));
|
|
@@ -2,10 +2,12 @@ import { Effect } from "effect";
|
|
|
2
2
|
import type { ImportAnalysisFailure } from "#adapters/ImportAnalysisFailure.ts";
|
|
3
3
|
import { readPackageManifest } from "#adapters/manifestInventory.ts";
|
|
4
4
|
import { importGraph } from "#imports/graph.ts";
|
|
5
|
+
import { isPackageRootConfig } from "#imports/isTooling.ts";
|
|
5
6
|
import { packageNameOf } from "#imports/packageName.ts";
|
|
6
7
|
import { packageOf } from "#imports/workspace.ts";
|
|
7
8
|
import { testName } from "#naming/testName.ts";
|
|
8
9
|
import type { Finding, RuleInputs } from "#rule.ts";
|
|
10
|
+
import { entryModules } from "#rules/effect/boundaryReference.ts";
|
|
9
11
|
|
|
10
12
|
const CLIENT_RENDERING_LIBRARIES = new Set([
|
|
11
13
|
"react",
|
|
@@ -21,10 +23,15 @@ const CLIENT_RENDERING_LIBRARIES = new Set([
|
|
|
21
23
|
"tailwind-merge",
|
|
22
24
|
]);
|
|
23
25
|
|
|
24
|
-
|
|
26
|
+
// Path functions compute strings and touch no file system or process state, so they need no adapter.
|
|
27
|
+
const PURE_BUILTINS = new Set(["node:path", "node:path/posix", "node:path/win32"]);
|
|
28
|
+
|
|
29
|
+
function exempt(directory: string, path: string, name: string): boolean {
|
|
25
30
|
return (
|
|
26
31
|
/(?:^|\/)(?:adapters|test-support)\//u.test(path)
|
|
27
|
-
|| (name
|
|
32
|
+
|| PURE_BUILTINS.has(name)
|
|
33
|
+
|| isPackageRootConfig(directory, path)
|
|
34
|
+
|| (name === "vitest" && testName(path) !== undefined)
|
|
28
35
|
|| name === "effect"
|
|
29
36
|
|| name.startsWith("@effect/")
|
|
30
37
|
|| name.startsWith("@shivaedev/")
|
|
@@ -58,23 +65,23 @@ export const outsideImportFindings = Effect.fn("Imports.outsideImportFindings")(
|
|
|
58
65
|
.filter((edge) => edge.missing === undefined && !/^[.#/]/u.test(edge.specifier))
|
|
59
66
|
.map((edge) => ({ ...edge, name: packageNameOf(edge.specifier) })),
|
|
60
67
|
];
|
|
61
|
-
|
|
68
|
+
const outside = sites.filter((site) => {
|
|
62
69
|
const directory = packageOf(graph.packages, site.from)?.directory ?? ".";
|
|
63
|
-
|
|
70
|
+
return !(
|
|
64
71
|
workspace.has(site.name)
|
|
65
72
|
|| site.type
|
|
66
73
|
|| site.kind !== "import"
|
|
67
|
-
|| exempt(site.from, site.name)
|
|
74
|
+
|| exempt(directory, site.from, site.name)
|
|
68
75
|
|| !(site.name.startsWith("node:") || runtime.get(directory)?.has(site.name))
|
|
69
|
-
)
|
|
70
|
-
return [];
|
|
71
|
-
}
|
|
72
|
-
return [
|
|
73
|
-
{
|
|
74
|
-
file: site.from,
|
|
75
|
-
line: site.line,
|
|
76
|
-
message: `Imports outside library "${site.specifier}" as a value. Move the integration into an adapters/ module with explicit imports that exposes Effect values; use import type for types. Read environment variables with Config instead of process.env, including in adapters/.`,
|
|
77
|
-
},
|
|
78
|
-
];
|
|
76
|
+
);
|
|
79
77
|
});
|
|
78
|
+
const processImporters = new Set(outside.flatMap((site) => (site.name === "node:process" ? [site.from] : [])));
|
|
79
|
+
const entries = entryModules(inputs.sources.filter((file) => processImporters.has(file.path)));
|
|
80
|
+
return outside
|
|
81
|
+
.filter((site) => !(site.name === "node:process" && entries.has(site.from)))
|
|
82
|
+
.map((site) => ({
|
|
83
|
+
file: site.from,
|
|
84
|
+
line: site.line,
|
|
85
|
+
message: `Imports outside library "${site.specifier}" as a value. Move the integration into an adapters/ module with explicit imports that exposes Effect values; use import type for types. Read environment variables with Config instead of process.env, including in adapters/.`,
|
|
86
|
+
}));
|
|
80
87
|
});
|
|
@@ -0,0 +1,22 @@
|
|
|
1
|
+
import ts from "typescript";
|
|
2
|
+
import { wrapsEffectFunction } from "#adapters/frameworkCallback.ts";
|
|
3
|
+
|
|
4
|
+
function effectBody(checker: ts.TypeChecker, node: ts.Node): boolean {
|
|
5
|
+
if ((ts.isFunctionDeclaration(node) || ts.isFunctionExpression(node) || ts.isMethodDeclaration(node)) && node.asteriskToken !== undefined) {
|
|
6
|
+
return true;
|
|
7
|
+
}
|
|
8
|
+
return (
|
|
9
|
+
(ts.isArrowFunction(node) || ts.isFunctionExpression(node))
|
|
10
|
+
&& ts.isCallExpression(node.parent)
|
|
11
|
+
&& wrapsEffectFunction(checker, node.parent.expression)
|
|
12
|
+
);
|
|
13
|
+
}
|
|
14
|
+
|
|
15
|
+
export function plainFunction(checker: ts.TypeChecker, fn: ts.Node): boolean {
|
|
16
|
+
for (let node: ts.Node | undefined = fn; node !== undefined; node = node.parent) {
|
|
17
|
+
if (effectBody(checker, node)) {
|
|
18
|
+
return false;
|
|
19
|
+
}
|
|
20
|
+
}
|
|
21
|
+
return true;
|
|
22
|
+
}
|
|
@@ -27,7 +27,7 @@ export function effectApi(checker: ts.TypeChecker, node: ts.Node, name: string):
|
|
|
27
27
|
);
|
|
28
28
|
}
|
|
29
29
|
|
|
30
|
-
function declarationOf(checker: ts.TypeChecker, node: ts.Node): ts.Declaration | undefined {
|
|
30
|
+
export function declarationOf(checker: ts.TypeChecker, node: ts.Node): ts.Declaration | undefined {
|
|
31
31
|
const symbol = ts.isShorthandPropertyAssignment(node.parent)
|
|
32
32
|
? checker.getShorthandAssignmentValueSymbol(node.parent)
|
|
33
33
|
: checker.getSymbolAtLocation(node);
|
|
@@ -0,0 +1,18 @@
|
|
|
1
|
+
import ts from "typescript";
|
|
2
|
+
import { browserLibraryType } from "#adapters/browserLibraryType.ts";
|
|
3
|
+
|
|
4
|
+
export function valueType(type: ts.Type): boolean {
|
|
5
|
+
return (
|
|
6
|
+
browserLibraryType(type)
|
|
7
|
+
|| (type.flags
|
|
8
|
+
& (ts.TypeFlags.Any
|
|
9
|
+
| ts.TypeFlags.Unknown
|
|
10
|
+
| ts.TypeFlags.Never
|
|
11
|
+
| ts.TypeFlags.StringLike
|
|
12
|
+
| ts.TypeFlags.NumberLike
|
|
13
|
+
| ts.TypeFlags.BooleanLike
|
|
14
|
+
| ts.TypeFlags.ESSymbolLike
|
|
15
|
+
| ts.TypeFlags.BigIntLike))
|
|
16
|
+
!== 0
|
|
17
|
+
);
|
|
18
|
+
}
|
package/src/imports/isTooling.ts
CHANGED
|
@@ -4,8 +4,12 @@ const TOOL_FOLDERS = new Set(["script", "scripts", "tooling"]);
|
|
|
4
4
|
|
|
5
5
|
const CONFIG_FILE = /(?:^|\.)config\.[cm]?[jt]sx?$/u;
|
|
6
6
|
|
|
7
|
-
export function
|
|
7
|
+
export function isPackageRootConfig(directory: string, path: string): boolean {
|
|
8
8
|
const local = posix.relative(directory, path);
|
|
9
|
-
|
|
10
|
-
|
|
9
|
+
return !local.includes("/") && CONFIG_FILE.test(local);
|
|
10
|
+
}
|
|
11
|
+
|
|
12
|
+
export function isTooling(directory: string, path: string): boolean {
|
|
13
|
+
const [folder = ""] = posix.relative(directory, path).split("/");
|
|
14
|
+
return TOOL_FOLDERS.has(folder) || isPackageRootConfig(directory, path);
|
|
11
15
|
}
|
|
@@ -4,7 +4,7 @@ import { defineRule } from "#rule.ts";
|
|
|
4
4
|
export const adapterImports = defineRule({
|
|
5
5
|
check: outsideImportFindings,
|
|
6
6
|
description:
|
|
7
|
-
"Keep value imports of non-Effect runtime dependencies, peers, optional dependencies and Node builtins in adapters/. Type-only imports, workspace modules, test-support/ kits, Effect and @shivaedev packages, supported UI, routing and styling libraries in client/ folders and
|
|
7
|
+
"Keep value imports of non-Effect runtime dependencies, peers, optional dependencies and Node builtins in adapters/. Type-only imports, pure node:path calls (including node:path/posix and node:path/win32) anywhere, workspace modules, test-support/ kits, tool configs directly in a package's folder, Effect and @shivaedev packages, supported UI, routing and styling libraries in client/ folders, Vitest in tests and specs, and node:process in entry modules (cli/main/entry files, runMain callers and the import.meta.url === process.argv[1] guard) are accepted. Recharts is the stack's charting library, accepted in client/ folders; build charts with shadcn's Chart component (ChartContainer and friends) rather than raw recharts primitives where shadcn covers the case. Libraries that perform I/O or manage external state, and file-system and process builtins, still need adapters/. Move integrations into adapters/ and expose Effect values. No config exceptions or inline suppressions; baseline existing debt.",
|
|
8
8
|
id: "effect/adapter-imports",
|
|
9
9
|
registrable: false,
|
|
10
10
|
});
|
|
@@ -1,5 +1,8 @@
|
|
|
1
1
|
import { join } from "node:path";
|
|
2
|
+
import { Effect } from "effect";
|
|
2
3
|
import ts from "typescript";
|
|
4
|
+
import { isPackageRootConfig } from "#imports/isTooling.ts";
|
|
5
|
+
import { packageOf, workspacePackages } from "#imports/workspace.ts";
|
|
3
6
|
import { defineRule, type Finding, type RuleInputs } from "#rule.ts";
|
|
4
7
|
import { boundaryCalls } from "#rules/effect/boundaryCalls.ts";
|
|
5
8
|
import { boundaryEntryPoint } from "#rules/effect/boundaryReference.ts";
|
|
@@ -54,9 +57,6 @@ function checkBoundary(inputs: RuleInputs): readonly Finding[] {
|
|
|
54
57
|
const checker = program.getTypeChecker();
|
|
55
58
|
const call = boundaryCalls(checker);
|
|
56
59
|
return inputs.sources.flatMap((file) => {
|
|
57
|
-
if (/(?:^|\/)(?:adapters|test-support)\//u.test(file.path)) {
|
|
58
|
-
return [];
|
|
59
|
-
}
|
|
60
60
|
const source = parse(file) === undefined ? undefined : program.getSourceFile(join(inputs.root, file.path));
|
|
61
61
|
const findings: Finding[] = [];
|
|
62
62
|
const entryPoint = source !== undefined && boundaryEntryPoint(file.path, source, checker);
|
|
@@ -79,21 +79,29 @@ function checkBoundary(inputs: RuleInputs): readonly Finding[] {
|
|
|
79
79
|
}
|
|
80
80
|
|
|
81
81
|
export const effectBoundary = defineRule({
|
|
82
|
-
check: (inputs) =>
|
|
83
|
-
|
|
84
|
-
|
|
85
|
-
|
|
86
|
-
|
|
87
|
-
|
|
88
|
-
|
|
89
|
-
|
|
90
|
-
|
|
91
|
-
|
|
92
|
-
|
|
93
|
-
|
|
94
|
-
|
|
82
|
+
check: (inputs) =>
|
|
83
|
+
Effect.map(
|
|
84
|
+
Effect.promise(() => workspacePackages(inputs)),
|
|
85
|
+
(packages) => {
|
|
86
|
+
const groups = new Map<string, RuleInputs["sources"][number][]>();
|
|
87
|
+
for (const source of inputs.sources) {
|
|
88
|
+
if (
|
|
89
|
+
/(?:^|\/)(?:adapters|test-support)\//u.test(source.path)
|
|
90
|
+
|| !/\.[cm]?[jt]sx?$/u.test(source.path)
|
|
91
|
+
|| isPackageRootConfig(packageOf(packages, source.path)?.directory ?? ".", source.path)
|
|
92
|
+
) {
|
|
93
|
+
continue;
|
|
94
|
+
}
|
|
95
|
+
const group = /^(?:packages|examples)\/[^/]+/u.exec(source.path)?.[0] ?? ".";
|
|
96
|
+
const sources = groups.get(group) ?? [];
|
|
97
|
+
sources.push(source);
|
|
98
|
+
groups.set(group, sources);
|
|
99
|
+
}
|
|
100
|
+
return [...groups.values()].flatMap((sources) => checkBoundary({ ...inputs, sources }));
|
|
101
|
+
},
|
|
102
|
+
),
|
|
95
103
|
description:
|
|
96
|
-
"Use Effect instead of Promise syntax and parameters, synchronous Node IO, throwing helper calls or Effect.sync with throwing APIs. Runners belong at entry points (including main.tsx and entry.tsx), tool configs and tests. Within Effect code, adapters/ and test-support/ folders are exempt; calls to throwing helpers defined in adapters/ are accepted. Use Effect services and tagged errors; bridge outside libraries in adapters/. No config exceptions or inline suppressions; baseline existing debt.",
|
|
104
|
+
"Use Effect instead of Promise syntax and parameters, synchronous Node IO, throwing helper calls or Effect.sync with throwing APIs. Runners belong at entry points (including main.tsx and entry.tsx), tool configs and tests. Within Effect code, adapters/ and test-support/ folders and tool configs directly in a package's folder, which their tool loads from that fixed path, are exempt; calls to throwing helpers defined in adapters/ are accepted. Use Effect services and tagged errors; bridge outside libraries in adapters/. No config exceptions or inline suppressions; baseline existing debt.",
|
|
97
105
|
id: "effect/boundary",
|
|
98
106
|
registrable: false,
|
|
99
107
|
});
|
|
@@ -1,4 +1,6 @@
|
|
|
1
1
|
import ts from "typescript";
|
|
2
|
+
import type { SourceFile } from "#rule.ts";
|
|
3
|
+
import { parse } from "#rules/parse.ts";
|
|
2
4
|
|
|
3
5
|
function importedReference(declaration: ts.Declaration): string | undefined {
|
|
4
6
|
if (ts.isImportSpecifier(declaration)) {
|
|
@@ -65,8 +67,15 @@ export function boundaryReference(checker: ts.TypeChecker, node: ts.Node, seen =
|
|
|
65
67
|
return ts.isIdentifier(node) ? symbolReference(checker, node, seen) : undefined;
|
|
66
68
|
}
|
|
67
69
|
|
|
68
|
-
|
|
69
|
-
|
|
70
|
+
const ENTRY_NAME = /(?:^|\/)(?:cli|main|entry|[^/]+-cli)\.[cm]?[jt]sx?$/u;
|
|
71
|
+
|
|
72
|
+
const RUNNER_HOST = /\.(?:config|test|spec)\.[cm]?[jt]sx?$/u;
|
|
73
|
+
|
|
74
|
+
export function entryModule(path: string, source: ts.SourceFile, checker: ts.TypeChecker): boolean {
|
|
75
|
+
if (RUNNER_HOST.test(path)) {
|
|
76
|
+
return false;
|
|
77
|
+
}
|
|
78
|
+
if (ENTRY_NAME.test(path)) {
|
|
70
79
|
return true;
|
|
71
80
|
}
|
|
72
81
|
function visit(node: ts.Node): boolean {
|
|
@@ -83,3 +92,22 @@ export function boundaryEntryPoint(path: string, source: ts.SourceFile, checker:
|
|
|
83
92
|
}
|
|
84
93
|
return visit(source);
|
|
85
94
|
}
|
|
95
|
+
|
|
96
|
+
export function boundaryEntryPoint(path: string, source: ts.SourceFile, checker: ts.TypeChecker): boolean {
|
|
97
|
+
return RUNNER_HOST.test(path) || entryModule(path, source, checker);
|
|
98
|
+
}
|
|
99
|
+
|
|
100
|
+
// Entry markers name their imports, so each module binds on its own without resolving the program behind it.
|
|
101
|
+
export function entryModules(sources: readonly SourceFile[]): ReadonlySet<string> {
|
|
102
|
+
const options: ts.CompilerOptions = { allowJs: true, noLib: true, noResolve: true, types: [] };
|
|
103
|
+
const host = ts.createCompilerHost(options);
|
|
104
|
+
const parsed = new Map(
|
|
105
|
+
sources.flatMap((file) => {
|
|
106
|
+
const source = parse(file);
|
|
107
|
+
return source === undefined ? [] : [[file.path, source] as const];
|
|
108
|
+
}),
|
|
109
|
+
);
|
|
110
|
+
host.getSourceFile = (path) => parsed.get(path);
|
|
111
|
+
const checker = ts.createProgram([...parsed.keys()], options, host).getTypeChecker();
|
|
112
|
+
return new Set([...parsed].flatMap(([path, source]) => (entryModule(path, source, checker) ? [path] : [])));
|
|
113
|
+
}
|
|
@@ -1,9 +1,11 @@
|
|
|
1
1
|
import { relative } from "node:path";
|
|
2
2
|
import ts from "typescript";
|
|
3
|
+
import { declarationTagParameter } from "#adapters/declarationTagParameter.ts";
|
|
3
4
|
import { foreignResources } from "#adapters/foreignResources.ts";
|
|
4
5
|
import { frameworkCallback, parameterSite } from "#adapters/frameworkCallback.ts";
|
|
5
6
|
import { localFunctions } from "#adapters/localFunctions.ts";
|
|
6
7
|
import { ownedServiceParameters } from "#adapters/ownedServiceParameters.ts";
|
|
8
|
+
import { plainFunction } from "#adapters/plainFunction.ts";
|
|
7
9
|
import { reactComponent, reactPropParameters } from "#adapters/reactComponent.ts";
|
|
8
10
|
import type { Finding } from "#rule.ts";
|
|
9
11
|
import { layerConstructor } from "#rules/effect/layerConstructor.ts";
|
|
@@ -33,12 +35,14 @@ export function serviceFindings(
|
|
|
33
35
|
const resource = foreignResources(checker, sources);
|
|
34
36
|
const owned = ownedServiceParameters(checker, sources);
|
|
35
37
|
const props = reactPropParameters(checker, sources);
|
|
38
|
+
const declarationTag = declarationTagParameter(checker, services.carries);
|
|
36
39
|
const findings = new Map<ts.ParameterDeclaration, Finding>();
|
|
37
40
|
const visited = new Set<ts.Type>();
|
|
38
41
|
const activeSignatures = new Set<NonNullable<ts.Signature["declaration"]>>();
|
|
39
42
|
const local = new Set(sources);
|
|
40
43
|
function parameterFinding(symbol: ts.Symbol, signature?: ts.Signature): void {
|
|
41
|
-
|
|
44
|
+
const type = checker.getTypeOfSymbol(symbol);
|
|
45
|
+
if (!services.carries(type)) {
|
|
42
46
|
return;
|
|
43
47
|
}
|
|
44
48
|
for (const parameter of symbol.declarations ?? []) {
|
|
@@ -47,6 +51,8 @@ export function serviceFindings(
|
|
|
47
51
|
|| implementationParameter(checker, parameter, services)
|
|
48
52
|
|| resource(parameter)
|
|
49
53
|
|| owned(parameter)
|
|
54
|
+
|| (plainFunction(checker, parameter.parent) && !services.carriesBeyondClientHandles(type))
|
|
55
|
+
|| declarationTag(parameter)
|
|
50
56
|
|| frameworkCallback(checker, parameter.parent, local)
|
|
51
57
|
|| reactComponent(checker, parameter.parent)
|
|
52
58
|
|| props.has(parameter)
|
|
@@ -37,7 +37,7 @@ export const serviceParameters = defineRule({
|
|
|
37
37
|
return findings;
|
|
38
38
|
}),
|
|
39
39
|
description:
|
|
40
|
-
"Exported and local functions and public methods take services from Effect's environment, including aliases, constraints, inferred/destructured parameters and factory returns. Service keys/classes, non-empty Contexts and implementation shapes are services; Effect/Stream requirements are computations. Service implementation methods, framework callbacks, module-level React components and their props, owned initializer state, foreign host callbacks in object literals and classes, owned foreign adapter resources
|
|
40
|
+
"Exported and local functions and public methods take services from Effect's environment, including aliases, constraints, inferred/destructured parameters and factory returns. Service keys/classes, non-empty Contexts and implementation shapes are services; Effect/Stream requirements are computations. Service implementation methods, framework callbacks, module-level React components and their props, owned initializer state, foreign host callbacks in object literals and classes, owned foreign adapter resources, Layer constructors, registries and RPC clients held by plain functions outside Effect bodies, and tags only handed to middleware declarations or Context.pick are accepted. Within Effect code, test-support/ folders are exempt. The fixed adapters/ convention bridges outside libraries to Effect values; adapters still follow this rule and ambient runtime bans. No config exceptions or inline suppressions; baseline existing debt.",
|
|
41
41
|
id: "effect/service-parameters",
|
|
42
42
|
registrable: false,
|
|
43
43
|
});
|
|
@@ -1,7 +1,8 @@
|
|
|
1
1
|
import ts from "typescript";
|
|
2
|
-
import { browserLibraryType } from "#adapters/browserLibraryType.ts";
|
|
3
2
|
import { callerContextData } from "#adapters/callerContextData.ts";
|
|
3
|
+
import { clientHandle } from "#adapters/clientHandle.ts";
|
|
4
4
|
import { nonEmptyContext } from "#adapters/nonEmptyContext.ts";
|
|
5
|
+
import { valueType } from "#adapters/valueType.ts";
|
|
5
6
|
|
|
6
7
|
const SERVICE = "~effect/Context/Service";
|
|
7
8
|
const CONTEXT = "~effect/Context";
|
|
@@ -86,26 +87,16 @@ export function serviceTypes(checker: ts.TypeChecker, initializerState = false)
|
|
|
86
87
|
function factoryService(type: ts.Type): boolean {
|
|
87
88
|
return !initializerState && type.getCallSignatures().some((signature) => serviceReturn(signature.getReturnType()));
|
|
88
89
|
}
|
|
89
|
-
function
|
|
90
|
-
|
|
91
|
-
|
|
92
|
-
|
|
93
|
-
|
|
94
|
-
|| type.flags
|
|
95
|
-
& (ts.TypeFlags.Any
|
|
96
|
-
| ts.TypeFlags.Unknown
|
|
97
|
-
| ts.TypeFlags.Never
|
|
98
|
-
| ts.TypeFlags.StringLike
|
|
99
|
-
| ts.TypeFlags.NumberLike
|
|
100
|
-
| ts.TypeFlags.BooleanLike
|
|
101
|
-
| ts.TypeFlags.ESSymbolLike
|
|
102
|
-
| ts.TypeFlags.BigIntLike)
|
|
103
|
-
) {
|
|
90
|
+
function exempt(type: ts.Type, handles: boolean): boolean {
|
|
91
|
+
return contextData.has(type) || valueType(type) || (!handles && clientHandle(type));
|
|
92
|
+
}
|
|
93
|
+
function carries(type: ts.Type, handles: boolean, seen = new Set<ts.Type>()): boolean {
|
|
94
|
+
if (seen.has(type) || exempt(type, handles)) {
|
|
104
95
|
return false;
|
|
105
96
|
}
|
|
106
97
|
seen.add(type);
|
|
107
98
|
if (type.isUnionOrIntersection()) {
|
|
108
|
-
return type.types.some((part) => carries(part, seen));
|
|
99
|
+
return type.types.some((part) => carries(part, handles, seen));
|
|
109
100
|
}
|
|
110
101
|
if (type.getProperty(SERVICE) !== undefined) {
|
|
111
102
|
return true;
|
|
@@ -118,14 +109,16 @@ export function serviceTypes(checker: ts.TypeChecker, initializerState = false)
|
|
|
118
109
|
return false;
|
|
119
110
|
}
|
|
120
111
|
const constraint = checker.getBaseConstraintOfType(type);
|
|
121
|
-
if (constraint !== undefined && carries(constraint, seen)) {
|
|
112
|
+
if (constraint !== undefined && carries(constraint, handles, seen)) {
|
|
122
113
|
return true;
|
|
123
114
|
}
|
|
124
115
|
return (
|
|
125
116
|
implementation(type)
|
|
126
117
|
|| factoryService(type)
|
|
127
|
-
|| checker.getIndexInfosOfType(type).some((index) => carries(index.type, seen))
|
|
128
|
-
|| type
|
|
118
|
+
|| checker.getIndexInfosOfType(type).some((index) => carries(index.type, handles, seen))
|
|
119
|
+
|| type
|
|
120
|
+
.getProperties()
|
|
121
|
+
.some((property) => !(property.flags & ts.SymbolFlags.Method) && carries(checker.getTypeOfSymbol(property), handles, seen))
|
|
129
122
|
);
|
|
130
123
|
}
|
|
131
124
|
return {
|
|
@@ -134,10 +127,11 @@ export function serviceTypes(checker: ts.TypeChecker, initializerState = false)
|
|
|
134
127
|
if (known !== undefined) {
|
|
135
128
|
return known;
|
|
136
129
|
}
|
|
137
|
-
const result = carries(type);
|
|
130
|
+
const result = carries(type, true);
|
|
138
131
|
carried.set(type, result);
|
|
139
132
|
return result;
|
|
140
133
|
},
|
|
134
|
+
carriesBeyondClientHandles: (type: ts.Type) => carries(type, false),
|
|
141
135
|
computation,
|
|
142
136
|
implementation,
|
|
143
137
|
remember,
|
|
@@ -24,6 +24,6 @@ export const importsAliased = defineRule({
|
|
|
24
24
|
})),
|
|
25
25
|
),
|
|
26
26
|
description:
|
|
27
|
-
"Import own modules through the package.json `imports` aliases, including same-folder modules. Import other packages by their names and exported paths.",
|
|
27
|
+
"Import own modules through the package.json `imports` aliases, including same-folder modules; tool configs directly in a package's folder, which no alias reaches, may import each other relatively. Import other packages by their names and exported paths.",
|
|
28
28
|
id: "imports/aliased",
|
|
29
29
|
});
|