@effect/language-service 0.28.1 → 0.28.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effect/language-service",
-  "version": "0.28.1",
+  "version": "0.28.2",
   "description": "A Language-Service Plugin to Refactor and Diagnostic effect-ts projects",
   "main": "index.cjs",
   "bin": {

package/transform.js

@@ -3362,6 +3362,110 @@ var missingStarInYieldEffectGen = createDiagnostic({
   })
 });
 
+// src/diagnostics/multipleEffectProvide.ts
+var multipleEffectProvide = createDiagnostic({
+  name: "multipleEffectProvide",
+  code: 18,
+  severity: "warning",
+  apply: fn("multipleEffectProvide.apply")(function* (sourceFile, report) {
+    const ts = yield* service(TypeScriptApi);
+    const typeChecker = yield* service(TypeCheckerApi);
+    const typeParser = yield* service(TypeParser);
+    const effectModuleIdentifier = yield* pipe(
+      findImportedModuleIdentifierByPackageAndNameOrBarrel(
+        sourceFile,
+        "effect",
+        "Effect"
+      ),
+      map3((_) => _.text),
+      orElse2(() => succeed("Effect"))
+    );
+    const layerModuleIdentifier = yield* pipe(
+      findImportedModuleIdentifierByPackageAndNameOrBarrel(
+        sourceFile,
+        "effect",
+        "Layer"
+      ),
+      map3((_) => _.text),
+      orElse2(() => succeed("Layer"))
+    );
+    const parseEffectProvideLayer = (node) => {
+      if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && ts.isIdentifier(node.expression.name) && node.expression.name.text === "provide" && node.arguments.length > 0) {
+        const layer = node.arguments[0];
+        const type = typeChecker.getTypeAtLocation(layer);
+        return pipe(
+          typeParser.importedEffectModule(node.expression.expression),
+          flatMap2(() => typeParser.layerType(type, layer)),
+          map3(() => ({ layer, node })),
+          orElse2(() => void_)
+        );
+      }
+      return void_;
+    };
+    const parsePipeCall = (node) => gen(function* () {
+      const { args: args2 } = yield* typeParser.pipeCall(node);
+      let currentChunk = 0;
+      const previousLayers = [[]];
+      for (const pipeArg of args2) {
+        const parsedProvide = yield* parseEffectProvideLayer(pipeArg);
+        if (parsedProvide) {
+          previousLayers[currentChunk].push(parsedProvide);
+        } else {
+          currentChunk++;
+          previousLayers.push([]);
+        }
+      }
+      for (const chunk of previousLayers) {
+        if (chunk.length < 2) continue;
+        report({
+          node: chunk[0].node,
+          messageText: "Calling multiple subsequent times Effect.provide is an anti-pattern and can lead to service lifecycle issues. You should combine the layers and provide them once instead.",
+          fixes: [{
+            fixName: "multipleEffectProvide_fix",
+            description: "Combine into a single provide",
+            apply: gen(function* () {
+              const changeTracker = yield* service(ChangeTracker);
+              changeTracker.deleteRange(sourceFile, {
+                pos: chunk[0].node.getStart(sourceFile),
+                end: chunk[chunk.length - 1].node.getEnd()
+              });
+              const newNode = ts.factory.createCallExpression(
+                ts.factory.createPropertyAccessExpression(
+                  ts.factory.createIdentifier(effectModuleIdentifier),
+                  ts.factory.createIdentifier("provide")
+                ),
+                void 0,
+                [ts.factory.createCallExpression(
+                  ts.factory.createPropertyAccessExpression(
+                    ts.factory.createIdentifier(layerModuleIdentifier),
+                    ts.factory.createIdentifier("mergeAll")
+                  ),
+                  void 0,
+                  chunk.map((c) => c.layer)
+                )]
+              );
+              changeTracker.insertNodeAt(sourceFile, chunk[0].node.getStart(sourceFile), newNode);
+            })
+          }]
+        });
+      }
+    });
+    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)) {
+        yield* pipe(parsePipeCall(node), ignore);
+      }
+    }
+  })
+});
+
 // src/diagnostics/returnEffectInGen.ts
 var returnEffectInGen = createDiagnostic({
   name: "returnEffectInGen",
@@ -3823,7 +3927,8 @@ var diagnostics = [
   scopeInLayerEffect,
   effectInVoidSuccess,
   unnecessaryPipeChain,
-  strictBooleanExpressions
+  strictBooleanExpressions,
+  multipleEffectProvide
 ];
 
 // src/transform.ts