@ontrails/warden 1.0.0-beta.23 → 1.0.0-beta.29

package/src/rules/implementation-returns-result.ts

@@ -6,14 +6,31 @@
  * or a tracked Result-typed variable.
  */
 
-import { dirname, isAbsolute, resolve } from 'node:path';
 import { existsSync, readFileSync } from 'node:fs';
+import { dirname, isAbsolute, resolve } from 'node:path';
 import type { AstNode } from './ast.js';
 import {
   collectScopeFrameBindings,
   findBlazeBodies,
   findTrailDefinitions,
   getMemberExpression,
+  getNodeAlternate,
+  getNodeArgument,
+  getNodeBodyNode,
+  getNodeBodyStatements,
+  getNodeConsequent,
+  getNodeDeclaration,
+  getNodeExportKind,
+  getNodeExpression,
+  getNodeId,
+  getNodeImported,
+  getNodeInit,
+  getNodeLocal,
+  getNodeName,
+  getNodeReturnType,
+  getNodeSource,
+  getNodeTypeAnnotation,
+  getNodeValue,
   identifierName,
   offsetToLine,
   parse,
@@ -61,7 +78,7 @@ export const isResultExpression = (node: AstNode): boolean => {
   }
 
   if (node.type === 'AwaitExpression') {
-    const arg = (node as unknown as { argument?: AstNode }).argument;
+    const arg = getNodeArgument(node);
     return arg ? isResultExpression(arg) : false;
   }
 
@@ -79,6 +96,13 @@ export type ScopedHelperMap = ReadonlyMap<
 
 export type MutableScopedHelperMap = Map<ReadonlySet<string>, Set<string>>;
 
+type ScopedResultVariableMap = ReadonlyMap<
+  ReadonlySet<string>,
+  ReadonlySet<string>
+>;
+
+type MutableScopedResultVariableMap = Map<ReadonlySet<string>, Set<string>>;
+
 export const findNearestBindingScope = (
   name: string,
   scopes: readonly ReadonlySet<string>[]
@@ -91,6 +115,15 @@ const isScopedHelperBinding = (
   scopedHelpers: ScopedHelperMap
 ): boolean => scopedHelpers.get(scope)?.has(name) ?? false;
 
+const isScopedResultVariableBinding = (
+  name: string,
+  scopes: readonly ReadonlySet<string>[],
+  resultVars: ScopedResultVariableMap
+): boolean => {
+  const bindingScope = findNearestBindingScope(name, scopes);
+  return Boolean(bindingScope && resultVars.get(bindingScope)?.has(name));
+};
+
 /**
  * Check whether a namespace-member call like `ns.helper(...)` resolves to a
  * known Result helper.
@@ -131,9 +164,7 @@ export const isHelperCall = (
   scopedHelpers: ScopedHelperMap = new Map()
 ): boolean => {
   const target =
-    node.type === 'AwaitExpression'
-      ? ((node as unknown as { argument?: AstNode }).argument ?? null)
-      : node;
+    node.type === 'AwaitExpression' ? (getNodeArgument(node) ?? null) : node;
 
   if (!target || target.type !== 'CallExpression') {
     return false;
@@ -141,7 +172,10 @@ export const isHelperCall = (
 
   const callee = target['callee'] as AstNode | undefined;
   if (callee?.type === 'Identifier') {
-    const { name } = callee as unknown as { name: string };
+    const name = getNodeName(callee);
+    if (!name) {
+      return false;
+    }
     const bindingScope = findNearestBindingScope(name, scopes);
     if (
       bindingScope &&
@@ -160,37 +194,83 @@ export const isHelperCall = (
 /** Unwrap an optional AwaitExpression to get the inner identifier name. */
 const resolveIdentifierName = (node: AstNode): string | null => {
   if (node.type === 'Identifier') {
-    return (node as unknown as { name: string }).name;
+    return getNodeName(node) ?? null;
   }
   if (node.type === 'AwaitExpression') {
-    const inner = (node as unknown as { argument?: AstNode }).argument;
+    const inner = getNodeArgument(node);
     if (inner?.type === 'Identifier') {
-      return (inner as unknown as { name: string }).name;
+      return getNodeName(inner) ?? null;
     }
   }
   return null;
 };
 
+const unwrapReturnExpression = (node: AstNode): AstNode => {
+  let current = node;
+  while (
+    current.type === 'AwaitExpression' ||
+    current.type === 'ParenthesizedExpression'
+  ) {
+    const next =
+      current.type === 'AwaitExpression'
+        ? getNodeArgument(current)
+        : getNodeExpression(current);
+    if (!next) {
+      return current;
+    }
+    current = next;
+  }
+  return current;
+};
+
 /** Check if a return argument is an allowed Result value. */
 const isAllowedReturnArgument = (
   argument: AstNode,
   helperNames: ReadonlySet<string>,
-  resultVars: ReadonlySet<string>,
+  resultVars: ScopedResultVariableMap,
   namespaceHelpers: NamespaceHelperMap,
   scopes: readonly ReadonlySet<string>[] = [],
   scopedHelpers: ScopedHelperMap = new Map()
 ): boolean => {
-  if (isResultExpression(argument)) {
+  const target = unwrapReturnExpression(argument);
+  if (target.type === 'ConditionalExpression') {
+    const alternate = getNodeAlternate(target);
+    const consequent = getNodeConsequent(target);
+    return (
+      consequent !== undefined &&
+      alternate !== undefined &&
+      isAllowedReturnArgument(
+        consequent,
+        helperNames,
+        resultVars,
+        namespaceHelpers,
+        scopes,
+        scopedHelpers
+      ) &&
+      isAllowedReturnArgument(
+        alternate,
+        helperNames,
+        resultVars,
+        namespaceHelpers,
+        scopes,
+        scopedHelpers
+      )
+    );
+  }
+  if (isResultExpression(target)) {
     return true;
   }
   if (
-    isHelperCall(argument, helperNames, namespaceHelpers, scopes, scopedHelpers)
+    isHelperCall(target, helperNames, namespaceHelpers, scopes, scopedHelpers)
   ) {
     return true;
   }
 
-  const varName = resolveIdentifierName(argument);
-  return varName !== null && resultVars.has(varName);
+  const varName = resolveIdentifierName(target);
+  return (
+    varName !== null &&
+    isScopedResultVariableBinding(varName, scopes, resultVars)
+  );
 };
 
 // ---------------------------------------------------------------------------
@@ -198,17 +278,13 @@ const isAllowedReturnArgument = (
 // ---------------------------------------------------------------------------
 
 const getImportSourceValue = (node: AstNode): string | null => {
-  const sourceNode = (node as unknown as { source?: AstNode }).source;
-  const sourceValue = sourceNode
-    ? (sourceNode as unknown as { value?: unknown }).value
-    : undefined;
+  const sourceNode = getNodeSource(node);
+  const sourceValue = sourceNode ? getNodeValue(sourceNode) : undefined;
   return typeof sourceValue === 'string' ? sourceValue : null;
 };
 
 const extractIdentifierName = (node: AstNode | undefined): string | null =>
-  node?.type === 'Identifier'
-    ? ((node as unknown as { name: string }).name ?? null)
-    : null;
+  node?.type === 'Identifier' ? (getNodeName(node) ?? null) : null;
 
 const DEFAULT_RESULT_TYPE_NAMES = new Set(['Result']);
 
@@ -236,10 +312,8 @@ export const collectResultTypeNames = (ast: AstNode): ReadonlySet<string> => {
       if (specifier.type !== 'ImportSpecifier') {
         continue;
       }
-      const { imported, local } = specifier as unknown as {
-        imported?: AstNode;
-        local?: AstNode;
-      };
+      const imported = getNodeImported(specifier);
+      const local = getNodeLocal(specifier);
       if (extractIdentifierName(imported) !== 'Result') {
         continue;
       }
@@ -255,7 +329,7 @@ const hasResultReturnType = (
   sourceCode: string,
   resultTypeNames: ReadonlySet<string> = DEFAULT_RESULT_TYPE_NAMES
 ): boolean => {
-  const { returnType } = node as unknown as { returnType?: AstNode };
+  const returnType = getNodeReturnType(node);
   if (!returnType) {
     return false;
   }
@@ -284,6 +358,19 @@ const addScopedHelper = (
   scopedHelpers.set(scope, new Set([name]));
 };
 
+const addScopedResultVariable = (
+  resultVars: MutableScopedResultVariableMap,
+  scope: ReadonlySet<string>,
+  name: string
+): void => {
+  const existing = resultVars.get(scope);
+  if (existing) {
+    existing.add(name);
+    return;
+  }
+  resultVars.set(scope, new Set([name]));
+};
+
 /** Record `const helper = (): Result<...> => ...` declarations for the current lexical scope. */
 export const trackScopedResultHelperDeclaration = (
   node: AstNode,
@@ -295,7 +382,8 @@ export const trackScopedResultHelperDeclaration = (
   if (node.type !== 'VariableDeclarator') {
     return;
   }
-  const { id, init } = node as unknown as { id?: AstNode; init?: AstNode };
+  const id = getNodeId(node);
+  const init = getNodeInit(node);
   const name = extractIdentifierName(id);
   if (!(name && init && isFunctionLikeExpression(init))) {
     return;
@@ -313,24 +401,54 @@ export const trackScopedResultHelperDeclaration = (
 // Variable tracking
 // ---------------------------------------------------------------------------
 
+const hasResultVariableAnnotation = (
+  node: AstNode,
+  sourceCode: string,
+  resultTypeNames: ReadonlySet<string>
+): boolean => {
+  const typeAnnotation = getNodeTypeAnnotation(node);
+  if (!typeAnnotation) {
+    return false;
+  }
+  const annotationText = sourceCode.slice(
+    typeAnnotation.start,
+    typeAnnotation.end
+  );
+  for (const name of resultTypeNames) {
+    if (hasGenericTypeReference(annotationText, name)) {
+      return true;
+    }
+  }
+  return false;
+};
+
 /** Track a VariableDeclarator, adding to resultVars if it produces a Result. */
 const trackResultVariable = (
   node: AstNode,
-  resultVars: Set<string>,
+  resultVars: MutableScopedResultVariableMap,
   helperNames: ReadonlySet<string>,
   namespaceHelpers: NamespaceHelperMap,
   scopes: readonly ReadonlySet<string>[],
-  scopedHelpers: ScopedHelperMap
+  scopedHelpers: ScopedHelperMap,
+  sourceCode: string,
+  resultTypeNames: ReadonlySet<string>
 ): void => {
-  const { init } = node as unknown as { init?: AstNode };
-  const { id } = node as unknown as { id?: AstNode };
+  const init = getNodeInit(node);
+  const id = getNodeId(node);
   if (init && id?.type === 'Identifier') {
-    const { name } = id as unknown as { name: string };
+    const name = getNodeName(id);
+    if (!name) {
+      return;
+    }
     if (
+      hasResultVariableAnnotation(id, sourceCode, resultTypeNames) ||
       isResultExpression(init) ||
       isHelperCall(init, helperNames, namespaceHelpers, scopes, scopedHelpers)
     ) {
-      resultVars.add(name);
+      const bindingScope = findNearestBindingScope(name, scopes);
+      if (bindingScope) {
+        addScopedResultVariable(resultVars, bindingScope, name);
+      }
     }
   }
 };
@@ -351,7 +469,7 @@ const checkReturnStatements = (
   diagnostics: WardenDiagnostic[],
   implScope: ReadonlySet<string> = new Set<string>()
 ): void => {
-  const resultVars = new Set<string>();
+  const resultVars: MutableScopedResultVariableMap = new Map();
   const scopedHelpers: MutableScopedHelperMap = new Map();
   const initialScopes = implScope.size > 0 ? [implScope] : [];
 
@@ -372,7 +490,9 @@ const checkReturnStatements = (
           helperNames,
           namespaceHelpers,
           currentScopes,
-          scopedHelpers
+          scopedHelpers,
+          sourceCode,
+          resultTypeNames
         );
       }
 
@@ -380,7 +500,7 @@ const checkReturnStatements = (
         return;
       }
 
-      const { argument } = node as unknown as { argument?: AstNode };
+      const argument = getNodeArgument(node);
       // Bare return is not a value return.
       if (!argument) {
         return;
@@ -421,25 +541,31 @@ const collectResultHelperNames = (
 
   walk(ast, (node) => {
     if (node.type === 'VariableDeclarator') {
-      const { id } = node as unknown as { id?: AstNode };
-      const { init } = node as unknown as { init?: AstNode };
+      const id = getNodeId(node);
+      const init = getNodeInit(node);
       if (
         id?.type === 'Identifier' &&
         init &&
         isFunctionLikeExpression(init) &&
         hasResultReturnType(init, sourceCode, resultTypeNames)
       ) {
-        names.add((id as unknown as { name: string }).name);
+        const name = getNodeName(id);
+        if (name) {
+          names.add(name);
+        }
       }
     }
 
     if (node.type === 'FunctionDeclaration') {
-      const { id } = node as unknown as { id?: AstNode };
+      const id = getNodeId(node);
       if (
         id?.type === 'Identifier' &&
         hasResultReturnType(node, sourceCode, resultTypeNames)
       ) {
-        names.add((id as unknown as { name: string }).name);
+        const name = getNodeName(id);
+        if (name) {
+          names.add(name);
+        }
       }
     }
   });
@@ -490,7 +616,7 @@ const buildDefaultImportBinding = (
   specifier: AstNode,
   source: string
 ): ImportBinding | null => {
-  const { local } = specifier as unknown as { local?: AstNode };
+  const local = getNodeLocal(specifier);
   const localName = extractIdentifierName(local);
   if (!localName) {
     return null;
@@ -502,10 +628,8 @@ const buildNamedImportBinding = (
   specifier: AstNode,
   source: string
 ): ImportBinding | null => {
-  const { local, imported } = specifier as unknown as {
-    local?: AstNode;
-    imported?: AstNode;
-  };
+  const local = getNodeLocal(specifier);
+  const imported = getNodeImported(specifier);
   const localName = extractIdentifierName(local);
   const importedName = extractIdentifierName(imported) ?? localName;
   if (!(localName && importedName)) {
@@ -551,7 +675,9 @@ const collectBindingsFromImportDeclaration = (
   });
 };
 
-/** Collect `import { foo as bar } from './...'` bindings keyed by local name. */
+/** Collect `import {
+  foo as bar
+} from './...';` bindings keyed by local name. */
 const collectResolvableImports = (ast: AstNode): readonly ImportBinding[] => {
   const imports: ImportBinding[] = [];
   walk(ast, (node) => {
@@ -609,7 +735,7 @@ const getExportedDeclaration = (node: AstNode): AstNode | null => {
   if (node.type !== 'ExportNamedDeclaration') {
     return null;
   }
-  const decl = (node as unknown as { declaration?: AstNode }).declaration;
+  const decl = getNodeDeclaration(node);
   return decl ?? null;
 };
 
@@ -622,10 +748,8 @@ const addExportedVariableResultHelper = (
   const declarations =
     (decl['declarations'] as readonly AstNode[] | undefined) ?? [];
   for (const declarator of declarations) {
-    const { id, init } = declarator as unknown as {
-      id?: AstNode;
-      init?: AstNode;
-    };
+    const id = getNodeId(declarator);
+    const init = getNodeInit(declarator);
     const name = extractIdentifierName(id);
     if (
       name &&
@@ -644,7 +768,7 @@ const addExportedFunctionResultHelper = (
   collected: Set<string>,
   resultTypeNames: ReadonlySet<string>
 ): void => {
-  const name = extractIdentifierName((decl as unknown as { id?: AstNode }).id);
+  const name = extractIdentifierName(getNodeId(decl));
   if (name && hasResultReturnType(decl, source, resultTypeNames)) {
     collected.add(name);
   }
@@ -671,10 +795,8 @@ const indexVariableDeclarationInto = (
   const declarators =
     (decl['declarations'] as readonly AstNode[] | undefined) ?? [];
   for (const declarator of declarators) {
-    const { id, init } = declarator as unknown as {
-      id?: AstNode;
-      init?: AstNode;
-    };
+    const id = getNodeId(declarator);
+    const init = getNodeInit(declarator);
     const name = extractIdentifierName(id);
     if (name && init && isFunctionLikeExpression(init)) {
       index.set(name, init);
@@ -686,7 +808,7 @@ const indexFunctionDeclarationInto = (
   decl: AstNode,
   index: Map<string, AstNode>
 ): void => {
-  const name = extractIdentifierName((decl as unknown as { id?: AstNode }).id);
+  const name = extractIdentifierName(getNodeId(decl));
   if (name) {
     index.set(name, decl);
   }
@@ -719,8 +841,7 @@ const indexBodyNodeInto = (
 
 const indexLocalDeclarations = (ast: AstNode): DeclarationIndex => {
   const index = new Map<string, AstNode>();
-  const program = ast as unknown as { body?: readonly AstNode[] };
-  const bodyNodes = program.body ?? [];
+  const bodyNodes = getNodeBodyStatements(ast);
   for (const node of bodyNodes) {
     indexBodyNodeInto(node, index);
   }
@@ -749,10 +870,10 @@ const getSpecifierNameNode = (
     return null;
   }
   if (node.type === 'Identifier') {
-    return (node as unknown as { name?: string }).name ?? null;
+    return getNodeName(node) ?? null;
   }
   // Support string-literal specifiers (`export { "default" as X }`, etc).
-  const { value } = node as unknown as { value?: unknown };
+  const value = getNodeValue(node);
   return typeof value === 'string' ? value : null;
 };
 
@@ -775,11 +896,10 @@ const buildExportSpecifierInfo = (
 };
 
 const getExportDefaultDeclaration = (ast: AstNode): AstNode | null => {
-  const program = ast as unknown as { body?: readonly AstNode[] };
-  const bodyNodes = program.body ?? [];
+  const bodyNodes = getNodeBodyStatements(ast);
   for (const node of bodyNodes) {
     if (node.type === 'ExportDefaultDeclaration') {
-      const decl = (node as unknown as { declaration?: AstNode }).declaration;
+      const decl = getNodeDeclaration(node);
       return decl ?? null;
     }
   }
@@ -1082,8 +1202,7 @@ const processExportDefaultDeclaration = (
   collected: Set<string>,
   resultTypeNames: ReadonlySet<string>
 ): void => {
-  const defaultDecl = (node as unknown as { declaration?: AstNode })
-    .declaration;
+  const defaultDecl = getNodeDeclaration(node);
   if (!defaultDecl) {
     return;
   }
@@ -1115,8 +1234,7 @@ const collectExportedResultHelpersFromAst = (
     preloadedLocalDeclarations ?? indexLocalDeclarations(ast);
   const resultTypeNames =
     preloadedResultTypeNames ?? collectResultTypeNames(ast);
-  const program = ast as unknown as { body?: readonly AstNode[] };
-  const bodyNodes = program.body ?? [];
+  const bodyNodes = getNodeBodyStatements(ast);
 
   for (const node of bodyNodes) {
     if (node.type === 'ExportNamedDeclaration') {
@@ -1161,7 +1279,7 @@ const processExportAllDeclaration = (
   depth: number,
   collected: Set<string>
 ): void => {
-  const { exportKind } = node as unknown as { exportKind?: string };
+  const exportKind = getNodeExportKind(node);
   if (exportKind === 'type') {
     return;
   }
@@ -1309,7 +1427,7 @@ const getNamespaceLocalName = (spec: AstNode): string | null => {
   if (spec.type !== 'ImportNamespaceSpecifier') {
     return null;
   }
-  const { local } = spec as unknown as { local?: AstNode };
+  const local = getNodeLocal(spec);
   return extractIdentifierName(local);
 };
 
@@ -1417,7 +1535,7 @@ const checkImplementation = (
   resultTypeNames: ReadonlySet<string>,
   diagnostics: WardenDiagnostic[]
 ): void => {
-  const fnBody = (implValue as unknown as { body?: AstNode }).body;
+  const fnBody = getNodeBodyNode(implValue);
   if (!fnBody) {
     return;
   }
@@ -1443,10 +1561,24 @@ const checkImplementation = (
 
   const conciseScopes: readonly ReadonlySet<string>[] =
     implScope.size > 0 ? [implScope] : [];
-  if (
-    !isResultExpression(fnBody) &&
-    !isHelperCall(fnBody, helperNames, namespaceHelpers, conciseScopes)
-  ) {
+  const isConciseResultBody = (node: AstNode): boolean => {
+    const target = unwrapReturnExpression(node);
+    if (target.type === 'ConditionalExpression') {
+      const alternate = getNodeAlternate(target);
+      const consequent = getNodeConsequent(target);
+      return (
+        consequent !== undefined &&
+        alternate !== undefined &&
+        isConciseResultBody(consequent) &&
+        isConciseResultBody(alternate)
+      );
+    }
+    return (
+      isResultExpression(target) ||
+      isHelperCall(target, helperNames, namespaceHelpers, conciseScopes)
+    );
+  };
+  if (!isConciseResultBody(fnBody)) {
     diagnostics.push({
       filePath,
       line: offsetToLine(sourceCode, implValue.start),

package/src/rules/incomplete-crud.ts

@@ -4,6 +4,14 @@ import {
   collectNamedContourIds,
   collectNamedStoreTableIds,
   deriveStoreTableId,
+  getNodeArguments,
+  getNodeElements,
+  getNodeId,
+  getNodeImported,
+  getNodeInit,
+  getNodeLocal,
+  getNodeSource,
+  getNodeSpecifiers,
   getStringValue,
   identifierName,
   isNamedCall,
@@ -39,7 +47,7 @@ interface ImportAliasResolution {
 }
 
 const getImportSource = (node: AstNode): string | null => {
-  const sourceNode = (node as unknown as { source?: AstNode }).source;
+  const sourceNode = getNodeSource(node);
   return sourceNode && isStringLiteral(sourceNode)
     ? getStringValue(sourceNode)
     : null;
@@ -56,8 +64,8 @@ const extractImportAliasResolution = (
     return null;
   }
 
-  const { imported } = specifier as unknown as { imported?: AstNode };
-  const { local } = specifier as unknown as { local?: AstNode };
+  const imported = getNodeImported(specifier);
+  const local = getNodeLocal(specifier);
   const localName = identifierName(local);
   if (!localName) {
     return null;
@@ -85,8 +93,7 @@ const collectImportDeclarationAliases = (
     return;
   }
 
-  const specifiers = ((node as unknown as { specifiers?: readonly AstNode[] })
-    .specifiers ?? []) as readonly AstNode[];
+  const specifiers = getNodeSpecifiers(node) as readonly AstNode[];
   for (const specifier of specifiers) {
     const alias = extractImportAliasResolution(specifier, source);
     if (!alias) {
@@ -101,8 +108,7 @@ const extractInlineContourId = (node: AstNode | undefined): string | null => {
     return null;
   }
 
-  const [nameArg] = ((node as unknown as { arguments?: readonly AstNode[] })
-    .arguments ?? []) as readonly AstNode[];
+  const [nameArg] = getNodeArguments(node) as readonly AstNode[];
   return nameArg && isStringLiteral(nameArg) ? getStringValue(nameArg) : null;
 };
 
@@ -278,11 +284,7 @@ const extractDerivedCrudEntry = (
     return null;
   }
 
-  const [contourArg, operationArg] = ((
-    node as unknown as {
-      arguments?: readonly AstNode[];
-    }
-  ).arguments ?? []) as readonly AstNode[];
+  const [contourArg, operationArg] = getNodeArguments(node);
   const operation = extractCrudOperation(operationArg);
   const entityId = resolveContourId(contourArg, namedContourIds, importAliases);
   return operation && entityId ? { entityId, operation } : null;
@@ -334,18 +336,17 @@ const extractCrudTuplePattern = (
     return null;
   }
 
-  const { id, init } = node as unknown as {
-    readonly id?: AstNode;
-    readonly init?: AstNode;
-  };
+  const id = getNodeId(node);
+  const init = getNodeInit(node);
   if (!id || id.type !== 'ArrayPattern' || !isNamedCall(init, 'crud')) {
     return null;
   }
 
-  const [tableArg] = ((init as unknown as { arguments?: readonly AstNode[] })
-    .arguments ?? []) as readonly AstNode[];
+  const [tableArg] = getNodeArguments(init) as readonly AstNode[];
   const entityId = deriveStoreTableId(tableArg, namedStoreTableIds);
-  const { elements } = id as unknown as { elements?: readonly AstNode[] };
+  const elements = getNodeElements(id).filter(
+    (element): element is AstNode => element !== null
+  );
   return entityId && elements ? { elements, entityId } : null;
 };