@effect/language-service 0.49.0 → 0.51.0

package/README.md

@@ -5,6 +5,8 @@ This package implements a TypeScript language service plugin that allows additio
 ## Installation
 
 1. `npm install @effect/language-service --save-dev` in your project
+   - For monorepos: We suggest installing `@effect/language-service` in the monorepo root and configuring it in the root `tsconfig.json` for consistent behavior across all packages
+   - For any other package: Install directly in the package where you want to use it
 2. Inside your tsconfig.json, you should add the plugin configuration as follows:
 ```jsonc
 {
@@ -53,6 +55,7 @@ And you're done! You'll now be able to use a set of refactors and diagnostics th
 - Warn on leaking requirements in Effect services
 - Warn on Scope as requirement of a Layer
 - Warn on subsequent `Effect.provide` anti-pattern
+- Warn when using `Effect.provide` with Layer outside of application entry points
 - Detect wrong `Self` type parameter for APIs like `Effect.Service` or `Schema.TaggedError` and similar 
 - Unnecessary usages of `Effect.gen` or `pipe()`
 - Warn when using `Effect.gen` with the old generator adapter pattern
@@ -64,6 +67,7 @@ And you're done! You'll now be able to use a set of refactors and diagnostics th
 - Warn when `Effect.Service` is used with a primitive type instead of an object type
 - Warn when schema classes override the default constructor behavior
 - Warn when `@effect-diagnostics-next-line` comments have no effect (i.e., they don't suppress any diagnostic)
+- Detect nested function calls that can be converted to pipeable style for better readability
 
 ### Completions
 

package/cli.js

@@ -31198,7 +31198,8 @@ var defaults = {
     pattern: "default",
     skipLeadingPath: ["src/"]
   }],
-  extendedKeyDetection: false
+  extendedKeyDetection: false,
+  pipeableMinArgCount: 1
 };
 function parseKeyPatterns(patterns) {
   const result = [];
@@ -31233,7 +31234,8 @@ function parse4(config2) {
     renames: isObject(config2) && hasProperty(config2, "renames") && isBoolean(config2.renames) ? config2.renames : defaults.renames,
     noExternal: isObject(config2) && hasProperty(config2, "noExternal") && isBoolean(config2.noExternal) ? config2.noExternal : defaults.noExternal,
     keyPatterns: isObject(config2) && hasProperty(config2, "keyPatterns") && isArray(config2.keyPatterns) ? parseKeyPatterns(config2.keyPatterns) : defaults.keyPatterns,
-    extendedKeyDetection: isObject(config2) && hasProperty(config2, "extendedKeyDetection") && isBoolean(config2.extendedKeyDetection) ? config2.extendedKeyDetection : defaults.extendedKeyDetection
+    extendedKeyDetection: isObject(config2) && hasProperty(config2, "extendedKeyDetection") && isBoolean(config2.extendedKeyDetection) ? config2.extendedKeyDetection : defaults.extendedKeyDetection,
+    pipeableMinArgCount: isObject(config2) && hasProperty(config2, "pipeableMinArgCount") && isNumber(config2.pipeableMinArgCount) ? config2.pipeableMinArgCount : defaults.pipeableMinArgCount
   };
 }
 
@@ -33724,6 +33726,74 @@ More info at https://effect.website/docs/requirements-management/layers/#avoidin
   })
 });
 
+// src/diagnostics/missedPipeableOpportunity.ts
+var missedPipeableOpportunity = createDiagnostic({
+  name: "missedPipeableOpportunity",
+  code: 26,
+  severity: "off",
+  apply: fn2("missedPipeableOpportunity.apply")(function* (sourceFile, report) {
+    const ts = yield* service2(TypeScriptApi);
+    const typeChecker = yield* service2(TypeCheckerApi);
+    const typeParser = yield* service2(TypeParser);
+    const options3 = yield* service2(LanguageServicePluginOptions);
+    const nodeToVisit = [sourceFile];
+    const prependNodeToVisit = (node) => {
+      nodeToVisit.unshift(node);
+      return void 0;
+    };
+    const callChainNodes = /* @__PURE__ */ new WeakMap();
+    while (nodeToVisit.length > 0) {
+      const node = nodeToVisit.shift();
+      if (ts.isCallExpression(node) && node.arguments.length === 1 && node.parent) {
+        const parentChain = callChainNodes.get(node.parent) || [];
+        callChainNodes.set(node, parentChain.concat(node));
+      } else if (node.parent && callChainNodes.has(node.parent) && ts.isExpression(node)) {
+        const parentChain = callChainNodes.get(node.parent) || [];
+        const originalParentChain = parentChain.slice();
+        parentChain.push(node);
+        while (parentChain.length > options3.pipeableMinArgCount) {
+          const subject = parentChain.pop();
+          const resultType = typeChecker.getTypeAtLocation(subject);
+          const pipeableType = yield* pipe(typeParser.pipeableType(resultType, subject), orElse14(() => void_8));
+          if (pipeableType) {
+            report({
+              location: parentChain[0],
+              messageText: `Nested function calls can be converted to pipeable style for better readability.`,
+              fixes: [{
+                fixName: "missedPipeableOpportunity_fix",
+                description: "Convert to pipe style",
+                apply: gen3(function* () {
+                  const changeTracker = yield* service2(ChangeTracker);
+                  changeTracker.replaceNode(
+                    sourceFile,
+                    parentChain[0],
+                    ts.factory.createCallExpression(
+                      ts.factory.createPropertyAccessExpression(
+                        subject,
+                        "pipe"
+                      ),
+                      void 0,
+                      pipe(
+                        parentChain,
+                        filter2(ts.isCallExpression),
+                        map4((call) => call.expression),
+                        reverse
+                      )
+                    )
+                  );
+                })
+              }]
+            });
+            originalParentChain.forEach((node2) => callChainNodes.delete(node2));
+            break;
+          }
+        }
+      }
+      ts.forEachChild(node, prependNodeToVisit);
+    }
+  })
+});
+
 // src/diagnostics/missingEffectContext.ts
 var missingEffectContext = createDiagnostic({
   name: "missingEffectContext",
@@ -35003,6 +35073,50 @@ var strictBooleanExpressions = createDiagnostic({
   })
 });
 
+// src/diagnostics/strictEffectProvide.ts
+var strictEffectProvide = createDiagnostic({
+  name: "strictEffectProvide",
+  code: 27,
+  severity: "off",
+  apply: fn2("strictEffectProvide.apply")(function* (sourceFile, report) {
+    const ts = yield* service2(TypeScriptApi);
+    const typeChecker = yield* service2(TypeCheckerApi);
+    const typeParser = yield* service2(TypeParser);
+    const parseEffectProvideWithLayer = (node) => gen3(function* () {
+      if (!ts.isCallExpression(node) || !ts.isPropertyAccessExpression(node.expression) || !ts.isIdentifier(node.expression.name) || ts.idText(node.expression.name) !== "provide" || node.arguments.length === 0) {
+        return yield* typeParserIssue("Not an Effect.provide call");
+      }
+      yield* typeParser.importedEffectModule(node.expression.expression);
+      return yield* firstSuccessOf2(
+        node.arguments.map((arg) => {
+          const argType = typeChecker.getTypeAtLocation(arg);
+          return typeParser.layerType(argType, arg);
+        })
+      );
+    });
+    const nodeToVisit = [];
+    const appendNodeToVisit = (node) => {
+      nodeToVisit.push(node);
+      return void 0;
+    };
+    ts.forEachChild(sourceFile, appendNodeToVisit);
+    while (nodeToVisit.length > 0) {
+      const node = nodeToVisit.shift();
+      ts.forEachChild(node, appendNodeToVisit);
+      if (ts.isCallExpression(node)) {
+        const layerCheck = yield* pipe(parseEffectProvideWithLayer(node), option4);
+        if (isSome2(layerCheck)) {
+          report({
+            location: node,
+            messageText: "Effect.provide with a Layer should only be used at application entry points. If this is an entry point, you can safely disable this diagnostic. Otherwise, using Effect.provide may break scope lifetimes. Compose all layers at your entry point and provide them at once.",
+            fixes: []
+          });
+        }
+      }
+    }
+  })
+});
+
 // src/diagnostics/tryCatchInEffectGen.ts
 var tryCatchInEffectGen = createDiagnostic({
   name: "tryCatchInEffectGen",
@@ -35292,7 +35406,9 @@ var diagnostics = [
   overriddenSchemaConstructor,
   unsupportedServiceAccessors,
   nonObjectEffectServiceType,
-  deterministicKeys
+  deterministicKeys,
+  missedPipeableOpportunity,
+  strictEffectProvide
 ];
 
 // src/cli/diagnostics.ts