@effect/language-service 0.42.0 → 0.43.1

package/README.md

@@ -120,7 +120,8 @@ Few options can be provided alongside the initialization of the Language Service
         "namespaceImportPackages": [], // package names that should be preferred as imported with namespace imports e.g. ["effect", "@effect/*"] (default: [])
         "topLevelNamedReexports": "ignore", // for namespaceImportPackages, how should top level named re-exports (e.g. {pipe} from "effect") be treated? "ignore" will leave them as is, "follow" will rewrite them to the re-exported module (e.g. {pipe} from "effect/Function")
         "importAliases": { "Array": "Arr" }, // allows to chose some different names for import name aliases (only when not chosing to import the whole module) (default: {})
-        "noExternal": false // disables features that provides links to external websites (such as links to mermaidchart.com) (default: false)
+        "noExternal": false, // disables features that provides links to external websites (such as links to mermaidchart.com) (default: false)
+        "keyPatterns": [{ "target": "service", "pattern": "default", "skipLeadingPath": ["src/"] }] // configure the key patterns; recommended reading more on the section "Configuring Key Patterns"
       }
     ]
   }
@@ -230,6 +231,56 @@ or you can set the severity for the entire project in the global plugin configur
 }
 ```
 
+## Configuring Key Patterns
+
+Effect uses string keys for Services, Error Tags, RPC Methods, and more.
+It can happen that sometimes, after some refactors or copy/paste, you may end up having wrong or non unique keys in your services.
+
+To avoid that, the LSP suggests deterministic patterns for keys; that can be configured by the "keyPatterns" option.
+
+To enable reporting of wrong or outdated keys, the rule "deterministicKeys" must be enabled first (off by default). To do so, adjust its diagnosticSeverity to error.
+
+The keyPatterns key can then contain an array of the configured patterns.
+
+```jsonc
+{
+  "compilerOptions": {
+    "plugins": [
+      {
+        "name": "@effect/language-service",
+        // ...
+        "diagnosticSeverity": {
+          "deterministicKeys": "error" // enables reporting of wrong keys
+          // ...
+        },
+        "keyPatterns": [
+          {
+            "target": "service", // what key type to target between service|error
+            "pattern": "default", // the chosen pattern
+            "skipLeadingPath": ["src/"] // other pattern specific configs
+          }
+        ]
+        
+      }
+    ]
+  }
+}
+```
+
+### Pattern: default
+
+This pattern constructs keys by chaining package name + file path + class identifier.
+
+E.g. `@effect/package/subpath-relative-to-package-root/FileName/ClassIdentifier`
+
+If the filename and the class identifier are the same, they won't be repeated, but used only once.
+
+The skipLeadingPath array can contain a set of prefixes to remove from the subpath part of the path. By default "src/" is removed for example.
+
+### Pattern: package-identifier
+
+This pattern uses the package name + identifier. This usually works great if you have a flat structure, with one file per service/error.
+
 ## Known gotchas
 
 ### Svelte VSCode extension and SvelteKit

package/effect-lsp-patch-utils.js

@@ -1184,8 +1184,25 @@ var defaults = {
   barrelImportPackages: [],
   importAliases: {},
   renames: true,
-  noExternal: false
+  noExternal: false,
+  keyPatterns: [{
+    target: "service",
+    pattern: "default",
+    skipLeadingPath: ["src/"]
+  }]
 };
+function parseKeyPatterns(patterns) {
+  const result = [];
+  for (const entry of patterns) {
+    if (!isObject(entry)) continue;
+    result.push({
+      target: hasProperty(entry, "target") && isString(entry.target) && ["service", "error"].includes(entry.target.toLowerCase()) ? entry.target.toLowerCase() : "service",
+      pattern: hasProperty(entry, "pattern") && isString(entry.pattern) && ["package-identifier", "default"].includes(entry.pattern.toLowerCase()) ? entry.pattern.toLowerCase() : "default",
+      skipLeadingPath: hasProperty(entry, "skipLeadingPath") && isArray(entry.skipLeadingPath) && entry.skipLeadingPath.every(isString) ? entry.skipLeadingPath : ["src/"]
+    });
+  }
+  return result;
+}
 function parse(config) {
   return {
     refactors: isObject(config) && hasProperty(config, "refactors") && isBoolean(config.refactors) ? config.refactors : defaults.refactors,
@@ -1203,7 +1220,8 @@ function parse(config) {
     importAliases: isObject(config) && hasProperty(config, "importAliases") && isRecord(config.importAliases) ? map2(config.importAliases, (value) => String(value)) : defaults.importAliases,
     topLevelNamedReexports: isObject(config) && hasProperty(config, "topLevelNamedReexports") && isString(config.topLevelNamedReexports) && ["ignore", "follow"].includes(config.topLevelNamedReexports.toLowerCase()) ? config.topLevelNamedReexports.toLowerCase() : defaults.topLevelNamedReexports,
     renames: isObject(config) && hasProperty(config, "renames") && isBoolean(config.renames) ? config.renames : defaults.renames,
-    noExternal: isObject(config) && hasProperty(config, "noExternal") && isBoolean(config.noExternal) ? config.noExternal : defaults.noExternal
+    noExternal: isObject(config) && hasProperty(config, "noExternal") && isBoolean(config.noExternal) ? config.noExternal : defaults.noExternal,
+    keyPatterns: isObject(config) && hasProperty(config, "keyPatterns") && isArray(config.keyPatterns) ? parseKeyPatterns(config.keyPatterns) : defaults.keyPatterns
   };
 }
 
@@ -3462,6 +3480,128 @@ var classSelfMismatch = createDiagnostic({
   })
 });
 
+// src/core/KeyBuilder.ts
+var makeKeyBuilder = fn("KeyBuilder")(
+  function* (sourceFile) {
+    const ts = yield* service(TypeScriptApi);
+    const tsUtils = yield* service(TypeScriptUtils);
+    const program = yield* service(TypeScriptProgram);
+    const options = yield* service(LanguageServicePluginOptions);
+    const packageInfo = tsUtils.resolveModuleWithPackageInfoFromSourceFile(program, sourceFile);
+    function createString2(classNameText, kind) {
+      if (!packageInfo) return;
+      for (const keyPattern of options.keyPatterns) {
+        if (keyPattern.target !== kind) continue;
+        const lastIndex = sourceFile.fileName.lastIndexOf("/");
+        let onlyFileName = lastIndex === -1 ? "" : sourceFile.fileName.slice(lastIndex + 1);
+        const lastExtensionIndex = onlyFileName.lastIndexOf(".");
+        if (lastExtensionIndex !== -1) onlyFileName = onlyFileName.slice(0, lastExtensionIndex);
+        if (onlyFileName.toLowerCase().endsWith("/index")) onlyFileName = onlyFileName.slice(0, -6);
+        if (onlyFileName.startsWith("/")) onlyFileName = onlyFileName.slice(1);
+        let subDirectory = getDirectoryPath(ts, sourceFile.fileName);
+        if (!subDirectory.startsWith(packageInfo.packageDirectory)) continue;
+        subDirectory = subDirectory.slice(packageInfo.packageDirectory.length);
+        if (!subDirectory.endsWith("/")) subDirectory = subDirectory + "/";
+        if (subDirectory.startsWith("/")) subDirectory = subDirectory.slice(1);
+        for (const prefix of keyPattern.skipLeadingPath) {
+          if (subDirectory.startsWith(prefix)) {
+            subDirectory = subDirectory.slice(prefix.length);
+            break;
+          }
+        }
+        let parts = [packageInfo.name, subDirectory, onlyFileName].concat(
+          onlyFileName.toLowerCase() === classNameText.toLowerCase() ? [] : [classNameText]
+        );
+        if (keyPattern.pattern === "package-identifier") {
+          parts = [packageInfo.name, onlyFileName].concat(
+            onlyFileName.toLowerCase() === classNameText.toLowerCase() ? [] : [classNameText]
+          );
+        }
+        parts = parts.map((part) => part.startsWith("/") ? part.slice(1) : part).map(
+          (part) => part.endsWith("/") ? part.slice(0, -1) : part
+        );
+        return parts.filter((_) => String(_).trim().length > 0).join("/");
+      }
+    }
+    return {
+      createString: createString2
+    };
+  }
+);
+var keyBuilderCache = /* @__PURE__ */ new Map();
+var getOrMakeKeyBuilder = fn("getOrMakeKeyBuilder")(function* (sourceFile) {
+  const keyBuilder = keyBuilderCache.get(sourceFile.fileName) || (yield* makeKeyBuilder(sourceFile));
+  keyBuilderCache.set(sourceFile.fileName, keyBuilder);
+  return keyBuilder;
+});
+function createString(sourceFile, identifier, kind) {
+  return map4(
+    getOrMakeKeyBuilder(sourceFile),
+    (identifierBuilder) => identifierBuilder.createString(identifier, kind)
+  );
+}
+
+// src/diagnostics/deterministicKeys.ts
+var deterministicKeys = createDiagnostic({
+  name: "deterministicKeys",
+  code: 25,
+  severity: "off",
+  apply: fn("deterministicKeys.apply")(function* (sourceFile, report) {
+    const ts = yield* service(TypeScriptApi);
+    const typeParser = yield* service(TypeParser);
+    const nodeToVisit = [];
+    const appendNodeToVisit = (node) => {
+      nodeToVisit.push(node);
+      return void 0;
+    };
+    ts.forEachChild(sourceFile, appendNodeToVisit);
+    while (nodeToVisit.length > 0) {
+      const node = nodeToVisit.shift();
+      if (ts.isClassDeclaration(node) && node.name && node.heritageClauses) {
+        const result = yield* pipe(
+          pipe(
+            typeParser.extendsEffectService(node),
+            orElse2(() => typeParser.extendsContextTag(node)),
+            orElse2(() => typeParser.extendsEffectTag(node)),
+            map4(({ className, keyStringLiteral }) => ({ keyStringLiteral, className, target: "service" }))
+          ),
+          orElse2(
+            () => pipe(
+              typeParser.extendsDataTaggedError(node),
+              orElse2(() => typeParser.extendsSchemaTaggedError(node)),
+              map4(({ className, keyStringLiteral }) => ({ keyStringLiteral, className, target: "error" }))
+            )
+          ),
+          orElse2(() => void_)
+        );
+        if (result && result.keyStringLiteral) {
+          const { className, keyStringLiteral } = result;
+          const classNameText = ts.idText(className);
+          const expectedKey = yield* createString(sourceFile, classNameText, result.target);
+          if (!expectedKey) return;
+          const actualIdentifier = keyStringLiteral.text;
+          if (actualIdentifier !== expectedKey) {
+            report({
+              location: keyStringLiteral,
+              messageText: `Key should be '${expectedKey}'`,
+              fixes: [{
+                fixName: "deterministicKeys_fix",
+                description: `Replace '${actualIdentifier}' with '${expectedKey}'`,
+                apply: gen(function* () {
+                  const changeTracker = yield* service(ChangeTracker);
+                  const newStringLiteral = ts.factory.createStringLiteral(expectedKey);
+                  changeTracker.replaceNode(sourceFile, keyStringLiteral, newStringLiteral);
+                })
+              }]
+            });
+          }
+        }
+      }
+      ts.forEachChild(node, appendNodeToVisit);
+    }
+  })
+});
+
 // src/diagnostics/duplicatePackage.ts
 var checkedPackagesCache = /* @__PURE__ */ new Map();
 var programResolvedCacheSize = /* @__PURE__ */ new Map();
@@ -5471,7 +5611,8 @@ var diagnostics = [
   outdatedEffectCodegen,
   overriddenSchemaConstructor,
   unsupportedServiceAccessors,
-  nonObjectEffectServiceType
+  nonObjectEffectServiceType,
+  deterministicKeys
 ];
 
 // src/effect-lsp-patch-utils.ts