@kognitivedev/cloud-platforms 0.2.29

package/src/validation.ts

@@ -0,0 +1,221 @@
+import type {
+    ConnectLinkResult,
+    PlatformAction,
+    PlatformActionResult,
+    PlatformCatalog,
+    PlatformConnection,
+    PlatformToolkit,
+    PlatformToolConnection,
+    PlatformToolDefinition,
+} from "./types";
+
+export class CloudPlatformsValidationError extends Error {
+    readonly path: string;
+    readonly expected: string;
+    readonly actual: unknown;
+
+    constructor(path: string, expected: string, actual: unknown) {
+        super(`${path} must be ${expected}`);
+        this.name = "CloudPlatformsValidationError";
+        this.path = path;
+        this.expected = expected;
+        this.actual = actual;
+    }
+}
+
+type PlainObject = Record<string, unknown>;
+
+export function isPlainObject(value: unknown): value is PlainObject {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return false;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}
+
+export function cloneUnknown<T>(value: T): T {
+    if (Array.isArray(value)) {
+        return value.map((entry) => cloneUnknown(entry)) as T;
+    }
+    if (isPlainObject(value)) {
+        const cloned: Record<string, unknown> = {};
+        for (const [key, entry] of Object.entries(value)) {
+            cloned[key] = cloneUnknown(entry);
+        }
+        return cloned as T;
+    }
+    return value;
+}
+
+function invalid(path: string, expected: string, actual: unknown): never {
+    throw new CloudPlatformsValidationError(path, expected, actual);
+}
+
+function expectObject(value: unknown, path: string): PlainObject {
+    if (!isPlainObject(value)) {
+        invalid(path, "an object", value);
+    }
+    return value;
+}
+
+function expectArray(value: unknown, path: string): unknown[] {
+    if (!Array.isArray(value)) {
+        invalid(path, "an array", value);
+    }
+    return value;
+}
+
+function expectString(value: unknown, path: string): string {
+    if (typeof value !== "string") {
+        invalid(path, "a string", value);
+    }
+    return value;
+}
+
+function expectBoolean(value: unknown, path: string): boolean {
+    if (typeof value !== "boolean") {
+        invalid(path, "a boolean", value);
+    }
+    return value;
+}
+
+function expectNullableString(value: unknown, path: string): string | null {
+    if (value === null) {
+        return null;
+    }
+    return expectString(value, path);
+}
+
+function expectRecord(value: unknown, path: string): Record<string, unknown> {
+    return cloneUnknown(expectObject(value, path));
+}
+
+function expectStringArray(value: unknown, path: string): string[] {
+    return expectArray(value, path).map((entry, index) => expectString(entry, `${path}[${index}]`));
+}
+
+function optionalStringArray(value: unknown, path: string): string[] | undefined {
+    if (value === undefined) {
+        return undefined;
+    }
+    return expectStringArray(value, path);
+}
+
+export function decodeToolkit(value: unknown, path: string): PlatformToolkit {
+    const object = expectObject(value, path);
+    return {
+        id: expectString(object.id, `${path}.id`),
+        slug: expectString(object.slug, `${path}.slug`),
+        name: expectString(object.name, `${path}.name`),
+        description: expectNullableString(object.description, `${path}.description`),
+        iconUrl: expectNullableString(object.iconUrl, `${path}.iconUrl`),
+        categories: expectStringArray(object.categories, `${path}.categories`),
+        managedAuthSchemes: expectStringArray(object.managedAuthSchemes, `${path}.managedAuthSchemes`),
+    };
+}
+
+export function decodeAction(value: unknown, path: string): PlatformAction {
+    const object = expectObject(value, path);
+    return {
+        id: expectString(object.id, `${path}.id`),
+        slug: expectString(object.slug, `${path}.slug`),
+        toolkitSlug: expectString(object.toolkitSlug, `${path}.toolkitSlug`),
+        name: expectString(object.name, `${path}.name`),
+        description: expectNullableString(object.description, `${path}.description`),
+        version: expectNullableString(object.version, `${path}.version`),
+        inputSchema: expectRecord(object.inputSchema, `${path}.inputSchema`),
+        outputSchema: expectRecord(object.outputSchema, `${path}.outputSchema`),
+        tags: expectStringArray(object.tags, `${path}.tags`),
+        isDangerous: expectBoolean(object.isDangerous, `${path}.isDangerous`),
+        requireApproval: expectBoolean(object.requireApproval, `${path}.requireApproval`),
+    };
+}
+
+export function decodeConnection(value: unknown, path: string): PlatformConnection {
+    const object = expectObject(value, path);
+    return {
+        id: expectString(object.id, `${path}.id`),
+        toolkitSlug: expectString(object.toolkitSlug, `${path}.toolkitSlug`),
+        alias: expectNullableString(object.alias, `${path}.alias`),
+        displayName: expectNullableString(object.displayName, `${path}.displayName`),
+        status: expectString(object.status, `${path}.status`),
+        externalAccountLabel: expectNullableString(object.externalAccountLabel, `${path}.externalAccountLabel`),
+        metadata: expectRecord(object.metadata, `${path}.metadata`),
+        createdAt: expectString(object.createdAt, `${path}.createdAt`),
+        updatedAt: expectString(object.updatedAt, `${path}.updatedAt`),
+        lastSyncedAt: expectString(object.lastSyncedAt, `${path}.lastSyncedAt`),
+        lastVerifiedAt: expectNullableString(object.lastVerifiedAt, `${path}.lastVerifiedAt`),
+    };
+}
+
+export function decodeCatalog(value: unknown, path = "catalog"): PlatformCatalog {
+    const object = expectObject(value, path);
+    return {
+        toolkits: expectArray(object.toolkits, `${path}.toolkits`).map((entry, index) => decodeToolkit(entry, `${path}.toolkits[${index}]`)),
+        actions: expectArray(object.actions, `${path}.actions`).map((entry, index) => decodeAction(entry, `${path}.actions[${index}]`)),
+        lastSyncedAt: expectNullableString(object.lastSyncedAt, `${path}.lastSyncedAt`),
+    };
+}
+
+export function decodeConnectionsEnvelope(value: unknown): PlatformConnection[] {
+    const object = expectObject(value, "response");
+    return expectArray(object.connections, "response.connections").map((entry, index) => decodeConnection(entry, `response.connections[${index}]`));
+}
+
+export function decodeActionsEnvelope(value: unknown): PlatformAction[] {
+    const object = expectObject(value, "response");
+    return expectArray(object.actions, "response.actions").map((entry, index) => decodeAction(entry, `response.actions[${index}]`));
+}
+
+export function decodeToolConnection(value: unknown, path: string): PlatformToolConnection {
+    const object = expectObject(value, path);
+    return {
+        id: expectString(object.id, `${path}.id`),
+        label: expectString(object.label, `${path}.label`),
+        toolkitSlug: expectString(object.toolkitSlug, `${path}.toolkitSlug`),
+    };
+}
+
+export function decodeToolDefinition(value: unknown, path: string): PlatformToolDefinition {
+    const object = expectObject(value, path);
+    return {
+        id: expectString(object.id, `${path}.id`),
+        actionSlug: expectString(object.actionSlug, `${path}.actionSlug`),
+        toolkitSlug: expectString(object.toolkitSlug, `${path}.toolkitSlug`),
+        name: expectString(object.name, `${path}.name`),
+        description: expectString(object.description, `${path}.description`),
+        inputSchema: expectRecord(object.inputSchema, `${path}.inputSchema`),
+        outputSchema: expectRecord(object.outputSchema, `${path}.outputSchema`),
+        requireApproval: expectBoolean(object.requireApproval, `${path}.requireApproval`),
+        connections: expectArray(object.connections, `${path}.connections`).map((entry, index) => decodeToolConnection(entry, `${path}.connections[${index}]`)),
+    };
+}
+
+export function decodeToolsEnvelope(value: unknown): PlatformToolDefinition[] {
+    const object = expectObject(value, "response");
+    return expectArray(object.tools, "response.tools").map((entry, index) => decodeToolDefinition(entry, `response.tools[${index}]`));
+}
+
+export function decodeConnectLink(value: unknown): ConnectLinkResult {
+    const object = expectObject(value, "response");
+    return {
+        toolkitSlug: expectString(object.toolkitSlug, "response.toolkitSlug"),
+        connectionRequestId: expectString(object.connectionRequestId, "response.connectionRequestId"),
+        redirectUrl: expectString(object.redirectUrl, "response.redirectUrl"),
+    };
+}
+
+export function decodeActionResult(value: unknown): PlatformActionResult {
+    const object = expectObject(value, "response");
+    return {
+        actionSlug: expectString(object.actionSlug, "response.actionSlug"),
+        toolkitSlug: expectString(object.toolkitSlug, "response.toolkitSlug"),
+        connectionId: expectString(object.connectionId, "response.connectionId"),
+        version: expectNullableString(object.version, "response.version"),
+        result: cloneUnknown(object.result),
+    };
+}
+
+export function validateOptionalStringArray(value: unknown, path: string): string[] | undefined {
+    return optionalStringArray(value, path);
+}

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "module": "commonjs",
+    "rootDir": "src",
+    "outDir": "dist",
+    "declaration": true,
+    "noEmit": false,
+    "incremental": false
+  },
+  "include": [
+    "src"
+  ],
+  "exclude": [
+    "src/__tests__"
+  ]
+}

package/vitest.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+    test: {
+        environment: "node",
+        globals: true,
+    },
+});