@effect/language-service 0.28.0 → 0.28.2

package/package.json

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

package/transform.js

@@ -2542,6 +2542,47 @@ function make2(ts, typeChecker) {
     "TypeParser.scopeType",
     (type) => type
   );
+  const promiseLike = cachedBy(
+    function(type, atLocation) {
+      const thenProperty = type.getProperty("then");
+      if (!thenProperty) return typeParserIssue("not a promise - missing then property", type, atLocation);
+      const thenType = typeChecker.getTypeOfSymbolAtLocation(thenProperty, atLocation);
+      if (!thenType) return typeParserIssue("not a promise - missing then property", type, atLocation);
+      for (const callSignature of thenType.getCallSignatures()) {
+        const parameter = callSignature.parameters[0];
+        if (!parameter) continue;
+        const parameterType = callSignature.getTypeParameterAtPosition(0);
+        if (!parameterType) continue;
+        let callbackCallSignatures = [];
+        let toTest = [parameterType];
+        while (toTest.length > 0) {
+          const type2 = toTest.shift();
+          if (!type2) continue;
+          const callSignatures = type2.getCallSignatures();
+          callbackCallSignatures = callbackCallSignatures.concat(callSignatures);
+          if (type2.isUnion()) {
+            toTest = toTest.concat(type2.types);
+          }
+        }
+        for (const callableType of callbackCallSignatures) {
+          const callbackParameter = callableType.parameters[0];
+          if (!callbackParameter) {
+            continue;
+          }
+          const callbackParameterType = callableType.getTypeParameterAtPosition(0);
+          if (!callbackParameterType) {
+            continue;
+          }
+          return succeed({
+            type: callbackParameterType
+          });
+        }
+      }
+      return typeParserIssue("not a promise", type, atLocation);
+    },
+    "TypeParser.promiseLike",
+    (type) => type
+  );
   return {
     effectType,
     strictEffectType,
@@ -2557,7 +2598,8 @@ function make2(ts, typeChecker) {
     contextTag,
     pipeableType,
     pipeCall,
-    scopeType
+    scopeType,
+    promiseLike
   };
 }
 
@@ -3320,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",
@@ -3781,7 +3927,8 @@ var diagnostics = [
   scopeInLayerEffect,
   effectInVoidSuccess,
   unnecessaryPipeChain,
-  strictBooleanExpressions
+  strictBooleanExpressions,
+  multipleEffectProvide
 ];
 
 // src/transform.ts