curl --request DELETE \
  --url 'https://api.usedatabrain.com/api/v2/datasource?datasourceName=production-postgres' \
  --header 'Authorization: Bearer dbn_live_abc123...'

const datasourceName = 'production-postgres';
const response = await fetch(
  `https://api.usedatabrain.com/api/v2/datasource?datasourceName=${encodeURIComponent(datasourceName)}`,
  {
    method: 'DELETE',
    headers: {
      'Authorization': 'Bearer dbn_live_abc123...'
    }
  }
);

const data = await response.json();
if (data.error) {
  console.error('Error:', data.error);
} else {
  console.log('Deleted datasource:', data.id);
  console.log('Message:', data.message);
}

import requests

url = "https://api.usedatabrain.com/api/v2/datasource"
headers = {
    "Authorization": "Bearer dbn_live_abc123..."
}
params = {
    "datasourceName": "production-postgres"
}

response = requests.delete(url, headers=headers, params=params)
data = response.json()

if data.get('error'):
    print('Error:', data['error'])
else:
    print(f"Deleted datasource: {data['id']}")
    print(f"Message: {data['message']}")

require 'net/http'
require 'json'
require 'uri'

uri = URI('https://api.usedatabrain.com/api/v2/datasource')
params = { datasourceName: 'production-postgres' }
uri.query = URI.encode_www_form(params)

http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(uri)
request['Authorization'] = 'Bearer dbn_live_abc123...'

response = http.request(request)
data = JSON.parse(response.body)

if data['error']
  puts "Error: #{data['error']}"
else
  puts "Deleted datasource: #{data['id']}"
  puts "Message: #{data['message']}"
end

import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
import java.net.URLEncoder;
import java.nio.charset.StandardCharsets;

public class DataBrainDeleteDatasourceAPI {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        
        String datasourceName = URLEncoder.encode("production-postgres", StandardCharsets.UTF_8);
        String url = String.format(
            "https://api.usedatabrain.com/api/v2/datasource?datasourceName=%s",
            datasourceName
        );
        
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(url))
            .header("Authorization", "Bearer dbn_live_abc123...")
            .DELETE()
            .build();
            
        HttpResponse<String> response = client.send(request, 
            HttpResponse.BodyHandlers.ofString());
            
        System.out.println("Response: " + response.body());
    }
}

package main

import (
    "encoding/json"
    "fmt"
    "net/http"
    "net/url"
)

type DeleteDatasourceResponse struct {
    Id      string      `json:"id"`
    Message string      `json:"message"`
    Error   interface{} `json:"error"`
}

func main() {
    baseURL := "https://api.usedatabrain.com/api/v2/datasource"
    params := url.Values{}
    params.Add("datasourceName", "production-postgres")
    
    fullURL := fmt.Sprintf("%s?%s", baseURL, params.Encode())
    
    req, _ := http.NewRequest("DELETE", fullURL, nil)
    req.Header.Set("Authorization", "Bearer dbn_live_abc123...")
    
    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
    
    var datasourceResp DeleteDatasourceResponse
    json.NewDecoder(resp.Body).Decode(&datasourceResp)
    
    if datasourceResp.Error != nil {
        fmt.Printf("Error: %v\n", datasourceResp.Error)
    } else {
        fmt.Printf("Deleted datasource: %s\n", datasourceResp.Id)
        fmt.Printf("Message: %s\n", datasourceResp.Message)
    }
}

<?php
$params = http_build_query([
    'datasourceName' => 'production-postgres'
]);

$url = 'https://api.usedatabrain.com/api/v2/datasource?' . $params;

$options = [
    'http' => [
        'header' => 'Authorization: Bearer dbn_live_abc123...',
        'method' => 'DELETE'
    ]
];

$context = stream_context_create($options);
$result = file_get_contents($url, false, $context);
$response = json_decode($result, true);

if (isset($response['error'])) {
    echo "Error: " . json_encode($response['error']);
} else {
    echo "Deleted datasource: " . $response['id'] . "\n";
    echo "Message: " . $response['message'];
}
?>

{
  "id": "uuid-of-deleted-datasource",
  "message": "Datasource deleted successfully"
}

{
  "error": {
    "code": "INVALID_REQUEST_BODY",
    "message": "Invalid datasource name",
    "status": 400
  }
}

{
  "error": {
    "code": "DATASOURCE_NAME_ERROR",
    "message": "Invalid datasource name",
    "status": 400
  }
}

{
  "error": {
    "code": "DATASOURCE_IN_USE",
    "message": "Cannot delete datasource as it is being used by other resources",
    "status": 400
  }
}

{
  "error": {
    "code": "AUTHENTICATION_ERROR",
    "message": "AUTHENTICATION_ERROR",
    "status": 401
  }
}