@toloka-platform/sdk 0.1.0-preview.9 → 0.1.0

package/src/cli/project.ts

@@ -4,6 +4,7 @@ import { dirname, join, resolve } from "node:path";
 import type {
   PipelineGraphSnapshot,
   PipelineGraphV1,
+  PipelineValidationIssue,
   PipelineValidationReport,
 } from "../../openapi/gen/models";
 import { resolvePipelineDefinition, validatePipelineDefinition } from "../authoring";
@@ -83,10 +84,13 @@ export type ApplyProjectResult = {
 
 export type ValidateProjectOptions = PlanProjectOptions;
 
+export type PipelineValidationStatus = "valid" | "invalid" | "checks_pending";
+
 export type PipelineValidationResult = {
   readonly sourceDirectory: string;
   readonly pipelineId?: string;
   readonly report?: PipelineValidationReport;
+  readonly status?: PipelineValidationStatus;
   readonly skipped?: string;
 };
 
@@ -860,10 +864,47 @@ export async function applyProject(
 const issueLocation = (issue: { nodeId?: string; checkId?: string }) =>
   [issue.nodeId, issue.checkId].filter((value): value is string => value !== undefined).join("/");
 
+const PENDING_CHECK_CODE = "not_ran_node_check";
+
+const normalizeValidationIssue = (issue: PipelineValidationIssue): PipelineValidationIssue =>
+  issue.code === "empty_node_checks"
+    ? { ...issue, message: "No stored check cases are configured for this node" }
+    : issue;
+
+const normalizeValidationReport = (
+  report: PipelineValidationReport,
+): { readonly report: PipelineValidationReport; readonly status: PipelineValidationStatus } => {
+  const seen = new Set<string>();
+  const issues = report.issues.flatMap((rawIssue) => {
+    const issue = normalizeValidationIssue(rawIssue);
+    const key = [
+      issue.code,
+      issue.severity,
+      issue.nodeId ?? "",
+      issue.checkId ?? "",
+      issue.message,
+    ].join("\n");
+    if (seen.has(key)) return [];
+    seen.add(key);
+    return [issue];
+  });
+  const pending = issues.some((issue) => issue.code === PENDING_CHECK_CODE);
+  const blocking = issues.some(
+    (issue) => issue.severity === "error" && issue.code !== PENDING_CHECK_CODE,
+  );
+  const status: PipelineValidationStatus =
+    blocking || (!report.valid && !pending) ? "invalid" : pending ? "checks_pending" : "valid";
+  return {
+    status,
+    report: { ...report, valid: status !== "invalid", issues },
+  };
+};
+
 const formatValidationIssues = (report: PipelineValidationReport) =>
   report.issues.map((issue) => {
     const location = issueLocation(issue);
-    return `  ${issue.severity} ${issue.code}${location.length === 0 ? "" : ` ${location}`}: ${issue.message}`;
+    const severity = issue.code === PENDING_CHECK_CODE ? "pending" : issue.severity;
+    return `  ${severity} ${issue.code}${location.length === 0 ? "" : ` ${location}`}: ${issue.message}`;
   });
 
 export async function validateProject(
@@ -898,24 +939,26 @@ export async function validateProject(
             resolvePipelineDefinition(pipeline.source.definition, { datasetId: dataset.id }),
             pipeline.snapshot.graph,
           );
-    const report = await client.pipelines.validateGraph({
-      pipelineId: pipeline.pipeline.id,
-      graph,
-    });
+    const normalized = normalizeValidationReport(
+      await client.pipelines.validateGraph({
+        pipelineId: pipeline.pipeline.id,
+        graph,
+      }),
+    );
     results.push({
       sourceDirectory: pipeline.source.sourceDirectory,
       pipelineId: pipeline.pipeline.id,
-      report,
+      report: normalized.report,
+      status: normalized.status,
     });
   }
-  const valid = results.every((result) => result.report?.valid !== false);
+  const valid = results.every((result) => result.status !== "invalid");
   const lines = results.flatMap((result) => {
     if (result.skipped !== undefined)
       return [`- ${result.sourceDirectory}: skipped (${result.skipped})`];
     assert(result.report, `Pipeline ${result.sourceDirectory} is missing a validation report`);
-    const header = result.report.valid
-      ? `- ${result.sourceDirectory}: valid`
-      : `- ${result.sourceDirectory}: invalid`;
+    assert(result.status, `Pipeline ${result.sourceDirectory} is missing a validation status`);
+    const header = `- ${result.sourceDirectory}: ${result.status.replace("_", "-")}`;
     return [header, ...formatValidationIssues(result.report)];
   });
   return {

package/src/cli/version.ts

@@ -0,0 +1,68 @@
+import { realpathSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join, resolve, sep } from "node:path";
+
+import { assert } from "es-toolkit";
+import { SDK_VERSION } from "./init";
+
+export type CliInstallChannel = "global-registry" | "linked" | "project-local";
+
+type VersionInfoOptions = {
+  readonly globalBinDirectory?: string;
+  readonly globalPackageDirectory?: string;
+};
+
+const GLOBAL_PACKAGE_MARKER = `${sep}install${sep}global${sep}`;
+
+const realpathOrSelf = (path: string): string => {
+  try {
+    return realpathSync(path);
+  } catch {
+    return path;
+  }
+};
+
+const classifyInstallChannel = (
+  entryPath: string,
+  packageRoot: string,
+  globalBinDirectory: string,
+  globalPackageDirectory: string,
+): CliInstallChannel => {
+  const resolvedEntryPath = realpathOrSelf(entryPath);
+  if (resolvedEntryPath.includes(GLOBAL_PACKAGE_MARKER)) return "global-registry";
+  if (realpathOrSelf(globalPackageDirectory) === packageRoot) return "linked";
+  if (dirname(resolve(entryPath)) === resolve(globalBinDirectory)) return "linked";
+  return "project-local";
+};
+
+export const cliVersionInfo = (entryPath = process.argv[1], options: VersionInfoOptions = {}) => {
+  assert(entryPath, "CLI entry path is unavailable");
+  const globalBinDirectory =
+    options.globalBinDirectory ??
+    resolve(process.env.BUN_INSTALL ?? join(homedir(), ".bun"), "bin");
+  const globalPackageDirectory =
+    options.globalPackageDirectory ??
+    resolve(
+      globalBinDirectory,
+      "..",
+      "install",
+      "global",
+      "node_modules",
+      "@toloka-platform",
+      "sdk",
+    );
+  const packageRoot = resolve(dirname(realpathOrSelf(entryPath)), "..");
+  const channel = classifyInstallChannel(
+    entryPath,
+    packageRoot,
+    globalBinDirectory,
+    globalPackageDirectory,
+  );
+
+  return {
+    version: SDK_VERSION,
+    commit: process.env.TOLOKA_BUILD_COMMIT ?? null,
+    channel,
+    ...(channel === "linked" ? { path: packageRoot } : {}),
+  };
+};

package/src/index.ts

@@ -69,6 +69,7 @@ export {
   connect,
   definePipeline,
   field,
+  optional,
   generation,
   isPipelineDefinition,
   match,
@@ -91,6 +92,7 @@ export type {
   InputPort,
   MatchAuthoringSettings,
   OutputPort,
+  OptionalFieldBinding,
   PipelineDefinition,
   PipelineDefinitionBindings,
   PipelineDefinitionInput,