Mutations

mutation Call($input: ApiInputRequest!, $payload: JSON, $credentials: JSON, $options: RequestOptions) {
  call(input: $input, payload: $payload, credentials: $credentials, options: $options) {
    id
    success
    error
    startedAt
    completedAt
    data
    config {
      ... on ApiConfig {
        id
        urlHost
        urlPath
        method
        instruction
        authentication
        createdAt
        updatedAt
      }
      ... on ExtractConfig {
        id
        urlHost
        urlPath
        fileType
        decompressionMethod
        instruction
        authentication
        createdAt
        updatedAt
      }
      ... on TransformConfig {
        id
        instruction
        responseSchema
        responseMapping
        createdAt
        updatedAt
      }
      ... on Workflow {
        id
        version
        instruction
        createdAt
        updatedAt
      }
    }
  }
}

const result = await client.call({
  endpoint: {
    id: "a-unique-id",
    urlHost: "https://api.example.com",
    urlPath: "/data",
    instruction: "Fetch user data",
    method: "GET",
    headers: {
      "Authorization": "Bearer token"
    }
  },
  payload: {
    userId: "123"
  },
  options: {
    cacheMode: "ENABLED",
    selfHealing: "ENABLED",
    timeout: 5000
  }
});

mutation Extract($input: ExtractInputRequest!, $payload: JSON, $credentials: JSON, $options: RequestOptions) {
  extract(input: $input, payload: $payload, credentials: $credentials, options: $options) {
    id
    success
    error
    startedAt
    completedAt
    data
    config {
      ... on ExtractConfig {
        id
        urlHost
        urlPath
        fileType
        decompressionMethod
        instruction
        authentication
        createdAt
        updatedAt
      }
    }
  }
}

const result = await client.extract({
  endpoint: {
    id: "a-unique-id",
    urlHost: "https://example.com",
    urlPath: "/data.csv",
    instruction: "Extract user data from CSV",
    fileType: "CSV",
    decompressionMethod: "GZIP"
  },
  options: {
    selfHealing: "ENABLED",
    timeout: 10000
  }
});

mutation Transform($input: TransformInputRequest!, $data: JSON!, $options: RequestOptions) {
  transform(input: $input, data: $data, options: $options) {
    id
    success
    error
    startedAt
    completedAt
    data
    config {
      ... on TransformConfig {
        id
        instruction
        responseSchema
        responseMapping
        createdAt
        updatedAt
      }
    }
  }
}

const result = await client.transform({
  endpoint: {
    id: "a-unique-id",
    instruction: "Transform user data",
    responseSchema: {
      type: "object",
      properties: {
        name: { type: "string" },
        age: { type: "number" }
      }
    },
    responseMapping: "$.user"
  },
  data: {
    user: {
      name: "John",
      age: 30
    }
  }
});

mutation ExecuteWorkflow($input: WorkflowInputRequest!, $payload: JSON, $credentials: JSON, $options: RequestOptions) {
  executeWorkflow(input: $input, payload: $payload, credentials: $credentials, options: $options) {
    id
    success
    data
    error
    startedAt
    completedAt
    config {
      id
      version
      instruction
    }
    stepResults {
      stepId
      success
      rawData
      transformedData
      error
    }
  }
}

const result = await client.executeWorkflow({
  workflow: {
    id: "workflow-id",
    steps: [/* ... */],
    finalTransform: "...",
    responseSchema: {/* ... */}
  },
  payload: {/* ... */},
  options: {/* ... */}
});

mutation BuildWorkflow(
  $instruction: String!,
  $payload: JSON,
  $integrations: [IntegrationInputRequest!]!,
  $responseSchema: JSONSchema
) {
  buildWorkflow(
    instruction: $instruction,
    payload: $payload,
    integrations: $integrations,
    responseSchema: $responseSchema
  ) {
    id
    version
    instruction
    steps {
      id
      apiConfig {
        id
        urlHost
        urlPath
        method
        instruction
      }
      integrationId
      executionMode
      inputMapping
      responseMapping
    }
    finalTransform
    responseSchema
    inputSchema
  }
}

const workflow = await client.buildWorkflow({
  instruction: "Get user profile and their recent posts",
  payload: { userId: "123" },
  integrations: [
    { id: "user-api" },
    { id: "posts-api" }
  ],
  responseSchema: {
    type: "object",
    properties: {
      user: { type: "object" },
      posts: { type: "array" }
    }
  }
});

mutation SetTenantInfo($email: String, $emailEntrySkipped: Boolean) {
  setTenantInfo(email: $email, emailEntrySkipped: $emailEntrySkipped) {
    email
    emailEntrySkipped
  }
}

const tenantInfo = await client.setTenantInfo({
  email: "user@example.com",
  emailEntrySkipped: false
});

mutation UpsertApi($id: ID!, $input: JSON!) {
  upsertApi(id: $id, input: $input) {
    id
    urlHost
    urlPath
    method
    instruction
    headers
    queryParams
    body
    authentication
    responseSchema
    responseMapping
    pagination {
      type
      pageSize
      cursorPath
    }
    dataPath
    updatedAt
  }
}

const config = await client.upsertApi("config-id", {
  urlHost: "https://api.example.com",
  urlPath: "/users",
  method: "GET",
  headers: {
    "Authorization": "Bearer token"
  }
});

mutation UpdateApiConfigId($oldId: ID!, $newId: ID!) {
  updateApiConfigId(oldId: $oldId, newId: $newId) {
    id
    urlHost
    urlPath
    method
    instruction
  }
}

const updatedConfig = await client.updateApiConfigId("old-id", "new-id");

mutation DeleteApi($id: ID!) {
  deleteApi(id: $id)
}

const success = await client.deleteApi("config-id");

mutation UpsertExtraction($id: ID!, $input: JSON!) {
  upsertExtraction(id: $id, input: $input) {
    id
    urlHost
    urlPath
    instruction
    fileType
    decompressionMethod
  }
}

const config = await client.upsertExtraction("extraction-config-id", {
  urlHost: "https://example.com",
  fileType: "CSV",
  instruction: "Extract data from CSV file."
});

mutation DeleteExtraction($id: ID!) {
  deleteExtraction(id: $id)
}

const success = await client.deleteExtraction("extraction-config-id");

mutation UpsertTransformation($id: ID!, $input: JSON!) {
  upsertTransformation(id: $id, input: $input) {
    id
    instruction
    responseSchema
    responseMapping
  }
}

const config = await client.upsertTransformation("transform-config-id", {
  instruction: "Transform user data to new schema",
  responseSchema: { type: "object", properties: { /* ... */ } },
  responseMapping: "$.users"
});

mutation DeleteTransformation($id: ID!) {
  deleteTransformation(id: $id)
}

const success = await client.deleteTransformation("transform-config-id");

mutation UpsertWorkflow($id: ID!, $input: JSON!) {
  upsertWorkflow(id: $id, input: $input) {
    id
    version
    instruction
    steps {
      id
      apiConfig {
        id
        urlHost
        urlPath
        method
        instruction
      }
      integrationId
      executionMode
      inputMapping
      responseMapping
    }
    finalTransform
    responseSchema
    inputSchema
  }
}

const workflow = await client.upsertWorkflow("workflow-id", {
  steps: [
    // ...ExecutionStepInput objects
  ],
  finalTransform: "$.step1.data + $.step2.data"
});

mutation DeleteWorkflow($id: ID!) {
  deleteWorkflow(id: $id)
}

const success = await client.deleteWorkflow("workflow-id");

mutation UpsertIntegration($input: IntegrationInput!, $mode: UpsertMode = UPSERT) {
  upsertIntegration(input: $input, mode: $mode) {
    id
    name
    type
    urlHost
    urlPath
    credentials
    documentationUrl
    documentation
    documentationPending
    icon
    version
    createdAt
    updatedAt
  }
}

const integration = await client.upsertIntegration({
  id: "github-api",
  name: "GitHub API",
  urlHost: "https://api.github.com",
  credentials: {
    token: "ghp_..."
  },
  documentationUrl: "https://docs.github.com/en/rest"
}, "UPSERT");

mutation DeleteIntegration($id: ID!) {
  deleteIntegration(id: $id)
}

const success = await client.deleteIntegration("integration-id");