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

package/src/eslint-rules/security-rule-utils.cjs

@@ -0,0 +1,21 @@
+function report(context, node, message) {
+  context.report({ node, message });
+}
+
+function propertyName(node) {
+  if (!node) return undefined;
+  if (!node.computed && node.property && node.property.type === 'Identifier') {
+    return node.property.name;
+  }
+  if (node.computed && node.property && node.property.type === 'Literal') {
+    return String(node.property.value);
+  }
+  return undefined;
+}
+
+function isCallNamed(node, name) {
+  return node && node.type === 'CallExpression' &&
+    node.callee && node.callee.type === 'Identifier' && node.callee.name === name;
+}
+
+module.exports = { report, propertyName, isCallNamed };

package/src/eslint-rules/style-file-boundary.cjs

@@ -0,0 +1,75 @@
+const ALLOWED_MODULES = ['@craft-ts/style'];
+
+/**
+ * A `*.style.ts` may import style vocabulary and nothing else.
+ *
+ * This is not a taste rule: the build plugin **imports these modules in Node**
+ * to read the values they register. An application import would drag component
+ * code, DI, or browser globals into that evaluation, and the emitter would
+ * either crash or — worse — succeed while running application side effects at
+ * build time.
+ *
+ * Relative imports are allowed only between style files, so a design system can
+ * be split across several of them.
+ */
+module.exports = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description:
+        'Restrict *.style.ts files to style vocabulary imports so the build plugin can evaluate them in Node.',
+    },
+    schema: [
+      {
+        type: 'object',
+        properties: {
+          allow: { type: 'array', items: { type: 'string' } },
+          suffix: { type: 'string' },
+        },
+        additionalProperties: false,
+      },
+    ],
+    messages: {
+      applicationImport:
+        "A style file may only import style vocabulary, and '{{source}}' is not. The build plugin imports this file in Node to read the values it registers; an application import would run application code at build time. Move what you need into the sheet, or into another *.style.ts.",
+    },
+  },
+  create(context) {
+    const options = context.options[0] ?? {};
+    const allowed = new Set([...ALLOWED_MODULES, ...(options.allow ?? [])]);
+    const suffix = options.suffix ?? '.style.ts';
+    const filename = context.filename ?? context.getFilename();
+
+    if (!filename.endsWith(suffix)) return {};
+
+    const check = (node, source) => {
+      if (typeof source !== 'string') return;
+      if (allowed.has(source)) return;
+      // A relative import is fine as long as it lands on another style file:
+      // splitting a design system across files must stay possible.
+      if (source.startsWith('.') && source.endsWith('.style')) return;
+      if (source.startsWith('.') && source.endsWith(suffix.slice(0, -3)))
+        return;
+      context.report({
+        node,
+        messageId: 'applicationImport',
+        data: { source },
+      });
+    };
+
+    return {
+      ImportDeclaration(node) {
+        check(node, node.source.value);
+      },
+      ExportNamedDeclaration(node) {
+        if (node.source) check(node, node.source.value);
+      },
+      ExportAllDeclaration(node) {
+        if (node.source) check(node, node.source.value);
+      },
+      ImportExpression(node) {
+        if (node.source.type === 'Literal') check(node, node.source.value);
+      },
+    };
+  },
+};

package/src/eslint-rules/sync-effect-body.cjs

@@ -0,0 +1,343 @@
+// ---------------------------------------------------------------------------
+// `SyncOp` in `R` is a CLAIM: an author writing `Effect<A, E, SyncOp>` promises
+// the Effect never suspends. The type system cannot check that claim — a
+// service member closes its dependencies at Layer construction, so an async
+// member and a pure one both surface as `R = never` and stay indistinguishable.
+//
+// This rule reads the body instead, all branches at once, which is the thing a
+// unit test cannot do: it needs no fixture, and a branch that only suspends on
+// a cold cache is as visible as one that always does.
+//
+// It works by ELIMINATION. Requirements union through `Effect.gen`, so anything
+// yielded that is itself declared synchronous carries `SyncOp` and passes for
+// free. What is left ambiguous is `R = never`: either a pure constructor
+// (`Effect.succeed`) or an async member whose Layer swallowed its dependencies.
+// The first list is short and closed, so it is the one spelled out here; the
+// rest is refused, and the author either declares it or moves it to a loader.
+// ---------------------------------------------------------------------------
+
+const EFFECT_PACKAGE = 'effect';
+const CRAFT_EFFECT_PACKAGE = '@craft-ts/effect';
+
+/** Constructors that cannot suspend — the closed list `R = never` needs. */
+const PURE_EFFECT_CONSTRUCTORS = new Set([
+  'succeed',
+  'sync',
+  'fail',
+  'failSync',
+  'die',
+  'dieSync',
+  'void',
+  'try',
+  'succeedNone',
+  'succeedSome',
+  'fromNullable',
+]);
+
+/** Constructors that always suspend — named so the message can be specific. */
+const ASYNC_EFFECT_CONSTRUCTORS = new Set([
+  'promise',
+  'tryPromise',
+  'sleep',
+  'async',
+  'callback',
+  'never',
+  'delay',
+  'timeout',
+]);
+
+const SYNC_OP_PATTERN = /\bSyncOp\b/;
+
+/** `ts.SymbolFlags.Class`. */
+const SYMBOL_FLAG_CLASS = 32;
+
+module.exports = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description:
+        'Keep a body declared synchronous (SyncOp) free of anything that may suspend.',
+    },
+    schema: [],
+    messages: {
+      asyncConstructor:
+        'Effect.{{name}}(...) always suspends: it cannot appear in a body declared synchronous (SyncOp).\nMove the asynchronous work to a loader (queryEffect / mutationEffect / asyncProcessEffect).',
+      notDeclaredSync:
+        'This body is declared synchronous (SyncOp) but yields {{what}}, which nothing declares synchronous.\nAdd SyncOp to its requirements if it is pure, or move the work to a loader (queryEffect / mutationEffect / asyncProcessEffect).',
+    },
+  },
+
+  create(context) {
+    const sourceCode = context.sourceCode ?? context.getSourceCode();
+    const parserServices = sourceCode.parserServices ?? context.parserServices;
+    const checker = parserServices?.program?.getTypeChecker?.();
+    const nodeMap = parserServices?.esTreeNodeToTSNodeMap;
+    const keys = sourceCode.visitorKeys ?? {};
+
+    const effectBindings = new Set();
+    const syncOpBindings = new Set();
+
+    return {
+      ImportDeclaration(node) {
+        if (node.importKind === 'type') return;
+        const source = node.source.value;
+
+        for (const specifier of node.specifiers) {
+          if (
+            specifier.type === 'ImportNamespaceSpecifier' &&
+            source === EFFECT_PACKAGE
+          ) {
+            effectBindings.add(specifier.local.name);
+            continue;
+          }
+
+          if (specifier.type !== 'ImportSpecifier') continue;
+          const imported = getIdentifierName(specifier.imported);
+
+          if (source === EFFECT_PACKAGE && imported === 'Effect') {
+            effectBindings.add(specifier.local.name);
+          }
+          if (source === CRAFT_EFFECT_PACKAGE && imported === 'SyncOp') {
+            syncOpBindings.add(specifier.local.name);
+          }
+        }
+      },
+
+      CallExpression(node) {
+        if (!isEffectMemberCall(node.callee, 'gen')) return;
+
+        const body = node.arguments.find((argument) =>
+          ['FunctionExpression', 'ArrowFunctionExpression'].includes(
+            argument?.type,
+          ),
+        );
+        if (!body) return;
+
+        const delegatedYields = collectDelegatedYields(body);
+        if (!isDeclaredSynchronous(node, delegatedYields)) return;
+
+        for (const yielded of delegatedYields) {
+          inspectYield(yielded);
+        }
+      },
+    };
+
+    // A body is declared synchronous either by yielding the marker itself — the
+    // spelling for an inferred `R` — or by the shape it is contextually typed
+    // against already spelling `SyncOp`, in which case the implementation needs
+    // no ceremony at all.
+    function isDeclaredSynchronous(genCall, delegatedYields) {
+      if (delegatedYields.some(isSyncOpReference)) return true;
+      return contextualTypeDeclaresSync(genCall);
+    }
+
+    function contextualTypeDeclaresSync(genCall) {
+      if (!checker || !nodeMap) return false;
+
+      // Walk out to the function whose return type the shape constrains.
+      let current = genCall.parent;
+      while (
+        current &&
+        !['ArrowFunctionExpression', 'FunctionExpression'].includes(
+          current.type,
+        )
+      ) {
+        if (current.type === 'CallExpression') return false;
+        current = current.parent;
+      }
+      if (!current) return false;
+
+      const tsNode = nodeMap.get(current);
+      if (!tsNode) return false;
+
+      const contextual = checker.getContextualType?.(tsNode);
+      return Boolean(contextual && SYNC_OP_PATTERN.test(safeToString(contextual)));
+    }
+
+    function inspectYield(yielded) {
+      if (isSyncOpReference(yielded)) return;
+
+      const asyncConstructor = getEffectConstructorName(
+        yielded,
+        ASYNC_EFFECT_CONSTRUCTORS,
+      );
+      if (asyncConstructor) {
+        context.report({
+          node: yielded,
+          messageId: 'asyncConstructor',
+          data: { name: asyncConstructor },
+        });
+        return;
+      }
+
+      if (getEffectConstructorName(yielded, PURE_EFFECT_CONSTRUCTORS)) return;
+      // `yield* SomeService` resolves a tag from the context in place; it is the
+      // Layer that already ran, not a suspension.
+      if (isServiceTagReference(yielded)) return;
+      if (typeDeclaresSync(yielded)) return;
+      // Without type information the rule cannot tell a pure member from an
+      // async one, and guessing either way is worse than staying silent.
+      if (!checker || !nodeMap) return;
+      // Not an Effect at all (a craft primitive relayed through the body).
+      if (!isEffectType(yielded)) return;
+
+      context.report({
+        node: yielded,
+        messageId: 'notDeclaredSync',
+        data: { what: describe(yielded) },
+      });
+    }
+
+    function isSyncOpReference(node) {
+      return node?.type === 'Identifier' && syncOpBindings.has(node.name);
+    }
+
+    function isEffectMemberCall(callee, memberName) {
+      return (
+        callee?.type === 'MemberExpression' &&
+        !callee.computed &&
+        callee.object.type === 'Identifier' &&
+        effectBindings.has(callee.object.name) &&
+        getIdentifierName(callee.property) === memberName
+      );
+    }
+
+    function getEffectConstructorName(node, names) {
+      const call = node?.type === 'CallExpression' ? node : undefined;
+      const callee = call ? call.callee : node;
+
+      if (
+        callee?.type !== 'MemberExpression' ||
+        callee.computed ||
+        callee.object.type !== 'Identifier' ||
+        !effectBindings.has(callee.object.name)
+      ) {
+        return undefined;
+      }
+
+      const name = getIdentifierName(callee.property);
+      return name && names.has(name) ? name : undefined;
+    }
+
+    // A bare identifier that resolves to a CLASS is a `Context.Service` tag:
+    // `yield* Pricing` reads it from the context in place — the Layer already
+    // ran. A bare identifier merely holding an Effect is not a class, and falls
+    // through to the type check below.
+    function isServiceTagReference(node) {
+      if (node?.type !== 'Identifier' || !checker || !nodeMap) return false;
+
+      const tsNode = nodeMap.get(node);
+      if (!tsNode) return false;
+
+      const symbol = checker.getSymbolAtLocation(tsNode);
+      // ts.SyntaxFlags.Class — compared numerically to keep the rule free of a
+      // typescript import, like the other typed rules in this folder.
+      return Boolean(symbol && (symbol.flags & SYMBOL_FLAG_CLASS) !== 0);
+    }
+
+    function typeDeclaresSync(node) {
+      if (!checker || !nodeMap) return false;
+      const type = getType(node);
+      return Boolean(type && SYNC_OP_PATTERN.test(safeToString(type)));
+    }
+
+    function isEffectType(node) {
+      const type = getType(node);
+      if (!type) return false;
+      const text = safeToString(type);
+      if (/\bEffect(?:\.Effect)?\s*</.test(text)) return true;
+      const symbol = type.aliasSymbol ?? type.getSymbol?.();
+      const name = symbol && String(symbol.escapedName ?? symbol.name);
+      return name === 'Effect';
+    }
+
+    function getType(node) {
+      if (!checker || !nodeMap || !node) return undefined;
+      const tsNode = nodeMap.get(node);
+      if (!tsNode) return undefined;
+      try {
+        return checker.getTypeAtLocation(tsNode);
+      } catch {
+        return undefined;
+      }
+    }
+
+    function safeToString(type) {
+      try {
+        return checker.typeToString(type);
+      } catch {
+        return '';
+      }
+    }
+
+    function describe(node) {
+      const text = sourceCode.getText(node);
+      return text.length > 60 ? `${text.slice(0, 57)}…` : text;
+    }
+
+    function collectDelegatedYields(functionNode) {
+      const found = [];
+      walk(
+        functionNode,
+        (child) => {
+          // A nested `Effect.gen` carries its own declaration and gets its own
+          // visit — descending into it here would blame the wrong body.
+          if (child !== functionNode && isEffectGenCall(child)) {
+            return 'skip';
+          }
+
+          if (child.type === 'YieldExpression' && child.delegate) {
+            const argument = unwrap(child.argument);
+            if (argument) found.push(argument);
+          }
+
+          return undefined;
+        },
+        keys,
+      );
+      return found;
+    }
+
+    function isEffectGenCall(node) {
+      return node.type === 'CallExpression' && isEffectMemberCall(node.callee, 'gen');
+    }
+  },
+};
+
+function getIdentifierName(node) {
+  if (!node) return undefined;
+  if (node.type === 'Identifier') return node.name;
+  if (node.type === 'Literal' && typeof node.value === 'string') {
+    return node.value;
+  }
+  return undefined;
+}
+
+function unwrap(node) {
+  let current = node;
+  while (
+    current &&
+    (current.type === 'TSAsExpression' ||
+      current.type === 'TSNonNullExpression' ||
+      current.type === 'TSSatisfiesExpression')
+  ) {
+    current = current.expression;
+  }
+  return current;
+}
+
+function walk(node, visit, keys) {
+  if (!node || typeof node.type !== 'string') return;
+  if (visit(node) === 'skip') return;
+
+  const childKeys = keys[node.type] ?? Object.keys(node);
+  for (const key of childKeys) {
+    if (key === 'parent') continue;
+    const value = node[key];
+    if (Array.isArray(value)) {
+      for (const child of value) walk(child, visit, keys);
+    } else if (value && typeof value.type === 'string') {
+      walk(value, visit, keys);
+    }
+  }
+}

package/src/index.d.ts

@@ -17,5 +17,9 @@ export * from './scripts/components/migration-diagnostic.js';
 export * from './scripts/architecture/migrate-architecture.js';
 export * from './scripts/dependency-graph.js';
 export * from './scripts/architecture-graph.js';
+export * from './scripts/style-graph.js';
+export * from './scripts/style-architecture.js';
+export * from './scripts/style-report.js';
+export * from './scripts/security-check.js';
 export * from './scripts/create/create-project.js';
 export * from './template-migration.js';

package/src/index.js

@@ -18,6 +18,10 @@ export * from './scripts/components/migration-diagnostic.js';
 export * from './scripts/architecture/migrate-architecture.js';
 export * from './scripts/dependency-graph.js';
 export * from './scripts/architecture-graph.js';
+export * from './scripts/style-graph.js';
+export * from './scripts/style-architecture.js';
+export * from './scripts/style-report.js';
+export * from './scripts/security-check.js';
 export * from './scripts/create/create-project.js';
 export * from './template-migration.js';
 //# sourceMappingURL=index.js.map

package/src/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../libs/dev-tools/src/index.ts"],"names":[],"mappings":"AAAA,sCAAsC;AACtC,cAAc,oCAAoC,CAAC;AACnD,cAAc,4CAA4C,CAAC;AAC3D,cAAc,kDAAkD,CAAC;AACjE,cAAc,sDAAsD,CAAC;AACrE,cAAc,0DAA0D,CAAC;AACzE,cAAc,sBAAsB,CAAC;AACrC,cAAc,8CAA8C,CAAC;AAC7D,cAAc,oCAAoC,CAAC;AACnD,cAAc,0CAA0C,CAAC;AACzD,cAAc,mCAAmC,CAAC;AAClD,cAAc,mCAAmC,CAAC;AAClD,cAAc,8BAA8B,CAAC;AAC7C,cAAc,wCAAwC,CAAC;AACvD,cAAc,4CAA4C,CAAC;AAC3D,cAAc,4CAA4C,CAAC;AAC3D,cAAc,8CAA8C,CAAC;AAC7D,cAAc,gDAAgD,CAAC;AAC/D,cAAc,+BAA+B,CAAC;AAC9C,cAAc,iCAAiC,CAAC;AAChD,cAAc,oCAAoC,CAAC;AACnD,cAAc,yBAAyB,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../libs/dev-tools/src/index.ts"],"names":[],"mappings":"AAAA,sCAAsC;AACtC,cAAc,oCAAoC,CAAC;AACnD,cAAc,4CAA4C,CAAC;AAC3D,cAAc,kDAAkD,CAAC;AACjE,cAAc,sDAAsD,CAAC;AACrE,cAAc,0DAA0D,CAAC;AACzE,cAAc,sBAAsB,CAAC;AACrC,cAAc,8CAA8C,CAAC;AAC7D,cAAc,oCAAoC,CAAC;AACnD,cAAc,0CAA0C,CAAC;AACzD,cAAc,mCAAmC,CAAC;AAClD,cAAc,mCAAmC,CAAC;AAClD,cAAc,8BAA8B,CAAC;AAC7C,cAAc,wCAAwC,CAAC;AACvD,cAAc,4CAA4C,CAAC;AAC3D,cAAc,4CAA4C,CAAC;AAC3D,cAAc,8CAA8C,CAAC;AAC7D,cAAc,gDAAgD,CAAC;AAC/D,cAAc,+BAA+B,CAAC;AAC9C,cAAc,iCAAiC,CAAC;AAChD,cAAc,0BAA0B,CAAC;AACzC,cAAc,iCAAiC,CAAC;AAChD,cAAc,2BAA2B,CAAC;AAC1C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,oCAAoC,CAAC;AACnD,cAAc,yBAAyB,CAAC"}

package/src/scripts/architecture-graph.js

@@ -1161,8 +1161,14 @@ export function primitiveLoaderRequirementViolations(graph, rule) {
         const label = primitiveDisplayName(primitive);
         if (allowed.has(label) || allowed.has(primitive.label))
             return [];
-        const loaderEdges = graph.edges.filter((edge) => edge.from === primitive.id &&
-            edge.details?.['resourceRole'] === 'loader');
+        const loaderEdges = graph.edges.filter((edge) => {
+            if (edge.from !== primitive.id)
+                return false;
+            const role = edge.details?.['resourceRole'];
+            return (role === 'loader' ||
+                (primitive.details?.['primitive'] === 'computedEffect' &&
+                    role === 'computed'));
+        });
         const satisfied = loaderEdges.some((edge) => {
             const target = nodesById.get(edge.to);
             if (!target)