@ethlete/eslint-plugin 1.0.0-next.20 → 1.0.0-next.21

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## 1.0.0-next.21
+
+### Minor Changes
+
+- [`3d44765`](https://github.com/ethlete-io/ethdk/commit/3d44765647e6d47b558c1395fe5ebcb20ed3ef83) Thanks [@TomTomB](https://github.com/TomTomB)! - New rule `ethlete/no-async-await`, replacing the `no-restricted-syntax` selectors that could not be
+  toggled on their own. It also catches bare `await` and `for await…of`.
+
 ## 1.0.0-next.20
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ethlete/eslint-plugin",
-  "version": "1.0.0-next.20",
+  "version": "1.0.0-next.21",
   "license": "MIT",
   "type": "commonjs",
   "main": "./src/index.js",

package/src/configs/recommended.js

@@ -126,19 +126,8 @@ const recommendedTs = {
         selector: 'PropertyDefinition > ArrowFunctionExpression',
         message: 'No arrow function properties in classes. Use regular methods.',
       },
-      // No async/await — use RxJS
-      {
-        selector: 'FunctionDeclaration[async=true]',
-        message: 'No async/await. Use RxJS for all async operations.',
-      },
-      {
-        selector: 'ArrowFunctionExpression[async=true]',
-        message: 'No async/await. Use RxJS for all async operations.',
-      },
-      {
-        selector: 'FunctionExpression[async=true]',
-        message: 'No async/await. Use RxJS for all async operations.',
-      },
+      // async/await is owned by ethlete/no-async-await, so a lib can keep it on while it works
+      // through the rest of this rule's backlog.
       // No static class members — except ngTemplateContextGuard, which Angular's template
       // type checker requires to be static (it types a structural directive's `let-` bindings)
       {
@@ -253,6 +242,9 @@ const recommendedTs = {
     // No .subscribe() inside a .pipe() callback
     'ethlete/no-subscribe-in-pipe': 'error',
 
+    // No async/await — asynchronous work is modelled as cold Observables
+    'ethlete/no-async-await': 'error',
+
     // No .subscribe() inside effect() or computed()
     'ethlete/no-rxjs-in-effect': 'error',
 

package/src/index.js

@@ -58,6 +58,7 @@ const noLegacyPrepareWithoutInjector = require('./rules/no-legacy-prepare-withou
 const requireFormSubmit = require('./rules/require-form-submit');
 const noCdkImport = require('./rules/no-cdk-import');
 const noLegacyQueryImport = require('./rules/no-legacy-query-import');
+const noAsyncAwait = require('./rules/no-async-await');
 const { recommendedTs, recommendedTemplate, recommendedSpec } = require('./configs/recommended');
 
 /** @type {import('eslint').ESLint.Plugin} */
@@ -124,6 +125,7 @@ const plugin = {
     'require-form-submit': requireFormSubmit,
     'no-cdk-import': noCdkImport,
     'no-legacy-query-import': noLegacyQueryImport,
+    'no-async-await': noAsyncAwait,
   },
 };
 

package/src/rules/no-async-await.js

@@ -0,0 +1,80 @@
+// @ts-check
+'use strict';
+
+/**
+ * Disallow async/await — asynchronous work is modelled with RxJS.
+ *
+ * Every async API in the SDK returns a cold Observable, not a Promise, so a consumer can compose,
+ * cancel and retry it. Bridge a browser Promise in with from(); never await it.
+ *
+ * BAD:
+ *   async copy(text: string) {
+ *     await navigator.clipboard.writeText(text);
+ *     this.copied.set(true);
+ *   }
+ *
+ * GOOD:
+ *   copy(text: string) {
+ *     return from(navigator.clipboard.writeText(text)).pipe(tap(() => this.copied.set(true)));
+ *   }
+ */
+
+/** Storybook's play function is called by the test runner and has to be a promise. */
+const isStorybookPlayFunction = (node) => {
+  const { parent } = node;
+
+  return (
+    parent?.type === 'Property' &&
+    parent.value === node &&
+    parent.key.type === 'Identifier' &&
+    parent.key.name === 'play'
+  );
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+const noAsyncAwait = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Disallow async / await — model asynchronous work as RxJS Observables.',
+      recommended: true,
+    },
+    messages: {
+      noAsync:
+        "Don't declare an 'async' function. Return a cold Observable instead — 'defer()' for laziness, 'from()' to bridge a Promise-based browser API.",
+      noAwait:
+        "Don't 'await'. Compose the value into the stream with 'switchMap' / 'mergeMap' / 'from()' instead, and read a one-shot result with 'firstValueFrom()' only in tests.",
+      noForAwait: "Don't use 'for await…of'. Bridge the async iterable into a stream and compose it with RxJS.",
+    },
+    schema: [],
+  },
+  create(context) {
+    const isExempt = (node) => {
+      for (let current = node; current; current = current.parent) {
+        if (isStorybookPlayFunction(current)) return true;
+      }
+
+      return false;
+    };
+
+    const reportAsync = (node) => {
+      if (!node.async || isExempt(node)) return;
+
+      context.report({ node, messageId: 'noAsync' });
+    };
+
+    return {
+      FunctionDeclaration: reportAsync,
+      FunctionExpression: reportAsync,
+      ArrowFunctionExpression: reportAsync,
+      AwaitExpression(node) {
+        if (!isExempt(node)) context.report({ node, messageId: 'noAwait' });
+      },
+      ForOfStatement(node) {
+        if (node.await && !isExempt(node)) context.report({ node, messageId: 'noForAwait' });
+      },
+    };
+  },
+};
+
+module.exports = noAsyncAwait;