@independo/inderun-contracts 0.1.0

package/dist/validators.js

@@ -0,0 +1,158 @@
+import Ajv2020 from "ajv/dist/2020.js";
+import { httpRequestSchema, httpResponseSchema, inderunErrorSchema, routePlanSchema, routePlannerInputSchema, taskRequestSchema, taskResultSchema, telemetryEventSchema } from "./generated/index.js";
+const Ajv2020Constructor = Ajv2020;
+const ajv = new Ajv2020Constructor({
+    allErrors: true,
+    strict: true,
+    strictRequired: false,
+    validateSchema: true
+});
+const validateTaskRequestSchema = ajv.compile(taskRequestSchema);
+const validateTaskResultSchema = ajv.compile(taskResultSchema);
+const validateIndeRunErrorSchema = ajv.compile(inderunErrorSchema);
+const validateHttpRequestSchema = ajv.compile(httpRequestSchema);
+const validateHttpResponseSchema = ajv.compile(httpResponseSchema);
+const validateTelemetryEventSchema = ajv.compile(telemetryEventSchema);
+const validateRoutePlannerInputSchema = ajv.compile(routePlannerInputSchema);
+const validateRoutePlanSchema = ajv.compile(routePlanSchema);
+export function validateTaskRequest(value) {
+    return getTaskRequestValidationIssues(value).length === 0;
+}
+export function validateTaskResult(value) {
+    return getTaskResultValidationIssues(value).length === 0;
+}
+export function validateIndeRunError(value) {
+    return getIndeRunErrorValidationIssues(value).length === 0;
+}
+export function validateHttpRequest(value) {
+    return getHttpRequestValidationIssues(value).length === 0;
+}
+export function validateHttpResponse(value) {
+    return getHttpResponseValidationIssues(value).length === 0;
+}
+export function validateTelemetryEvent(value) {
+    return getTelemetryEventValidationIssues(value).length === 0;
+}
+export function validateRoutePlannerInput(value) {
+    return getRoutePlannerInputValidationIssues(value).length === 0;
+}
+export function validateRoutePlan(value) {
+    return getRoutePlanValidationIssues(value).length === 0;
+}
+export function getTaskRequestValidationIssues(value) {
+    const issues = getValidationIssues(validateTaskRequestSchema, value, {
+        forbidInlineSecrets: true
+    });
+    issues.push(...findRoutingConstraintIssues(value));
+    return issues;
+}
+export function getTaskResultValidationIssues(value) {
+    return getValidationIssues(validateTaskResultSchema, value, {
+        forbidInlineSecrets: true
+    });
+}
+export function getIndeRunErrorValidationIssues(value) {
+    return getValidationIssues(validateIndeRunErrorSchema, value, {
+        forbidInlineSecrets: true
+    });
+}
+export function getHttpRequestValidationIssues(value) {
+    return getValidationIssues(validateHttpRequestSchema, value);
+}
+export function getHttpResponseValidationIssues(value) {
+    return getValidationIssues(validateHttpResponseSchema, value);
+}
+export function getTelemetryEventValidationIssues(value) {
+    return getValidationIssues(validateTelemetryEventSchema, value, {
+        forbidInlineSecrets: true
+    });
+}
+export function getRoutePlannerInputValidationIssues(value) {
+    return getValidationIssues(validateRoutePlannerInputSchema, value);
+}
+export function getRoutePlanValidationIssues(value) {
+    return getValidationIssues(validateRoutePlanSchema, value);
+}
+function getValidationIssues(validateSchema, value, options = {}) {
+    const issues = [];
+    if (!validateSchema(value)) {
+        issues.push(...formatAjvIssues(validateSchema.errors ?? []));
+    }
+    if (options.forbidInlineSecrets) {
+        issues.push(...findInlineSecretKeys(value));
+    }
+    return issues;
+}
+function formatAjvIssues(errors) {
+    return errors.map((error) => ({
+        path: error.instancePath || "/",
+        message: error.message ?? "Invalid value",
+        keyword: error.keyword
+    }));
+}
+function findInlineSecretKeys(value, path = "") {
+    if (Array.isArray(value)) {
+        return value.flatMap((item, index) => findInlineSecretKeys(item, `${path}/${index}`));
+    }
+    if (!value || typeof value !== "object") {
+        return [];
+    }
+    const issues = [];
+    for (const [key, child] of Object.entries(value)) {
+        const childPath = `${path}/${escapeJsonPointerSegment(key)}`;
+        if (isForbiddenSecretKey(key)) {
+            issues.push({
+                path: childPath,
+                message: "Inline secrets are not allowed; use authContextRef instead.",
+                keyword: "forbiddenSecretKey"
+            });
+        }
+        issues.push(...findInlineSecretKeys(child, childPath));
+    }
+    return issues;
+}
+function findRoutingConstraintIssues(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return [];
+    }
+    const request = value;
+    const constraints = request.constraints;
+    if (!constraints) {
+        return [];
+    }
+    const issues = [];
+    if (constraints.privacy === "local_required" && constraints.cloud === "required") {
+        issues.push({
+            path: "/constraints",
+            message: "privacy=local_required conflicts with cloud=required.",
+            keyword: "routingConstraintConflict"
+        });
+    }
+    if (constraints.privacy === "cloud_required" && constraints.cloud === "forbidden") {
+        issues.push({
+            path: "/constraints",
+            message: "privacy=cloud_required conflicts with cloud=forbidden.",
+            keyword: "routingConstraintConflict"
+        });
+    }
+    return issues;
+}
+function normalizeKey(key) {
+    return key.replace(/[^a-z0-9]/gi, "").toLowerCase();
+}
+function isForbiddenSecretKey(key) {
+    const normalizedKey = normalizeKey(key);
+    if (normalizedKey.includes("authorization") ||
+        normalizedKey.includes("password") ||
+        normalizedKey.includes("secret") ||
+        normalizedKey.includes("apikey")) {
+        return true;
+    }
+    if (normalizedKey.includes("api") && normalizedKey.includes("key")) {
+        return true;
+    }
+    return normalizedKey === "token" || normalizedKey.endsWith("token");
+}
+function escapeJsonPointerSegment(segment) {
+    return segment.replaceAll("~", "~0").replaceAll("/", "~1");
+}

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@independo/inderun-contracts",
+  "version": "0.1.0",
+  "description": "Canonical JSON Schemas, generated TypeScript types, and validators for IndeRun contracts.",
+  "license": "MIT",
+  "engines": {
+    "node": ">=24"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "dependencies": {
+    "ajv": "^8.20.0"
+  },
+  "devDependencies": {
+    "@types/node": "^24.13.2",
+    "vitest": "^3.2.6"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "vitest run"
+  }
+}