@toloka-platform/sdk 0.1.0-preview.6 → 0.1.0-preview.7

package/src/checks/postprocess-collisions.ts

@@ -0,0 +1,145 @@
+import type { BlockStatement, Expression, JSXAttribute, ObjectExpression } from "oxc-parser";
+import { Visitor } from "oxc-parser";
+
+import { parseProgram, resolveAttributeString } from "./ast";
+import type { TaskUiDiagnostic, TaskUiSource } from "./task-ui-typecheck";
+
+// Collisions in conditional return branches are errors too: a submission whose data reaches the
+// branch still dies at getData().
+export const findPostprocessKeyCollisions = (
+  ui: Pick<TaskUiSource, "code" | "postprocess">,
+): TaskUiDiagnostic[] => {
+  const returnedKeys = extractPostprocessReturnedKeys(ui.postprocess);
+  if (!returnedKeys || returnedKeys.size === 0) return [];
+  const bindings = extractFieldPathBindings(ui.code);
+  if (!bindings || bindings.size === 0) return [];
+
+  return [...bindings]
+    .filter(([key]) => returnedKeys.has(key))
+    .sort(([keyA], [keyB]) => keyA.localeCompare(keyB))
+    .map(([key, path]) => {
+      const binding =
+        path === key
+          ? `path="${path}"`
+          : `path="${path}" — a dotted path binds its top-level key "${key}"`;
+      return {
+        severity: "error",
+        text:
+          `Postprocess returns the key "${key}", but a Field component is bound to it (${binding}). ` +
+          `Every submission of this interface fails at runtime with: Postprocess cannot write key '${key}' because a component is bound to it. ` +
+          `Fix: bind the Field to a raw key (e.g. path="raw_${key}") and derive "${key}" in postprocess, or remove "${key}" from the postprocess return.`,
+      };
+    });
+};
+
+const extractFieldPathBindings = (code: string): Map<string, string> | null => {
+  const program = parseProgram("code.tsx", `(\n${code}\n)`, "tsx");
+  if (!program) return null;
+  const bindings = new Map<string, string>();
+  const visitor = new Visitor({
+    JSXOpeningElement(node) {
+      let name = node.name;
+      while (name.type === "JSXMemberExpression") name = name.object;
+      if (name.type !== "JSXIdentifier" || name.name !== "Field") return;
+      const pathAttribute = node.attributes.find(
+        (attribute): attribute is JSXAttribute =>
+          attribute.type === "JSXAttribute" &&
+          attribute.name.type === "JSXIdentifier" &&
+          attribute.name.name === "path",
+      );
+      const path = resolveAttributeString(pathAttribute);
+      if (!path) return;
+      const key = path.split(/[.[]/u)[0];
+      if (key && !bindings.has(key)) bindings.set(key, path);
+    },
+  });
+  visitor.visit(program);
+  return bindings;
+};
+
+const extractPostprocessReturnedKeys = (postprocess: string): Set<string> | null => {
+  const program = parseProgram("postprocess.ts", `(() => {\n${postprocess}\n})`, "ts");
+  if (!program) return null;
+  const statement = program.body.length === 1 ? program.body[0] : undefined;
+  // postprocess text can escape the wrapper braces yet still parse — `}) , (() => {` turns the
+  // expression into a SequenceExpression — so only the intact wrapper shape is analyzable
+  if (
+    statement?.type !== "ExpressionStatement" ||
+    statement.expression.type !== "ArrowFunctionExpression" ||
+    statement.expression.body.type !== "BlockStatement"
+  ) {
+    return null;
+  }
+  const keys = new Set<string>();
+  for (const returned of collectOwnReturnArguments(statement.expression.body)) {
+    collectObjectLiteralKeys(returned, keys);
+  }
+  return keys;
+};
+
+const functionNodeTypes = new Set([
+  "ArrowFunctionExpression",
+  "FunctionExpression",
+  "FunctionDeclaration",
+]);
+
+const collectOwnReturnArguments = (body: BlockStatement): Expression[] => {
+  const returned: Expression[] = [];
+  const visit = (node: unknown): void => {
+    if (!node || typeof node !== "object") return;
+    if (Array.isArray(node)) {
+      for (const item of node) visit(item);
+      return;
+    }
+    const candidate = node as { type?: unknown } & Record<string, unknown>;
+    if (typeof candidate.type === "string") {
+      if (functionNodeTypes.has(candidate.type)) return;
+      if (candidate.type === "ReturnStatement" && candidate.argument) {
+        returned.push(candidate.argument as Expression);
+      }
+    }
+    for (const value of Object.values(candidate)) visit(value);
+  };
+  visit(body.body);
+  return returned;
+};
+
+const collectObjectLiteralKeys = (expression: Expression, keys: Set<string>): void => {
+  if (expression.type === "ObjectExpression") {
+    collectPropertyKeys(expression, keys);
+  } else if (expression.type === "ConditionalExpression") {
+    collectObjectLiteralKeys(expression.consequent, keys);
+    collectObjectLiteralKeys(expression.alternate, keys);
+  } else if (expression.type === "LogicalExpression") {
+    collectObjectLiteralKeys(expression.left, keys);
+    collectObjectLiteralKeys(expression.right, keys);
+  } else if (expression.type === "SequenceExpression") {
+    const last = expression.expressions.at(-1);
+    if (last) collectObjectLiteralKeys(last, keys);
+  } else if (
+    expression.type === "TSAsExpression" ||
+    expression.type === "TSSatisfiesExpression" ||
+    expression.type === "TSNonNullExpression" ||
+    expression.type === "TSTypeAssertion"
+  ) {
+    collectObjectLiteralKeys(expression.expression, keys);
+  }
+};
+
+const collectPropertyKeys = (objectExpression: ObjectExpression, keys: Set<string>): void => {
+  for (const property of objectExpression.properties) {
+    if (property.type === "SpreadElement") {
+      if (property.argument.type === "ObjectExpression")
+        collectPropertyKeys(property.argument, keys);
+      continue;
+    }
+    if (!property.computed && property.key.type === "Identifier") {
+      keys.add(property.key.name);
+    } else if (
+      property.key.type === "Literal" &&
+      (typeof property.key.value === "string" || typeof property.key.value === "number")
+    ) {
+      keys.add(String(property.key.value));
+    }
+  }
+};