@effect/language-service 0.37.0 → 0.38.0

package/index.js

@@ -11520,6 +11520,301 @@ var functionToArrow = createRefactor({
   })
 });
 
+// src/refactors/layerMagic.ts
+function sortDependencies(nodes) {
+  const result = [];
+  const visited = /* @__PURE__ */ new Set();
+  const visiting = /* @__PURE__ */ new Set();
+  const cycles = [];
+  const providesMap = /* @__PURE__ */ new Map();
+  Object.entries(nodes).forEach(([nodeId, node]) => {
+    node.provides.forEach((service2) => {
+      if (!providesMap.has(service2)) {
+        providesMap.set(service2, []);
+      }
+      providesMap.get(service2).push(nodeId);
+    });
+  });
+  providesMap.forEach((nodeIds) => {
+    nodeIds.sort((a, b) => {
+      const nodeA = nodes[a];
+      const nodeB = nodes[b];
+      return nodeA.requires.length - nodeB.requires.length;
+    });
+  });
+  const visit = (nodeId, path) => {
+    if (visited.has(nodeId)) {
+      return;
+    }
+    if (visiting.has(nodeId)) {
+      const cycleStart = path.indexOf(nodeId);
+      const cycle = path.slice(cycleStart).concat([nodeId]);
+      const cycleServices = cycle.map((id) => {
+        const node2 = nodes[id];
+        return `${node2.provides.join(", ")} (requires: ${node2.requires.join(", ")})`;
+      });
+      cycles.push(cycleServices);
+      return;
+    }
+    visiting.add(nodeId);
+    const currentPath = [...path, nodeId];
+    const dependencies = /* @__PURE__ */ new Set();
+    const node = nodes[nodeId];
+    node.requires.forEach((requiredService) => {
+      const providers = providesMap.get(requiredService) || [];
+      providers.forEach((providerId) => {
+        if (providerId !== nodeId) {
+          dependencies.add(providerId);
+        }
+      });
+    });
+    dependencies.forEach((depId) => {
+      visit(depId, currentPath);
+    });
+    visiting.delete(nodeId);
+    visited.add(nodeId);
+    result.push(node);
+  };
+  Object.keys(nodes).forEach((nodeId) => {
+    if (!visited.has(nodeId)) {
+      visit(nodeId, []);
+    }
+  });
+  return {
+    sorted: result,
+    cycles,
+    hasCycles: cycles.length > 0
+  };
+}
+var layerMagic = createRefactor({
+  name: "layerMagic",
+  description: "Layer Magic",
+  apply: fn("layerMagic.apply")(function* (sourceFile, textRange) {
+    const ts = yield* service(TypeScriptApi);
+    const tsUtils = yield* service(TypeScriptUtils);
+    const typeChecker = yield* service(TypeCheckerApi);
+    const typeParser = yield* service(TypeParser);
+    const typeCheckerUtils = yield* service(TypeCheckerUtils);
+    const layerIdentifier = tsUtils.findImportedModuleIdentifierByPackageAndNameOrBarrel(
+      sourceFile,
+      "effect",
+      "Layer"
+    ) || "Layer";
+    const extractArrayLiteral = (node) => {
+      if (ts.isArrayLiteralExpression(node)) {
+        return pipe(
+          all(...node.elements.map((element) => extractLayers(element, false))),
+          map3(flatten)
+        );
+      }
+      return TypeParserIssue.issue;
+    };
+    const extractLayerExpression = (node) => {
+      if (ts.isExpression(node)) {
+        return pipe(
+          typeParser.layerType(typeChecker.getTypeAtLocation(node), node),
+          map3((_) => [{ node, ..._ }])
+        );
+      }
+      return TypeParserIssue.issue;
+    };
+    const extractLayerApi = (node) => {
+      if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && ts.isIdentifier(node.expression.expression) && ts.idText(node.expression.expression) === layerIdentifier && ts.isIdentifier(node.expression.name) && ["provide", "provideMerge", "merge", "mergeAll"].map((_) => _.toLowerCase()).indexOf(
+        ts.idText(node.expression.name).toLowerCase()
+      ) > -1) {
+        return pipe(
+          all(...node.arguments.map((element) => extractLayers(element, false))),
+          map3(flatten)
+        );
+      }
+      return TypeParserIssue.issue;
+    };
+    const extractPipeSequencing = (node) => {
+      return pipe(
+        typeParser.pipeCall(node),
+        flatMap((_) => {
+          return all(...[_.subject, ..._.args].map((element) => extractLayers(element, true)));
+        }),
+        map3(flatten)
+      );
+    };
+    const extractLayers = cachedBy(
+      fn("layerMagic.apply.extractLayerArray")(function* (node, _inPipeContext) {
+        return yield* pipe(
+          extractArrayLiteral(node),
+          orElse2(() => extractLayerApi(node)),
+          _inPipeContext ? (x) => x : orElse2(() => extractPipeSequencing(node)),
+          orElse2(() => extractLayerExpression(node))
+        );
+      }),
+      "layerMagic.apply.extractLayerArray",
+      (node) => node
+    );
+    const adjustedNode = (node) => {
+      if (ts.isIdentifier(node) && ts.isVariableDeclaration(node.parent) && node.parent.initializer) {
+        return adjustedNode(node.parent.initializer);
+      }
+      if (ts.isIdentifier(node) && ts.isPropertyDeclaration(node.parent) && node.parent.initializer) {
+        return adjustedNode(node.parent.initializer);
+      }
+      return node;
+    };
+    const computeAsAnyAsLayerRefactor = (node) => {
+      const atLocation = adjustedNode(node);
+      return pipe(
+        extractLayers(atLocation, false),
+        flatMap(
+          (extractedLayer) => extractedLayer.length < 1 ? TypeParserIssue.issue : succeed(extractedLayer)
+        ),
+        map3((extractedLayers) => ({
+          kind: "refactor.rewrite.effect.layerMagicPrepare",
+          description: "Prepare layers for automatic composition",
+          apply: pipe(
+            gen(function* () {
+              const changeTracker = yield* service(ChangeTracker);
+              const memory = /* @__PURE__ */ new Map();
+              for (const layer of extractedLayers) {
+                yield* typeCheckerUtils.appendToUniqueTypesMap(
+                  memory,
+                  layer.ROut,
+                  (_) => succeed((_.flags & ts.TypeFlags.Never) !== 0)
+                );
+              }
+              const typeReferences = pipe(
+                fromIterable(memory.values()),
+                sort(typeCheckerUtils.deterministicTypeOrder),
+                map5((_) => typeChecker.typeToTypeNode(_, void 0, ts.NodeBuilderFlags.NoTruncation)),
+                filter((_) => !!_)
+              );
+              const newDeclaration = ts.factory.createAsExpression(
+                ts.factory.createAsExpression(
+                  ts.factory.createArrayLiteralExpression(extractedLayers.map((_) => _.node)),
+                  ts.factory.createTypeReferenceNode("any")
+                ),
+                ts.factory.createTypeReferenceNode(
+                  ts.factory.createQualifiedName(ts.factory.createIdentifier(layerIdentifier), "Layer"),
+                  typeReferences.length === 0 ? [
+                    ts.factory.createTypeReferenceNode("never")
+                  ] : [ts.factory.createUnionTypeNode(typeReferences)]
+                )
+              );
+              changeTracker.replaceNode(sourceFile, atLocation, newDeclaration, {
+                leadingTriviaOption: ts.textChanges.LeadingTriviaOption.IncludeAll,
+                trailingTriviaOption: ts.textChanges.TrailingTriviaOption.Exclude
+              });
+            }),
+            provideService(TypeScriptApi, ts)
+          )
+        }))
+      );
+    };
+    const parseAsAnyAsLayer = (node) => {
+      if (ts.isAsExpression(node) && ts.isTypeReferenceNode(node.type)) {
+        const expression = node.expression;
+        if (ts.isAsExpression(expression) && expression.type.kind === ts.SyntaxKind.AnyKeyword) {
+          return pipe(
+            typeParser.layerType(typeChecker.getTypeAtLocation(node.type), node.type),
+            map3((_) => ({ node, ..._, castedStructure: expression.expression }))
+          );
+        }
+      }
+      return TypeParserIssue.issue;
+    };
+    const computeBuildRefactor = (node) => {
+      const atLocation = adjustedNode(node);
+      return pipe(
+        parseAsAnyAsLayer(atLocation),
+        flatMap(
+          (_targetLayer) => pipe(
+            extractArrayLiteral(_targetLayer.castedStructure),
+            orElse2(() => extractLayers(_targetLayer.castedStructure, false)),
+            flatMap(
+              (extractedLayer) => extractedLayer.length < 1 ? TypeParserIssue.issue : succeed(extractedLayer)
+            ),
+            map3((extractedLayers) => ({
+              kind: "refactor.rewrite.effect.layerMagicBuild",
+              description: "Compose layers automatically with target output services",
+              apply: gen(function* () {
+                const changeTracker = yield* service(ChangeTracker);
+                const memory = /* @__PURE__ */ new Map();
+                const { allIndexes: outputIndexes } = yield* typeCheckerUtils.appendToUniqueTypesMap(
+                  memory,
+                  _targetLayer.ROut,
+                  (_) => succeed((_.flags & ts.TypeFlags.Never) !== 0)
+                );
+                const nodes = {};
+                for (let i = 0; i < extractedLayers.length; i++) {
+                  const layer = extractedLayers[i];
+                  const { allIndexes: providedIndexes } = yield* typeCheckerUtils.appendToUniqueTypesMap(
+                    memory,
+                    layer.ROut,
+                    (_) => succeed((_.flags & ts.TypeFlags.Never) !== 0)
+                  );
+                  const { allIndexes: requiredIndexes } = yield* typeCheckerUtils.appendToUniqueTypesMap(
+                    memory,
+                    layer.RIn,
+                    (_) => succeed((_.flags & ts.TypeFlags.Never) !== 0)
+                  );
+                  nodes[`node_${i}`] = {
+                    provides: providedIndexes.filter((_) => requiredIndexes.indexOf(_) === -1),
+                    // only provide indexes that are not required
+                    requires: requiredIndexes,
+                    node: layer.node
+                  };
+                }
+                const sortResult = sortDependencies(nodes);
+                const sortedNodes = sortResult.sorted.reverse();
+                const missingOutput = new Set(outputIndexes);
+                const missingInternal = /* @__PURE__ */ new Set();
+                const outputEntry = [];
+                for (const graphNode of sortedNodes) {
+                  const mergeOutput = graphNode.provides.filter((_) => missingOutput.has(_));
+                  const provideInternal = graphNode.provides.filter((_) => missingInternal.has(_));
+                  graphNode.requires.forEach((_) => missingInternal.add(_));
+                  mergeOutput.forEach((_) => missingOutput.delete(_));
+                  outputEntry.push({
+                    merges: mergeOutput.length > 0,
+                    provides: provideInternal.length > 0,
+                    node: graphNode.node
+                  });
+                }
+                const newDeclaration = ts.factory.createCallExpression(
+                  ts.factory.createPropertyAccessExpression(
+                    outputEntry[0].node,
+                    "pipe"
+                  ),
+                  [],
+                  outputEntry.slice(1).map(
+                    (_) => ts.factory.createCallExpression(
+                      ts.factory.createPropertyAccessExpression(
+                        ts.factory.createIdentifier(layerIdentifier),
+                        _.merges && _.provides ? "provideMerge" : _.merges ? "merge" : "provide"
+                      ),
+                      [],
+                      [_.node]
+                    )
+                  )
+                );
+                changeTracker.replaceNode(sourceFile, atLocation, newDeclaration, {
+                  leadingTriviaOption: ts.textChanges.LeadingTriviaOption.IncludeAll,
+                  trailingTriviaOption: ts.textChanges.TrailingTriviaOption.Exclude
+                });
+              })
+            }))
+          )
+        )
+      );
+    };
+    const parentNodes = tsUtils.getAncestorNodesInRange(sourceFile, textRange);
+    if (parentNodes.length === 0) return yield* fail(new RefactorNotApplicableError());
+    return yield* pipe(
+      firstSuccessOf(parentNodes.map(computeBuildRefactor)),
+      orElse2(() => firstSuccessOf(parentNodes.map(computeAsAnyAsLayerRefactor))),
+      orElse2(() => fail(new RefactorNotApplicableError()))
+    );
+  })
+});
+
 // src/refactors/makeSchemaOpaque.ts
 var _findSchemaVariableDeclaration = fn(
   "makeSchemaOpaque._findSchemaVariableDeclaration"
@@ -12732,6 +13027,7 @@ var wrapWithPipe = createRefactor({
 
 // src/refactors.ts
 var refactors = [
+  layerMagic,
   asyncAwaitToGen,
   asyncAwaitToGenTryPromise,
   asyncAwaitToFn,