@unito/integration-debugger/dist/src/services/crawler.d.ts

The Unito Integration Debugger

import { FieldSchema, RequestSchema, RelationSchema } from '@unito/integration-api';
import * as Validator from './validator';
export interface ProxyCallResponse {
    status: number;
    headers: Record<string, string>;
    payload: Record<string, unknown>;
}
export interface StepExecutionResult {
    step: Step;
    discoveredSteps: Step[];
}
export declare enum Operation {
    GetCollection = "getCollection",
    GetItem = "getItem",
    GetBlob = "getBlob",
    CreateItem = "createItem",
    UpdateItem = "updateItem",
    DeleteItem = "deleteItem",
    SubscribeWebhook = "subscribeWebhook",
    UnsubscribeWebhook = "unsubscribeWebhook",
    GetCredentialAccount = "getCredentialAccount"
}
export declare const ReadOperations: readonly Operation[];
export interface Step {
    path: string;
    requestSchema: RequestSchema | undefined;
    parentOperation: Operation | undefined;
    parentPath: string | undefined;
    schemaPath: string | undefined;
    operation: Operation;
    payloadIn?: unknown;
    payloadOut?: unknown;
    headersIn?: Record<string, string>;
    headersOut?: Record<string, string>;
    errors: Validator.ValidationDetail[];
    warnings: Validator.ValidationDetail[];
    context?: unknown;
}
export declare function buildStepUniqueId(stepOperation?: Operation, stepPath?: string): string;
export declare function buildSchemaUniqueId(stepPath?: string, relationName?: string, fieldName?: string): string;
export interface CrawlerOptions {
    proxyCall: (step: Step) => Promise<ProxyCallResponse>;
    timeout?: number;
}
export declare function create(crawlerOptions: CrawlerOptions): Promise<Instance>;
export declare class Instance {
    private proxyCall;
    private validator;
    private timeout;
    private nextSteps;
    private visitedRelationSchemas;
    private visitedFieldSchemas;
    constructor(crawlerOptions: CrawlerOptions, validator: Validator.Instance);
    next(): Promise<StepExecutionResult | undefined>;
    private discoverSteps;
    prepend(step: Step): void;
    append(step: Step): void;
    remove(step: Step): void;
    remaining(): ReadonlyArray<Readonly<Step>>;
    getRelationSchema(schemaPath: string): RelationSchema | undefined;
    getFieldSchemas(schemaPath: string): FieldSchema[] | undefined;
    execute(incomingStep: Step): Promise<Step>;
    private validateResponse;
    private validatePayload;
    private validateStatus;
    private getSchemaByOperation;
    private copyStep;
}