atom.io 0.21.1 → 0.22.0

package/eslint-plugin/dist/index.cjs

@@ -14,6 +14,7 @@ var __export = (target, all) => {
 var rules_exports = {};
 __export(rules_exports, {
   explicitStateTypes: () => explicitStateTypes,
+  lifespan: () => lifespan,
   synchronousSelectorDependencies: () => synchronousSelectorDependencies
 });
 var createRule = utils.ESLintUtils.RuleCreator(
@@ -66,7 +67,7 @@ var explicitStateTypes = createRule({
   }
 });
 
-// eslint-plugin/src/rules/synchronous-selector-dependencies.ts
+// eslint-plugin/src/walk.ts
 function walk(node, callback, depth = 0) {
   callback(node, depth);
   switch (node.type) {
@@ -125,8 +126,162 @@ function walk(node, callback, depth = 0) {
       walk(node.object, callback, depth);
       walk(node.property, callback, depth);
       break;
+    case `CallExpression`:
+      walk(node.callee, callback, depth);
+      for (const argument of node.arguments) {
+        walk(argument, callback, depth);
+      }
+      break;
   }
 }
+
+// eslint-plugin/src/rules/lifespan.ts
+var lifespan = {
+  meta: {
+    type: `problem`,
+    docs: {
+      description: `atom.io provides tools for short-lived (ephemeral) and long-lived (immortal) stores. This rule allows you to guard against unsafe usage of tools for the other type of store.`,
+      category: `Possible Errors`,
+      recommended: false,
+      url: ``
+      // URL to documentation page for this rule
+    },
+    schema: [
+      {
+        type: `string`,
+        enum: [`ephemeral`, `immortal`],
+        default: `ephemeral`
+      }
+    ]
+  },
+  create(context) {
+    var _a;
+    const storeLifespan = (_a = context.options[0]) != null ? _a : `ephemeral`;
+    return {
+      ImportDeclaration(node) {
+        const importSource = node.source.value;
+        if (!importSource.startsWith(`atom.io/`)) {
+          return;
+        }
+        const [_, subPackageName] = importSource.split(`/`);
+        if (storeLifespan === `immortal` && subPackageName === `ephemeral`) {
+          context.report({
+            node,
+            message: `do not import from "${importSource}" in an ${storeLifespan} store`
+          });
+        }
+      },
+      CallExpression(node) {
+        if (storeLifespan === `ephemeral`) {
+          return;
+        }
+        const functionCallee = node.callee.type === `Identifier` ? node.callee : void 0;
+        const methodCallee = node.callee.type === `MemberExpression` && node.callee.property.type === `Identifier` ? node.callee.property : void 0;
+        const callee = functionCallee != null ? functionCallee : methodCallee;
+        if (callee === void 0) {
+          return;
+        }
+        if (callee.name === `findState`) {
+          context.report({
+            node,
+            message: `do not use findState in an ${storeLifespan} store`
+          });
+        }
+        const storeProcedures = [];
+        if (callee.name === `selector` || callee.name === `selectorFamily` || callee.name === `transaction`) {
+          if (node.arguments[0].type === `ObjectExpression`) {
+            const argProperties = node.arguments[0].properties;
+            switch (callee.name) {
+              case `selector`:
+              case `selectorFamily`:
+                {
+                  const getAndSetProps = argProperties.filter(
+                    (prop) => {
+                      return `key` in prop && `name` in prop.key && (prop.key.name === `get` || prop.key.name === `set`);
+                    }
+                  );
+                  switch (callee.name) {
+                    case `selector`:
+                      {
+                        for (const prop of getAndSetProps) {
+                          if (prop.value.type === `FunctionExpression` || prop.value.type === `ArrowFunctionExpression`) {
+                            console.log(prop.value);
+                            storeProcedures.push(prop.value);
+                          }
+                        }
+                      }
+                      break;
+                    case `selectorFamily`:
+                      {
+                        for (const prop of getAndSetProps) {
+                          const { value } = prop;
+                          if (value.type === `FunctionExpression` || value.type === `ArrowFunctionExpression`) {
+                            if (value.body.type === `BlockStatement`) {
+                              for (const statement of value.body.body) {
+                                if (statement.type === `ReturnStatement` && statement.argument && (statement.argument.type === `FunctionExpression` || statement.argument.type === `ArrowFunctionExpression`)) {
+                                  storeProcedures.push(statement.argument);
+                                }
+                              }
+                            } else if (value.body.type === `FunctionExpression` || value.body.type === `ArrowFunctionExpression`) {
+                              storeProcedures.push(value.body);
+                            }
+                          }
+                        }
+                      }
+                      break;
+                  }
+                }
+                break;
+              case `transaction`:
+                {
+                  const doProp = argProperties.find(
+                    (prop) => {
+                      return `key` in prop && `name` in prop.key && prop.key.name === `do`;
+                    }
+                  );
+                  if (doProp) {
+                    if (doProp.value.type === `FunctionExpression` || doProp.value.type === `ArrowFunctionExpression`) {
+                      storeProcedures.push(doProp.value);
+                    }
+                  }
+                }
+                break;
+            }
+          }
+        }
+        for (const storeProcedure of storeProcedures) {
+          const transactorsParam = storeProcedure.params[0];
+          const nonDestructuredTransactorsName = transactorsParam && `name` in transactorsParam ? transactorsParam.name : void 0;
+          walk(storeProcedure.body, (n) => {
+            if (n.type === `CallExpression`) {
+              let willReport = false;
+              switch (n.callee.type) {
+                case `MemberExpression`:
+                  if (n.callee.object.type === `Identifier` && n.callee.object.name === nonDestructuredTransactorsName && n.callee.property.type === `Identifier` && n.callee.property.name === `find`) {
+                    willReport = true;
+                  }
+                  break;
+                case `Identifier`:
+                  if (n.callee.name === `find`) {
+                    willReport = true;
+                  }
+                  break;
+              }
+              if (willReport) {
+                context.report({
+                  node: n,
+                  message: `Using find in a transactor is not allowed in an immortal store.`
+                });
+              }
+            }
+          });
+        }
+      }
+    };
+  }
+};
+
+// eslint-plugin/src/rules/synchronous-selector-dependencies.ts
 var synchronousSelectorDependencies = {
   meta: {
     type: `problem`,

package/eslint-plugin/dist/index.js

@@ -5,6 +5,7 @@ import { ESLintUtils } from '@typescript-eslint/utils';
 var rules_exports = {};
 __export(rules_exports, {
   explicitStateTypes: () => explicitStateTypes,
+  lifespan: () => lifespan,
   synchronousSelectorDependencies: () => synchronousSelectorDependencies
 });
 var createRule = ESLintUtils.RuleCreator(
@@ -57,7 +58,7 @@ var explicitStateTypes = createRule({
   }
 });
 
-// eslint-plugin/src/rules/synchronous-selector-dependencies.ts
+// eslint-plugin/src/walk.ts
 function walk(node, callback, depth = 0) {
   callback(node, depth);
   switch (node.type) {
@@ -116,8 +117,162 @@ function walk(node, callback, depth = 0) {
       walk(node.object, callback, depth);
       walk(node.property, callback, depth);
       break;
+    case `CallExpression`:
+      walk(node.callee, callback, depth);
+      for (const argument of node.arguments) {
+        walk(argument, callback, depth);
+      }
+      break;
   }
 }
+
+// eslint-plugin/src/rules/lifespan.ts
+var lifespan = {
+  meta: {
+    type: `problem`,
+    docs: {
+      description: `atom.io provides tools for short-lived (ephemeral) and long-lived (immortal) stores. This rule allows you to guard against unsafe usage of tools for the other type of store.`,
+      category: `Possible Errors`,
+      recommended: false,
+      url: ``
+      // URL to documentation page for this rule
+    },
+    schema: [
+      {
+        type: `string`,
+        enum: [`ephemeral`, `immortal`],
+        default: `ephemeral`
+      }
+    ]
+  },
+  create(context) {
+    var _a;
+    const storeLifespan = (_a = context.options[0]) != null ? _a : `ephemeral`;
+    return {
+      ImportDeclaration(node) {
+        const importSource = node.source.value;
+        if (!importSource.startsWith(`atom.io/`)) {
+          return;
+        }
+        const [_, subPackageName] = importSource.split(`/`);
+        if (storeLifespan === `immortal` && subPackageName === `ephemeral`) {
+          context.report({
+            node,
+            message: `do not import from "${importSource}" in an ${storeLifespan} store`
+          });
+        }
+      },
+      CallExpression(node) {
+        if (storeLifespan === `ephemeral`) {
+          return;
+        }
+        const functionCallee = node.callee.type === `Identifier` ? node.callee : void 0;
+        const methodCallee = node.callee.type === `MemberExpression` && node.callee.property.type === `Identifier` ? node.callee.property : void 0;
+        const callee = functionCallee != null ? functionCallee : methodCallee;
+        if (callee === void 0) {
+          return;
+        }
+        if (callee.name === `findState`) {
+          context.report({
+            node,
+            message: `do not use findState in an ${storeLifespan} store`
+          });
+        }
+        const storeProcedures = [];
+        if (callee.name === `selector` || callee.name === `selectorFamily` || callee.name === `transaction`) {
+          if (node.arguments[0].type === `ObjectExpression`) {
+            const argProperties = node.arguments[0].properties;
+            switch (callee.name) {
+              case `selector`:
+              case `selectorFamily`:
+                {
+                  const getAndSetProps = argProperties.filter(
+                    (prop) => {
+                      return `key` in prop && `name` in prop.key && (prop.key.name === `get` || prop.key.name === `set`);
+                    }
+                  );
+                  switch (callee.name) {
+                    case `selector`:
+                      {
+                        for (const prop of getAndSetProps) {
+                          if (prop.value.type === `FunctionExpression` || prop.value.type === `ArrowFunctionExpression`) {
+                            console.log(prop.value);
+                            storeProcedures.push(prop.value);
+                          }
+                        }
+                      }
+                      break;
+                    case `selectorFamily`:
+                      {
+                        for (const prop of getAndSetProps) {
+                          const { value } = prop;
+                          if (value.type === `FunctionExpression` || value.type === `ArrowFunctionExpression`) {
+                            if (value.body.type === `BlockStatement`) {
+                              for (const statement of value.body.body) {
+                                if (statement.type === `ReturnStatement` && statement.argument && (statement.argument.type === `FunctionExpression` || statement.argument.type === `ArrowFunctionExpression`)) {
+                                  storeProcedures.push(statement.argument);
+                                }
+                              }
+                            } else if (value.body.type === `FunctionExpression` || value.body.type === `ArrowFunctionExpression`) {
+                              storeProcedures.push(value.body);
+                            }
+                          }
+                        }
+                      }
+                      break;
+                  }
+                }
+                break;
+              case `transaction`:
+                {
+                  const doProp = argProperties.find(
+                    (prop) => {
+                      return `key` in prop && `name` in prop.key && prop.key.name === `do`;
+                    }
+                  );
+                  if (doProp) {
+                    if (doProp.value.type === `FunctionExpression` || doProp.value.type === `ArrowFunctionExpression`) {
+                      storeProcedures.push(doProp.value);
+                    }
+                  }
+                }
+                break;
+            }
+          }
+        }
+        for (const storeProcedure of storeProcedures) {
+          const transactorsParam = storeProcedure.params[0];
+          const nonDestructuredTransactorsName = transactorsParam && `name` in transactorsParam ? transactorsParam.name : void 0;
+          walk(storeProcedure.body, (n) => {
+            if (n.type === `CallExpression`) {
+              let willReport = false;
+              switch (n.callee.type) {
+                case `MemberExpression`:
+                  if (n.callee.object.type === `Identifier` && n.callee.object.name === nonDestructuredTransactorsName && n.callee.property.type === `Identifier` && n.callee.property.name === `find`) {
+                    willReport = true;
+                  }
+                  break;
+                case `Identifier`:
+                  if (n.callee.name === `find`) {
+                    willReport = true;
+                  }
+                  break;
+              }
+              if (willReport) {
+                context.report({
+                  node: n,
+                  message: `Using find in a transactor is not allowed in an immortal store.`
+                });
+              }
+            }
+          });
+        }
+      }
+    };
+  }
+};
+
+// eslint-plugin/src/rules/synchronous-selector-dependencies.ts
 var synchronousSelectorDependencies = {
   meta: {
     type: `problem`,

package/eslint-plugin/src/rules/index.ts

@@ -1,2 +1,3 @@
 export * from "./explicit-state-types"
+export * from "./lifespan"
 export * from "./synchronous-selector-dependencies"

package/eslint-plugin/src/rules/lifespan.ts

@@ -0,0 +1,204 @@
+import type { Rule } from "eslint"
+import type * as ESTree from "estree"
+
+import { walk } from "../walk"
+
+export const lifespan = {
+	meta: {
+		type: `problem`,
+		docs: {
+			description: `atom.io provides tools for short-lived (ephemeral) and long-lived (immortal) stores. This rule allows you to guard against unsafe usage of tools for the other type of store.`,
+			category: `Possible Errors`,
+			recommended: false,
+			url: ``, // URL to documentation page for this rule
+		},
+		schema: [
+			{
+				type: `string`,
+				enum: [`ephemeral`, `immortal`],
+				default: `ephemeral`,
+			},
+		],
+	},
+	create(context) {
+		const storeLifespan = (context.options[0] ?? `ephemeral`) as
+			| `ephemeral`
+			| `immortal`
+		return {
+			ImportDeclaration(node) {
+				const importSource = node.source.value as string
+				if (!importSource.startsWith(`atom.io/`)) {
+					return
+				}
+				const [_, subPackageName] = importSource.split(`/`)
+				if (storeLifespan === `immortal` && subPackageName === `ephemeral`) {
+					context.report({
+						node,
+						message: `do not import from "${importSource}" in an ${storeLifespan} store`,
+					})
+				}
+			},
+
+			CallExpression(node) {
+				if (storeLifespan === `ephemeral`) {
+					return
+				}
+
+				const functionCallee =
+					node.callee.type === `Identifier` ? node.callee : undefined
+				const methodCallee =
+					node.callee.type === `MemberExpression` &&
+					node.callee.property.type === `Identifier`
+						? node.callee.property
+						: undefined
+				const callee = functionCallee ?? methodCallee
+
+				if (callee === undefined) {
+					return
+				}
+
+				if (callee.name === `findState`) {
+					context.report({
+						node,
+						message: `do not use findState in an ${storeLifespan} store`,
+					})
+				}
+
+				const storeProcedures: (
+					| ESTree.ArrowFunctionExpression
+					| ESTree.FunctionExpression
+				)[] = []
+				if (
+					callee.name === `selector` ||
+					callee.name === `selectorFamily` ||
+					callee.name === `transaction`
+				) {
+					if (node.arguments[0].type === `ObjectExpression`) {
+						const argProperties = node.arguments[0].properties
+						switch (callee.name) {
+							case `selector`:
+							case `selectorFamily`:
+								{
+									const getAndSetProps = argProperties.filter(
+										(prop): prop is ESTree.Property => {
+											return (
+												`key` in prop &&
+												`name` in prop.key &&
+												(prop.key.name === `get` || prop.key.name === `set`)
+											)
+										},
+									)
+									switch (callee.name) {
+										case `selector`:
+											{
+												for (const prop of getAndSetProps) {
+													if (
+														prop.value.type === `FunctionExpression` ||
+														prop.value.type === `ArrowFunctionExpression`
+													) {
+														console.log(prop.value)
+														storeProcedures.push(prop.value)
+													}
+												}
+											}
+											break
+										case `selectorFamily`:
+											{
+												for (const prop of getAndSetProps) {
+													const { value } = prop
+													if (
+														value.type === `FunctionExpression` ||
+														value.type === `ArrowFunctionExpression`
+													) {
+														if (value.body.type === `BlockStatement`) {
+															for (const statement of value.body.body) {
+																if (
+																	statement.type === `ReturnStatement` &&
+																	statement.argument &&
+																	(statement.argument.type ===
+																		`FunctionExpression` ||
+																		statement.argument.type ===
+																			`ArrowFunctionExpression`)
+																) {
+																	storeProcedures.push(statement.argument)
+																}
+															}
+														} else if (
+															value.body.type === `FunctionExpression` ||
+															value.body.type === `ArrowFunctionExpression`
+														) {
+															storeProcedures.push(value.body)
+														}
+													}
+												}
+											}
+											break
+									}
+								}
+								break
+
+							case `transaction`:
+								{
+									const doProp = argProperties.find(
+										(prop): prop is ESTree.Property => {
+											return (
+												`key` in prop &&
+												`name` in prop.key &&
+												prop.key.name === `do`
+											)
+										},
+									)
+									if (doProp) {
+										if (
+											doProp.value.type === `FunctionExpression` ||
+											doProp.value.type === `ArrowFunctionExpression`
+										) {
+											storeProcedures.push(doProp.value)
+										}
+									}
+								}
+								break
+						}
+					}
+				}
+
+				for (const storeProcedure of storeProcedures) {
+					const transactorsParam = storeProcedure.params[0]
+					const nonDestructuredTransactorsName =
+						transactorsParam && `name` in transactorsParam
+							? transactorsParam.name
+							: undefined
+					walk(storeProcedure.body, (n) => {
+						// console.log(`${`\t`.repeat(depth)}${n.type} ${n.name ?? ``}`)
+						if (n.type === `CallExpression`) {
+							let willReport = false
+							switch (n.callee.type) {
+								case `MemberExpression`:
+									if (
+										n.callee.object.type === `Identifier` &&
+										n.callee.object.name === nonDestructuredTransactorsName &&
+										n.callee.property.type === `Identifier` &&
+										n.callee.property.name === `find`
+									) {
+										willReport = true
+									}
+									break
+								case `Identifier`:
+									if (n.callee.name === `find`) {
+										willReport = true
+									}
+									break
+							}
+							if (willReport) {
+								context.report({
+									node: n,
+									message: `Using find in a transactor is not allowed in an immortal store.`,
+								})
+							}
+						}
+					})
+				}
+			},
+		}
+	},
+} satisfies Rule.RuleModule

package/eslint-plugin/src/rules/synchronous-selector-dependencies.ts

@@ -1,71 +1,7 @@
 import type { Rule } from "eslint"
 import type * as ESTree from "estree"
 
-function walk(
-	node: ESTree.Node,
-	callback: (node: ESTree.Node, depth: number) => void,
-	depth = 0,
-) {
-	callback(node, depth)
-
-	switch (node.type) {
-		case `FunctionDeclaration`:
-		case `FunctionExpression`:
-		case `ArrowFunctionExpression`:
-			for (const param of node.params) {
-				walk(param, callback, depth + 1)
-			}
-			walk(node.body, callback, depth + 1)
-			break
-		case `BlockStatement`:
-			for (const statement of node.body) {
-				walk(statement, callback, depth + 1)
-			}
-			break
-		case `IfStatement`:
-			walk(node.test, callback, depth)
-			walk(node.consequent, callback, depth)
-			if (node.alternate) {
-				walk(node.alternate, callback, depth)
-			}
-			break
-		case `SwitchStatement`:
-			walk(node.discriminant, callback, depth + 1)
-			for (const caseOrDefault of node.cases) {
-				walk(caseOrDefault, callback, depth)
-			}
-			break
-		case `ReturnStatement`:
-			if (node.argument) {
-				walk(node.argument, callback, depth)
-			}
-			break
-		case `SwitchCase`:
-			if (node.test) {
-				walk(node.test, callback, depth)
-			}
-			for (const statement of node.consequent) {
-				walk(statement, callback, depth)
-			}
-			break
-		case `VariableDeclaration`:
-			for (const declaration of node.declarations) {
-				walk(declaration, callback, depth)
-				if (declaration.init) {
-					walk(declaration.init, callback, depth)
-				}
-			}
-			break
-		case `BinaryExpression`:
-			walk(node.left, callback, depth)
-			walk(node.right, callback, depth)
-			break
-		case `MemberExpression`:
-			walk(node.object, callback, depth)
-			walk(node.property, callback, depth)
-			break
-	}
-}
+import { walk } from "../walk"
 
 export const synchronousSelectorDependencies = {
 	meta: {