@craft-ts/dev-tools 0.7.0-beta.13

package/src/eslint-rules/no-imperative-craft-resource-trigger.cjs

@@ -0,0 +1,291 @@
+const PRIMITIVE_METHODS = {
+  query: new Set(['call']),
+  mutation: new Set(['mutate']),
+  asyncProcess: new Set(['method']),
+};
+
+const CORE_PACKAGE = '@craft-ts/core';
+
+module.exports = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description:
+        'Disallow imperative query, mutation, and asyncProcess triggers from craftEffect dependency graphs.',
+    },
+    schema: [],
+    messages: {
+      forbidden:
+        'Imperative {{primitive}}.{{method}}(...) is forbidden from a craftEffect dependency graph. Trigger the resource from a declarative source or outside the effect.',
+      indirectForbidden:
+        'This craftEffect depends on a craftGen that imperatively calls {{primitive}}.{{method}}(...). Trigger the resource from a declarative source or outside the effect.',
+    },
+  },
+
+  create(context) {
+    const sourceCode = context.sourceCode ?? context.getSourceCode();
+    const imported = new Map();
+    const effectNames = new Set(['craftEffect']);
+    const craftGenNames = new Set(['craftGen']);
+    const primitiveNames = new Map();
+    const primitiveRefs = new Map();
+    const craftGenFactories = new Map();
+    const effectCallbacks = [];
+
+    return {
+      ImportDeclaration(node) {
+        if (node.source.value !== CORE_PACKAGE) return;
+
+        for (const specifier of node.specifiers) {
+          if (specifier.type !== 'ImportSpecifier') continue;
+          const importedName = specifier.imported.name;
+          const localName = specifier.local.name;
+          imported.set(localName, importedName);
+          if (importedName === 'craftEffect') effectNames.add(localName);
+          if (importedName === 'craftGen') craftGenNames.add(localName);
+          if (PRIMITIVE_METHODS[importedName]) {
+            primitiveNames.set(localName, importedName);
+          }
+        }
+      },
+
+      CallExpression(node) {
+        if (
+          node.callee.type !== 'Identifier' ||
+          !effectNames.has(node.callee.name)
+        ) {
+          return;
+        }
+
+        const callback = [...node.arguments]
+          .reverse()
+          .find(isFunction);
+        if (callback) effectCallbacks.push(callback);
+      },
+
+      VariableDeclarator(node) {
+        if (node.id.type === 'Identifier') {
+          const primitive = findPrimitiveCreation(node.init);
+          if (primitive) {
+            primitiveRefs.set(node.id.name, {
+              primitive,
+              methods: PRIMITIVE_METHODS[primitive],
+            });
+          }
+        }
+
+        if (
+          node.id.type === 'Identifier' &&
+          node.init?.type === 'CallExpression' &&
+          node.init.callee.type === 'Identifier' &&
+          craftGenNames.has(node.init.callee.name) &&
+          isFunction(node.init.arguments[0])
+        ) {
+          craftGenFactories.set(node.id.name, node.init.arguments[0]);
+        }
+
+        if (node.id.type === 'ObjectPattern') {
+          const primitive = findPrimitiveCreation(node.init);
+          if (!primitive) return;
+
+          for (const property of node.id.properties) {
+            if (
+              property.type !== 'Property' ||
+              property.computed ||
+              property.value.type !== 'Identifier'
+            ) {
+              continue;
+            }
+
+            const propertyName = getPropertyName(property.key);
+            if (!propertyName) continue;
+            primitiveRefs.set(property.value.name, {
+              primitive,
+              methods: PRIMITIVE_METHODS[primitive],
+            });
+          }
+        }
+      },
+
+      'Program:exit'() {
+        // Resolve simple aliases after all primitive destructuring declarations
+        // have been collected. This covers `const q = users;` in an effect.
+        let changed = true;
+        while (changed) {
+          changed = false;
+          walkProgram(sourceCode.ast, (node) => {
+            if (
+              node.type !== 'VariableDeclarator' ||
+              node.id.type !== 'Identifier' ||
+              node.init?.type !== 'Identifier'
+            ) {
+              return;
+            }
+            const ref = primitiveRefs.get(node.init.name);
+            if (ref && !primitiveRefs.has(node.id.name)) {
+              primitiveRefs.set(node.id.name, ref);
+              changed = true;
+            }
+          });
+        }
+
+        const reported = new Set();
+        for (const callback of effectCallbacks) {
+          scan(callback, reported);
+        }
+
+        function scan(root, reportedNodes) {
+          walk(root, (node) => {
+            if (node.type === 'CallExpression') {
+              const trigger = getTrigger(node);
+              if (trigger && !reportedNodes.has(node)) {
+                reportedNodes.add(node);
+                context.report({
+                  node,
+                  messageId: 'forbidden',
+                  data: trigger,
+                });
+              }
+
+              if (
+                node.callee.type === 'Identifier' &&
+                craftGenFactories.has(node.callee.name)
+              ) {
+                const factory = craftGenFactories.get(node.callee.name);
+                const indirectTrigger = findForbiddenTrigger(factory);
+                if (indirectTrigger && !reportedNodes.has(node)) {
+                  reportedNodes.add(node);
+                  context.report({
+                    node,
+                    messageId: 'indirectForbidden',
+                    data: indirectTrigger,
+                  });
+                }
+              }
+            }
+          });
+        }
+
+        function findForbiddenTrigger(root, seen = new Set()) {
+          if (!root || seen.has(root)) return null;
+          seen.add(root);
+
+          let found = null;
+          walk(root, (node) => {
+            if (found) return;
+
+            const trigger =
+              node.type === 'CallExpression' ? getTrigger(node) : null;
+            if (trigger) {
+              found = trigger;
+              return;
+            }
+
+            if (
+              node.type === 'CallExpression' &&
+              node.callee.type === 'Identifier' &&
+              craftGenFactories.has(node.callee.name)
+            ) {
+              found = findForbiddenTrigger(
+                craftGenFactories.get(node.callee.name),
+                seen,
+              );
+            }
+          });
+
+          return found;
+        }
+      },
+    };
+
+    function getTrigger(node) {
+      if (node.callee.type !== 'MemberExpression') return null;
+      if (node.callee.object.type !== 'Identifier') return null;
+
+      const ref = primitiveRefs.get(node.callee.object.name);
+      if (!ref) return null;
+
+      const method = node.callee.computed
+        ? node.callee.property.type === 'Literal'
+          ? String(node.callee.property.value)
+          : undefined
+        : node.callee.property.name;
+      if (!method || !ref.methods.has(method)) return null;
+
+      return { primitive: ref.primitive, method };
+    }
+
+    function findPrimitiveCreation(node) {
+      let current = node;
+      while (current) {
+        if (current.type === 'YieldExpression') {
+          current = current.argument;
+          continue;
+        }
+        if (
+          current.type === 'TSAsExpression' ||
+          current.type === 'TSTypeAssertion' ||
+          current.type === 'ChainExpression'
+        ) {
+          current = current.expression;
+          continue;
+        }
+        if (current.type !== 'CallExpression') return undefined;
+
+        if (
+          current.callee.type === 'Identifier' &&
+          (current.callee.name === 'craftUse' ||
+            imported.get(current.callee.name) === 'craftUse')
+        ) {
+          current = current.arguments[0];
+          continue;
+        }
+
+        if (
+          current.callee.type === 'Identifier' &&
+          primitiveNames.has(current.callee.name)
+        ) {
+          return primitiveNames.get(current.callee.name);
+        }
+        return undefined;
+      }
+      return undefined;
+    }
+  },
+};
+
+function isFunction(node) {
+  return (
+    node &&
+    (node.type === 'FunctionExpression' ||
+      node.type === 'ArrowFunctionExpression')
+  );
+}
+
+function getPropertyName(node) {
+  if (node.type === 'Identifier') return node.name;
+  if (node.type === 'Literal' && typeof node.value === 'string') {
+    return node.value;
+  }
+  return undefined;
+}
+
+function walkProgram(root, visitor) {
+  walk(root, visitor);
+}
+
+function walk(node, visitor) {
+  if (!node || typeof node !== 'object') return;
+  if (node.type) visitor(node);
+
+  for (const [key, value] of Object.entries(node)) {
+    if (key === 'parent' || key === 'tokens' || key === 'comments') continue;
+    if (Array.isArray(value)) {
+      for (const child of value) {
+        if (child && typeof child.type === 'string') walk(child, visitor);
+      }
+    } else if (value && typeof value.type === 'string') {
+      walk(value, visitor);
+    }
+  }
+}

package/src/eslint-rules/no-important-in-component-styles.cjs

@@ -0,0 +1,12 @@
+const { componentInfo } = require('./css-rule-utils.cjs');
+module.exports = {
+  meta: { type: 'problem', schema: [], messages: { important: '!important is not allowed in encapsulated component styles.' } },
+  create(context) {
+    const sourceCode = context.sourceCode ?? context.getSourceCode();
+    return { CallExpression(node) {
+      const info = componentInfo(context, sourceCode, node);
+      if (info?.css && /!important\b/i.test(info.css)) context.report({ node: info.styles?.value ?? info.stylesUrl.value, messageId: 'important' });
+    } };
+  },
+};
+

package/src/eslint-rules/no-injection-token.cjs

@@ -0,0 +1,173 @@
+const MESSAGE =
+  "Do not use InjectionToken in app code. Declare the contract with craftService({ name: '...', providedIn: 'abstract' }, abstract<Contract>()) instead.";
+
+module.exports = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description:
+        'Disallow authored InjectionToken contracts in favor of abstract craftService contracts.',
+    },
+    schema: [],
+    messages: {
+      forbidden: MESSAGE,
+    },
+  },
+
+  create(context) {
+    const sourceCode = context.sourceCode ?? context.getSourceCode();
+    const importedNames = new Set();
+    const namespaceNames = new Set();
+    const reportedImportNames = new Set();
+    const reportedNodes = new Set();
+
+    return {
+      ImportDeclaration(node) {
+        for (const specifier of node.specifiers) {
+          if (
+            specifier.type === 'ImportSpecifier' &&
+            specifier.imported.type === 'Identifier' &&
+            specifier.imported.name === 'InjectionToken'
+          ) {
+            importedNames.add(specifier.local.name);
+            continue;
+          }
+
+          if (specifier.type === 'ImportNamespaceSpecifier') {
+            namespaceNames.add(specifier.local.name);
+          }
+        }
+      },
+
+      NewExpression(node) {
+        const tokenNode = getInjectionTokenNode(
+          node.callee,
+          importedNames,
+          namespaceNames,
+          sourceCode,
+        );
+        if (!tokenNode) {
+          return;
+        }
+
+        report(context, tokenNode, reportedNodes);
+        if (tokenNode.type === 'Identifier') {
+          reportedImportNames.add(tokenNode.name);
+        }
+      },
+
+      TSTypeReference(node) {
+        const tokenNode = getInjectionTokenNode(
+          node.typeName,
+          importedNames,
+          namespaceNames,
+          sourceCode,
+        );
+        if (tokenNode) {
+          report(context, tokenNode, reportedNodes);
+          if (tokenNode.type === 'Identifier') {
+            reportedImportNames.add(tokenNode.name);
+          }
+        }
+      },
+
+      'Program:exit'() {
+        for (const name of importedNames) {
+          if (reportedImportNames.has(name)) {
+            continue;
+          }
+
+          const specifier = findInjectionTokenImport(
+            sourceCode.ast,
+            name,
+          );
+          if (specifier) {
+            report(context, specifier, reportedNodes);
+          }
+        }
+      },
+    };
+  },
+};
+
+function getInjectionTokenNode(
+  node,
+  importedNames,
+  namespaceNames,
+  sourceCode,
+) {
+  if (
+    node.type === 'Identifier' &&
+    (importedNames.has(node.name) ||
+      (node.name === 'InjectionToken' && isUnshadowed(node, sourceCode)))
+  ) {
+    return node;
+  }
+
+  if (
+    node.type === 'MemberExpression' &&
+    !node.computed &&
+    node.object.type === 'Identifier' &&
+    namespaceNames.has(node.object.name) &&
+    node.property.type === 'Identifier' &&
+    node.property.name === 'InjectionToken'
+  ) {
+    return node.property;
+  }
+
+  if (
+    node.type === 'TSQualifiedName' &&
+    node.left.type === 'Identifier' &&
+    namespaceNames.has(node.left.name) &&
+    node.right.type === 'Identifier' &&
+    node.right.name === 'InjectionToken'
+  ) {
+    return node.right;
+  }
+
+  return undefined;
+}
+
+function findInjectionTokenImport(program, localName) {
+  for (const statement of program.body) {
+    if (statement.type !== 'ImportDeclaration') {
+      continue;
+    }
+
+    for (const specifier of statement.specifiers) {
+      if (
+        specifier.type === 'ImportSpecifier' &&
+        specifier.local.name === localName &&
+        specifier.imported.type === 'Identifier' &&
+        specifier.imported.name === 'InjectionToken'
+      ) {
+        return specifier;
+      }
+    }
+  }
+
+  return undefined;
+}
+
+function report(context, node, reportedNodes) {
+  if (reportedNodes.has(node)) {
+    return;
+  }
+
+  reportedNodes.add(node);
+  context.report({ node, messageId: 'forbidden' });
+}
+
+function isUnshadowed(node, sourceCode) {
+  let scope = sourceCode.getScope(node);
+
+  while (scope) {
+    const variable = scope.set?.get(node.name);
+    if (variable) {
+      return variable.defs.length === 0;
+    }
+    scope = scope.upper;
+  }
+
+  return true;
+}

package/src/eslint-rules/no-invalid-insertion-pipe.cjs

@@ -0,0 +1,162 @@
+const CORE_PACKAGE = '@craft-ts/core';
+
+const INSERTION_PIPES = new Set([
+  'insertAsyncProcessPipe',
+  'insertMutationPipe',
+  'insertQueryParamsPipe',
+  'insertQueryPipe',
+  'insertStateMachinePipe',
+  'insertStatePipe',
+]);
+
+module.exports = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description:
+        'Require typed insertion pipes to compose multiple meaningful insertions.',
+    },
+    fixable: 'code',
+    schema: [],
+    messages: {
+      multipleInsertions:
+        "'{{name}}' requires at least two insertions. Remove the pipe wrapper when there is only one insertion.",
+      noEmptyInsertion:
+        "'{{name}}' cannot contain an insertion callback that returns an empty object.",
+    },
+  },
+
+  create(context) {
+    const sourceCode = context.sourceCode ?? context.getSourceCode();
+    const pipeBindings = new Map();
+    const namespaceBindings = new Set();
+
+    return {
+      ImportDeclaration(node) {
+        if (node.source.value !== CORE_PACKAGE || node.importKind === 'type') {
+          return;
+        }
+
+        for (const specifier of node.specifiers) {
+          if (specifier.importKind === 'type') continue;
+
+          if (specifier.type === 'ImportSpecifier') {
+            const importedName = getIdentifierName(specifier.imported);
+            if (importedName && INSERTION_PIPES.has(importedName)) {
+              pipeBindings.set(specifier.local.name, importedName);
+            }
+            continue;
+          }
+
+          if (specifier.type === 'ImportNamespaceSpecifier') {
+            namespaceBindings.add(specifier.local.name);
+          }
+        }
+      },
+
+      CallExpression(node) {
+        const pipeName = getPipeName(
+          node.callee,
+          pipeBindings,
+          namespaceBindings,
+        );
+        if (!pipeName) return;
+
+        if (node.arguments.length < 2) {
+          context.report({
+            node,
+            messageId: 'multipleInsertions',
+            data: { name: pipeName },
+            ...(node.arguments.length === 1
+              ? {
+                  fix(fixer) {
+                    return fixer.replaceText(
+                      node,
+                      sourceCode.getText(node.arguments[0]),
+                    );
+                  },
+                }
+              : {}),
+          });
+        }
+
+        for (const argument of node.arguments) {
+          if (!isEmptyInsertionCallback(argument)) continue;
+
+          context.report({
+            node: argument,
+            messageId: 'noEmptyInsertion',
+            data: { name: pipeName },
+          });
+        }
+      },
+    };
+  },
+};
+
+function getPipeName(callee, pipeBindings, namespaceBindings) {
+  if (callee.type === 'Identifier') {
+    return pipeBindings.get(callee.name);
+  }
+
+  if (
+    callee.type !== 'MemberExpression' ||
+    callee.computed ||
+    callee.object.type !== 'Identifier' ||
+    callee.property.type !== 'Identifier' ||
+    !namespaceBindings.has(callee.object.name) ||
+    !INSERTION_PIPES.has(callee.property.name)
+  ) {
+    return undefined;
+  }
+
+  return callee.property.name;
+}
+
+function isEmptyInsertionCallback(node) {
+  const callback = unwrap(node);
+  if (
+    callback.type !== 'ArrowFunctionExpression' &&
+    callback.type !== 'FunctionExpression'
+  ) {
+    return false;
+  }
+
+  const body = unwrap(callback.body);
+  if (body.type === 'ObjectExpression') {
+    return body.properties.length === 0;
+  }
+
+  if (body.type !== 'BlockStatement' || body.body.length !== 1) {
+    return false;
+  }
+
+  const statement = body.body[0];
+  return (
+    statement.type === 'ReturnStatement' &&
+    statement.argument != null &&
+    unwrap(statement.argument).type === 'ObjectExpression' &&
+    unwrap(statement.argument).properties.length === 0
+  );
+}
+
+function unwrap(node) {
+  let current = node;
+  while (
+    current &&
+    [
+      'ChainExpression',
+      'TSAsExpression',
+      'TSNonNullExpression',
+      'TSSatisfiesExpression',
+      'TSTypeAssertion',
+    ].includes(current.type)
+  ) {
+    current = current.expression;
+  }
+  return current;
+}
+
+function getIdentifierName(node) {
+  return node.type === 'Identifier' ? node.name : undefined;
+}