cloudcruise 1.0.0 → 1.0.1

package/dist/workflows/WorkflowsClient.js

@@ -0,0 +1,97 @@
+import { InputValidationError } from './types.js';
+export class WorkflowsClient {
+    makeRequest;
+    constructor(makeRequest) {
+        this.makeRequest = makeRequest;
+    }
+    /**
+     * Retrieves all workflows of the workspace the API key is associated with
+     */
+    async getAllWorkflows() {
+        return await this.makeRequest('GET', '/workflows');
+    }
+    /**
+     * Retrieves the JSON schema of the input variables for a specific workflow
+     * @param workflowId - The ID of the workflow
+     */
+    async getWorkflowMetadata(workflowId) {
+        const path = `/workflows/${workflowId}/metadata`;
+        return await this.makeRequest('GET', path);
+    }
+    /**
+     * Validates a payload against a workflow's input schema.
+     * Throws InputValidationError if invalid; resolves if valid.
+     */
+    async validateWorkflowInput(workflowId, payload) {
+        const { input_schema } = await this.getWorkflowMetadata(workflowId);
+        const schema = input_schema ?? {};
+        const properties = schema.properties ?? {};
+        const required = schema.required ?? [];
+        const disallowExtras = schema.additionalProperties === false;
+        // Check only required keys for presence and type
+        const missingRequired = required.filter((key) => payload[key] === undefined);
+        const invalidTypes = [];
+        const detectType = (v) => {
+            if (v === null)
+                return 'null';
+            if (Array.isArray(v))
+                return 'array';
+            if (typeof v === 'number')
+                return Number.isInteger(v) ? 'integer' : 'number';
+            return typeof v;
+        };
+        const allowedTypes = new Set(['array', 'boolean', 'integer', 'number', 'object', 'string', 'null']);
+        const expectedTypesOf = (def) => {
+            if (!def)
+                return [];
+            // Normalize to array-of-strings from either string | string[] | { type: string | string[] }
+            const raw = (typeof def === 'object' && !Array.isArray(def)) ? def.type : def;
+            if (!raw)
+                return [];
+            const arr = Array.isArray(raw) ? raw : [raw];
+            return arr
+                .map((t) => String(t).toLowerCase())
+                .filter((t) => allowedTypes.has(t));
+        };
+        const matches = (expected, actual) => {
+            if (expected.length === 0)
+                return true; // unknown => don't enforce
+            if (expected.includes(actual))
+                return true;
+            if (actual === 'integer' && expected.includes('number'))
+                return true;
+            return false;
+        };
+        // Validate types for:
+        // - all required keys that are present
+        // - optional keys if they exist in the payload
+        for (const [key, schemaDef] of Object.entries(properties)) {
+            if (payload[key] === undefined)
+                continue; // optional and not provided
+            const expected = expectedTypesOf(schemaDef);
+            const actual = detectType(payload[key]);
+            if (!matches(expected, actual)) {
+                const exp = expected.length ? expected : ['any'];
+                invalidTypes.push({ field: key, expected_display: exp.join(' | '), actual });
+            }
+        }
+        // If additionalProperties is false, collect unknown keys present in payload
+        const unknownKeys = disallowExtras
+            ? Object.keys(payload).filter((k) => !(k in properties))
+            : [];
+        if (missingRequired.length || invalidTypes.length || unknownKeys.length) {
+            const parts = [];
+            if (missingRequired.length)
+                parts.push(`missing required: ${missingRequired.join(', ')}`);
+            if (invalidTypes.length) {
+                parts.push(invalidTypes
+                    .map((e) => `${e.field}: expected ${e.expected_display}, got ${e.actual}`)
+                    .join('; '));
+            }
+            if (unknownKeys.length)
+                parts.push(`unknown keys: ${unknownKeys.join(', ')}`);
+            const message = `Workflow input validation failed: ${parts.join(' | ')}`;
+            throw new InputValidationError(message, missingRequired, invalidTypes, unknownKeys);
+        }
+    }
+}

package/dist/workflows/types.d.ts

@@ -0,0 +1,41 @@
+/**
+ * CloudCruise Workflows API Type Definitions
+ */
+export interface Workflow {
+    id: string;
+    name: string;
+    description?: string | null;
+    created_at: string;
+    updated_at: string;
+    workspace_id: string;
+    created_by: string;
+    enable_popup_handling: boolean;
+    enable_xpath_recovery: boolean;
+    enable_error_code_generation: boolean;
+    enable_service_unavailable_recovery: boolean;
+    enable_action_timing_recovery: boolean;
+}
+export type WorkflowPropertySchema = string | string[] | {
+    type?: string | string[];
+    [key: string]: unknown;
+};
+export interface WorkflowInputSchema {
+    type?: 'object';
+    properties?: Record<string, WorkflowPropertySchema>;
+    required?: string[];
+    additionalProperties?: boolean;
+}
+export interface WorkflowMetadata {
+    input_schema: WorkflowInputSchema;
+}
+export interface InvalidTypeDetail {
+    field: string;
+    expected_display: string;
+    actual: string;
+}
+export declare class InputValidationError extends Error {
+    readonly missingRequired: string[];
+    readonly invalidTypes: InvalidTypeDetail[];
+    readonly unknownKeys: string[];
+    constructor(message?: string, missingRequired?: string[], invalidTypes?: InvalidTypeDetail[], unknownKeys?: string[]);
+}

package/dist/workflows/types.js

@@ -0,0 +1,15 @@
+/**
+ * CloudCruise Workflows API Type Definitions
+ */
+export class InputValidationError extends Error {
+    missingRequired;
+    invalidTypes;
+    unknownKeys;
+    constructor(message = 'Input validation failed', missingRequired = [], invalidTypes = [], unknownKeys = []) {
+        super(message);
+        this.name = 'InputValidationError';
+        this.missingRequired = missingRequired;
+        this.invalidTypes = invalidTypes;
+        this.unknownKeys = unknownKeys;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cloudcruise",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "The official CloudCruise JS/TS client.",
   "homepage": "https://github.com/CloudCruise/cloudcruise-js#readme",
   "bugs": {
@@ -21,6 +21,7 @@
   "scripts": {
     "build": "tsc",
     "dev": "tsc --watch",
+    "prepublishOnly": "npm run build",
     "test": "pnpm build && node --test test/*.test.js"
   },
   "devDependencies": {