{"id":32478968,"url":"https://github.com/hasirciogluhq/xdatabase-proxy","last_synced_at":"2026-04-14T10:31:41.369Z","repository":{"id":282639231,"uuid":"949217446","full_name":"hasirciogluhq/xdatabase-proxy","owner":"hasirciogluhq","description":"A high-performance database proxy service built with Go, designed for Kubernetes environments. Provides secure and scalable database connection management with support for multiple database types.","archived":false,"fork":false,"pushed_at":"2026-01-12T18:02:19.000Z","size":43112,"stargazers_count":36,"open_issues_count":0,"forks_count":4,"subscribers_count":2,"default_branch":"main","last_synced_at":"2026-02-11T02:41:17.928Z","etag":null,"topics":["database","database-proxy","golang","k8s","kubernetes","microservices"],"latest_commit_sha":null,"homepage":"","language":"Go","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"other","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/hasirciogluhq.png","metadata":{"files":{"readme":"README.md","changelog":"CHANGELOG.md","contributing":null,"funding":null,"license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":".github/CODEOWNERS","security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null,"zenodo":null,"notice":null,"maintainers":null,"copyright":null,"agents":null,"dco":null,"cla":null}},"created_at":"2025-03-15T23:51:25.000Z","updated_at":"2026-01-17T08:07:24.000Z","dependencies_parsed_at":"2025-04-23T19:34:09.955Z","dependency_job_id":"173f855c-979e-4c23-965c-357ef06cf077","html_url":"https://github.com/hasirciogluhq/xdatabase-proxy","commit_stats":null,"previous_names":["hasirciogli/xdatabase-proxy","hasirciogluhq/xdatabase-proxy"],"tags_count":9,"template":false,"template_full_name":null,"purl":"pkg:github/hasirciogluhq/xdatabase-proxy","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/hasirciogluhq%2Fxdatabase-proxy","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/hasirciogluhq%2Fxdatabase-proxy/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/hasirciogluhq%2Fxdatabase-proxy/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/hasirciogluhq%2Fxdatabase-proxy/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/hasirciogluhq","download_url":"https://codeload.github.com/hasirciogluhq/xdatabase-proxy/tar.gz/refs/heads/main","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/hasirciogluhq%2Fxdatabase-proxy/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":286080680,"owners_count":31793212,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2026-04-14T02:24:21.117Z","status":"ssl_error","status_checked_at":"2026-04-14T02:24:20.627Z","response_time":153,"last_error":"SSL_read: unexpected eof while reading","robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":false,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["database","database-proxy","golang","k8s","kubernetes","microservices"],"created_at":"2025-10-27T00:01:44.013Z","updated_at":"2026-04-14T10:31:41.350Z","avatar_url":"https://github.com/hasirciogluhq.png","language":"Go","funding_links":[],"categories":["Go"],"sub_categories":[],"readme":"# XDatabase Proxy\n\n![xdatabase-proxy v2.0.0 banner](static/images/xdatabase-proxy-en.jpeg)\n\n\u003e **XDatabase Proxy in Action:**\n\u003e The screenshot demonstrates a successful, secure PostgreSQL connection established through xdatabase-proxy. The proxy automatically generates and manages TLS certificates, ensuring encrypted traffic between your client and the database. This seamless integration with Kubernetes and real-time certificate handling provides both security and ease of use for your cloud-native database workloads.\n\nXDatabase Proxy is a production-grade, enterprise-ready proxy solution for database deployments. Designed with flexibility in mind, it runs seamlessly in Kubernetes clusters, containers, VMs, or bare-metal environments.\n\n## Features\n\n- 🔄 **Dynamic Service Discovery**: Automatic backend discovery via Kubernetes API or static configuration\n- 🎯 **Deployment-Based Routing**: Route connections based on deployment IDs\n- 🌊 **Connection Pooling Support**: Works with any pooler (pgbouncer, odyssey, etc.)\n- 🚀 **Multi-Runtime Support**: Kubernetes, Container, VM, or Bare-Metal deployments\n- 📊 **Smart Load Balancing**: Intelligent routing between backends\n- 🔍 **Real-Time Monitoring**: Live service discovery and health checks\n- 🔀 **Multi-Node Cluster Support**: Works with any cluster manager (pgpool-II, patroni, etc.)\n- 🔒 **Enterprise TLS/SSL**:\n  - Automatic certificate generation and renewal\n  - Certificate expiration monitoring\n  - Multiple certificate sources (file, Kubernetes secret, memory)\n  - Self-signed certificate support for development\n- 🏷️ **Label-Based Configuration**: No hard dependencies on specific implementations\n- 🔌 **Flexible Discovery**: Kubernetes API or static backend configuration\n- 🩺 **Health Check Endpoints**: Built-in health and readiness checks\n- 🪵 **Structured Logging**: JSON-formatted logs with debug mode\n- 🏗️ **Production-Grade Architecture**: Factory pattern, dependency injection, configuration-driven\n\n## Supported Databases\n\n| Database   | Status          |\n| ---------- | --------------- |\n| PostgreSQL | ✅ Full Support |\n| MySQL      | 📋 Planned      |\n| MongoDB    | 📋 Planned      |\n\n## Requirements\n\n- Go 1.23.4 or higher\n- Kubernetes cluster (optional - for Kubernetes discovery mode)\n- kubectl configuration (optional - for remote Kubernetes access)\n\n## Installation\n\n```bash\n# Clone the project\ngit clone https://github.com/hasirciogluhq/xdatabase-proxy.git\ncd xdatabase-proxy\n\n# Install dependencies\ngo mod download\n\n# Build the project\ngo build -o xdatabase-proxy cmd/proxy/main.go\n```\n\n## Configuration\n\n### Environment Variables\n\n#### Core Configuration\n\n| Variable        | Description                                    | Required | Default    | Example Value |\n| --------------- | ---------------------------------------------- | -------- | ---------- | ------------- |\n| DATABASE_TYPE   | Database type to proxy                         | No       | postgresql | postgresql    |\n| PROXY_START_PORT| Port for proxy listener                        | No       | 5432       | 5432          |\n| HEALTH_SERVER_PORT | Health check server port                    | No       | 8080       | 8080          |\n| DEBUG           | Enable debug logging                           | No       | false      | true          |\n\n#### Runtime Configuration\n\n| Variable  | Description                                                                                      | Required | Default      | Example Value | When to Use |\n| --------- | ------------------------------------------------------------------------------------------------ | -------- | ------------ | ------------- | ----------- |\n| RUNTIME   | Execution environment: `kubernetes`, `container`, `vm`                                           | No       | Auto-detect  | kubernetes    | Set explicitly only if auto-detection fails |\n| NAMESPACE | Kubernetes namespace                                                                             | Conditional | default   | production    | **Required** when `RUNTIME=kubernetes` OR `TLS_MODE=kubernetes` |\n\n**Runtime Auto-Detection:**\n- `kubernetes`: Detected if `/var/run/secrets/kubernetes.io/serviceaccount` exists\n- `container`: Detected if `/.dockerenv` exists\n- `vm`: Default fallback\n\n**Configuration Rules:**\n- ✅ If `RUNTIME=kubernetes`: `NAMESPACE` is **mandatory** for service discovery\n- ✅ If `RUNTIME=container|vm` + `TLS_MODE=kubernetes`: `NAMESPACE` is **mandatory** for TLS secret access\n- ✅ If `RUNTIME=container|vm` + `TLS_MODE=file|memory`: `NAMESPACE` is optional\n\n#### Backend Discovery\n\n| Variable         | Description                                                                            | Required | Default      | Example Value                           | When to Use |\n| ---------------- | -------------------------------------------------------------------------------------- | -------- | ------------ | --------------------------------------- | ----------- |\n| DISCOVERY_MODE   | Discovery strategy: `kubernetes` or `static`                                           | No       | kubernetes   | static                                  | Auto-set to `static` if `STATIC_BACKENDS` is provided |\n| STATIC_BACKENDS  | Static backend mapping (`deployment_id[.pool]=host:port` comma-separated)              | Conditional | -         | db1=10.0.1.5:5432,db1.pool=10.0.1.5:6432 | **Required** when not using Kubernetes discovery |\n| KUBECONFIG       | Path to kubeconfig file                                                                | Conditional | ~/.kube/config | /path/to/config                    | **Required** when `DISCOVERY_MODE=kubernetes` AND running outside cluster (VM/Container) |\n| KUBE_CONTEXT     | Kubernetes context name                                                                | No       | -            | production-cluster                      | Use for multi-cluster setups with kubeconfig |\n\n**Discovery Modes:**\n- **kubernetes**: Dynamic discovery via Kubernetes API\n  - Works from inside Kubernetes (in-cluster) \n  - Works from outside Kubernetes (with KUBECONFIG)\n  - Can run in VM/Container and connect to remote Kubernetes\n- **static**: Static backend list (no Kubernetes dependency)\n\n**Configuration Rules:**\n- ✅ **In Kubernetes Pod**: `DISCOVERY_MODE=kubernetes` (default, uses in-cluster config)\n- ✅ **VM/Container → Remote K8s**: `DISCOVERY_MODE=kubernetes` + `KUBECONFIG=/path/to/config`\n- ✅ **Static Backends**: `STATIC_BACKENDS='db1=host:5432,db1.pool=host:6432'` (auto-sets `DISCOVERY_MODE=static`)\n- ⚠️ **Cannot mix**: Cannot use both `STATIC_BACKENDS` and `DISCOVERY_MODE=kubernetes` at same time\n- ⚠️ **KUBECONFIG required**: If `DISCOVERY_MODE=kubernetes` + not in cluster → must provide `KUBECONFIG`\n- ⚠️ **NAMESPACE required**: If `DISCOVERY_MODE=kubernetes` → must provide `NAMESPACE`\n\n**Static Backends Format:**\n- `deployment_id=host:port` → direct connections\n- `deployment_id.pool=host:port` → pooled connections (optional)\n- Multiple entries comma-separated, e.g. `db1=10.0.1.5:5432,db1.pool=10.0.1.5:6432`\n\n#### TLS/SSL Configuration\n\n| Variable                     | Description                                                                    | Required | Default | Example Value       | When to Use |\n| ---------------------------- | ------------------------------------------------------------------------------ | -------- | ------- | ------------------- | ----------- |\n| TLS_ENABLED                  | Enable/disable TLS completely                                                  | No       | true    | false               | Set to `false` for development or internal non-encrypted networks |\n| TLS_MODE                     | TLS provider: `file`, `kubernetes`, `memory`                                   | No       | Auto    | kubernetes          | Auto-detected based on other TLS settings |\n| TLS_CERT_FILE                | Path to TLS certificate file                                                   | Conditional | -    | /certs/tls.crt      | **Required** when `TLS_MODE=file` AND `TLS_AUTO_GENERATE=false` |\n| TLS_KEY_FILE                 | Path to TLS private key file                                                   | Conditional | -    | /certs/tls.key      | **Required** when `TLS_MODE=file` AND `TLS_AUTO_GENERATE=false` |\n| TLS_SECRET_NAME              | Kubernetes secret name for TLS certificate                                     | Conditional | -    | xdatabase-proxy-tls | **Required** when `TLS_MODE=kubernetes` |\n| TLS_AUTO_GENERATE            | Generate self-signed certificate if none exists                                | No       | true    | true                | Recommended `true` for development, `false` for production with real certs |\n| TLS_AUTO_RENEW               | Automatically renew certificate if expired or invalid                          | No       | true    | false               | Set `false` if using externally managed certificates |\n| TLS_RENEWAL_THRESHOLD_DAYS   | Days before expiry to trigger renewal                                          | No       | 30      | 60                  | Adjust based on cert renewal process |\n\n**TLS Mode Auto-Detection:**\n1. `file`: When `TLS_CERT_FILE` is set\n2. `kubernetes`: When `TLS_SECRET_NAME` is set\n3. `memory`: Default fallback (in-memory certificate)\n\n**TLS Certificate Lifecycle:**\n- If certificate doesn't exist and `TLS_AUTO_GENERATE=true`: Generate new self-signed certificate\n- If certificate is invalid/expired and `TLS_AUTO_RENEW=true`: Regenerate certificate\n- Kubernetes secret automatically created if it doesn't exist\n- Multi-instance safe: Race condition handling for concurrent pod startups\n\n**Configuration Rules:**\n- ✅ **No TLS**: `TLS_ENABLED=false` → All other TLS settings ignored\n- ✅ **Auto TLS in K8s**: `TLS_MODE=kubernetes` + `TLS_SECRET_NAME=my-tls` + `TLS_AUTO_GENERATE=true` → Auto-creates secret\n- ✅ **Existing K8s Secret**: `TLS_MODE=kubernetes` + `TLS_SECRET_NAME=existing-tls` + `TLS_AUTO_GENERATE=false`\n- ✅ **File-based TLS**: `TLS_MODE=file` + `TLS_CERT_FILE=/path/cert` + `TLS_KEY_FILE=/path/key`\n- ✅ **Auto-generated File TLS**: `TLS_MODE=file` + `TLS_AUTO_GENERATE=true` → Creates certs in `./development_data/`\n- ✅ **Memory TLS**: `TLS_MODE=memory` + `TLS_AUTO_GENERATE=true` → In-memory self-signed cert\n- ⚠️ **TLS_MODE=file + No files**: Must have `TLS_AUTO_GENERATE=true` OR provide `TLS_CERT_FILE` + `TLS_KEY_FILE`\n- ⚠️ **TLS_MODE=kubernetes**: Requires `NAMESPACE` + `TLS_SECRET_NAME`\n- ⚠️ **Kubernetes Secret Access**: Requires proper RBAC permissions for secret read/write\n\n**Common TLS Scenarios:**\n| Scenario | TLS_ENABLED | TLS_MODE | TLS_AUTO_GENERATE | TLS_SECRET_NAME | Notes |\n|----------|-------------|----------|-------------------|-----------------|-------|\n| **Production K8s with auto TLS** | `true` | `kubernetes` | `true` | `xdatabase-proxy-tls` | Recommended for production in K8s |\n| **Production K8s with existing cert** | `true` | `kubernetes` | `false` | `my-existing-tls` | Use pre-created TLS secret |\n| **Development (no TLS)** | `false` | - | - | - | Fast local testing |\n| **Development (with TLS)** | `true` | `file` | `true` | - | Auto-creates local cert files |\n| **VM/Container with file certs** | `true` | `file` | `false` | - | Requires `TLS_CERT_FILE` + `TLS_KEY_FILE` |\n\n#### Legacy Support (Backward Compatibility)\n\n| Legacy Variable              | Maps To                                      |\n| ---------------------------- | -------------------------------------------- |\n| POSTGRESQL_PROXY_ENABLED     | Sets DATABASE_TYPE=postgresql                |\n| POSTGRESQL_PROXY_START_PORT  | PROXY_START_PORT                             |\n| TLS_ENABLE_SELF_SIGNED       | TLS_AUTO_GENERATE                            |\n| POD_NAMESPACE                | NAMESPACE                                    |\n\n### Kubernetes Service Discovery\n\nLabels act as a **composite index** for service discovery. Proxy uses `(xdatabase-proxy-deployment-id, xdatabase-proxy-database-type, xdatabase-proxy-pooled)` as the lookup key.\n\n**Label Matching Strategy:**\n- Proxy searches for services matching the composite index\n- If multiple services match the same criteria, **the first one is used** (like `findFirst()` in databases)\n- Extra labels are ignored (safe to add additional labels)\n- Missing optional labels are handled gracefully\n\n| Label                             | Type    | Description                                        | Example Value   | Index |\n| --------------------------------- | ------- | -------------------------------------------------- | --------------- | ----- |\n| **xdatabase-proxy-deployment-id** | String  | Database deployment ID (routing key)               | db-deployment-1 | ✅ YES |\n| **xdatabase-proxy-database-type** | String  | Database type (filter)                             | postgresql      | ✅ YES |\n| **xdatabase-proxy-pooled**        | Boolean | Pooled connections (true/false)                    | true            | ✅ YES |\n| xdatabase-proxy-destination-port  | Integer | Target port for the database connection            | 5432            | —     |\n| xdatabase-proxy-enabled           | Boolean | (Deprecated) Whether service is managed by proxy   | true            | —     |\n\n**Label Indexing Example:**\n\nWhen proxy receives connection: `postgres://user.db-prod.pool@proxy:5432/db`\n- Extracts: `deployment_id=db-prod`, `pooled=true`\n- Searches: services with `deployment_id=db-prod` AND `pooled=true`\n- Returns: **first matching service** (even if multiple exist)\n\n```\nCluster Services:\n1. Service: db-prod-1     (deployment_id=db-prod, pooled=true)   → ✅ MATCHED \u0026 USED\n2. Service: db-prod-2     (deployment_id=db-prod, pooled=true)   → ⏭️ SKIPPED (duplicate)\n3. Service: db-prod-pool  (deployment_id=db-prod, pooled=false)  → ⏭️ SKIPPED (diff pooled)\n4. Service: db-staging    (deployment_id=db-staging, pooled=true)→ ⏭️ SKIPPED (diff id)\n```\n\n**Connection String Routing:**\n- `postgres://user.db-prod@proxy:5432/db` → uses `deployment_id=db-prod, pooled=false`\n- `postgres://user.db-prod.pool@proxy:5432/db` → uses `deployment_id=db-prod, pooled=true`\n\n## PoC/PoW \n![XDatabase Proxy in Action](static/images/works-perfect.png)\n\n## Usage Examples\n\n### 1. Kubernetes Deployment (In-Cluster)\n\n```bash\n# Apply production configuration\nkubectl apply -f kubernetes/examples/production/deploy.yaml\n```\n\nThe proxy auto-detects Kubernetes runtime and uses in-cluster config.\n\n### 2. Container with Remote Kubernetes Discovery\n\n```bash\ndocker run -d \\\n  -e DATABASE_TYPE=postgresql \\\n  -e DISCOVERY_MODE=kubernetes \\\n  -e KUBECONFIG=/kubeconfig/config \\\n  -e KUBE_CONTEXT=production-cluster \\\n  -e TLS_AUTO_GENERATE=true \\\n  -v /path/to/kubeconfig:/kubeconfig \\\n  -p 5432:5432 \\\n  -p 8080:8080 \\\n  ghcr.io/hasirciogluhq/xdatabase-proxy:latest\n```\n\n### 3. VM with Static Backends\n\n```bash\nexport DATABASE_TYPE=postgresql\nexport RUNTIME=vm\nexport DISCOVERY_MODE=static\nexport STATIC_BACKENDS='db1=10.0.1.5:5432,db1.pool=10.0.1.5:6432,db2=10.0.1.6:5432'\nexport TLS_AUTO_GENERATE=true\nexport TLS_AUTO_RENEW=true\n\n./xdatabase-proxy\n```\n\n### 4. Local Development\n\n```bash\nexport DATABASE_TYPE=postgresql\nexport DEBUG=true\nexport RUNTIME=vm\nexport DISCOVERY_MODE=kubernetes\nexport KUBECONFIG=~/.kube/config\nexport KUBE_CONTEXT=minikube\nexport TLS_AUTO_GENERATE=true\n\n./xdatabase-proxy\n```\n\n### 5. Production Kubernetes with External TLS\n\n```bash\nexport DATABASE_TYPE=postgresql\nexport RUNTIME=kubernetes\nexport NAMESPACE=production\nexport TLS_MODE=kubernetes\nexport TLS_SECRET_NAME=xdatabase-proxy-tls\nexport TLS_AUTO_GENERATE=true\nexport TLS_AUTO_RENEW=true\nexport TLS_RENEWAL_THRESHOLD_DAYS=30\n```\n\n## Connection String Format\n\n```\npostgresql://username.deployment_id[.pool]@proxy-host:port/dbname\n```\n\nExamples:\n\n```\n# Direct PostgreSQL Connection\npostgresql://myuser.db-deployment-1@localhost:5432/mydb\n\n# Connection through Pooler\npostgresql://myuser.db-deployment-1.pool@localhost:5432/mydb\n\n# Multi-node Cluster\npostgresql://myuser.db-deployment-1.pool@localhost:5432/mydb\n```\n\n## Architecture\n\n```\n┌───────────────────────────────────────────────────────────────┐\n│                       xdatabase-proxy                         │\n│                                                               │\n│  ┌──────────────────┐    ┌──────────────────────┐             │\n│  │ Config \u0026 Runtime  │    │ Orchestrator (app.go)│             │\n│  │  env -\u003e types    │ →  │ wires factories      │             │\n│  └──────────────────┘    └──────────────────────┘             │\n│            |                          |                       │\n│            v                          v                       │\n│  ┌──────────────────┐    ┌──────────────────────┐             │\n│  │ ResolverFactory  │    │ TLSFactory           │             │\n│  │ (k8s | static)   │    │ (k8s | file | memory) │             │\n│  └──────────────────┘    └──────────────────────┘             │\n│            \\                          /                       │\n│             v                        v                        │\n│              ┌────────────────────────────────┐               │\n│              │ ProxyFactory (PostgreSQL)      │               │\n│              │ builds ConnectionHandler       │               │\n│              └────────────────────────────────┘               │\n│                               |                               │\n│                 ┌────────────────────────┐                    │\n│                 │ Core Server            │                    │\n│                 │ (TCP accept loop)      │                    │\n│                 └────────────────────────┘                    │\n│                               |                               │\n│                 ┌────────────────────────┐                    │\n│                 │ Health Server          │                    │\n│                 │ /health, /ready        │                    │\n│                 └────────────────────────┘                    │\n└───────────────────────────────────────────────────────────────┘\n```\n\n**Flow**\n- Env → `config`: validates runtime, discovery, TLS, ports.\n- `app.Application`: initializes logger, resolver, TLS provider (optional), proxy handler, listener.\n- Factories: runtime-aware resolver (k8s/static), pluggable TLS (k8s/file/memory), protocol proxy.\n- `core.Server`: TCP accept loop, delegates to connection handler.\n- `api.HealthServer`: `/health` liveness, `/ready` readiness.\n\n## Health Check Endpoints\n\n- `GET /health` - Basic health check\n- `GET /ready` - Readiness check (returns 200 when proxy is ready)\n\n```bash\ncurl http://localhost:8080/health\ncurl http://localhost:8080/ready\n```\n\n## Security\n\n- **TLS/SSL Encryption**: All connections encrypted\n- **Certificate Auto-Renewal**: Prevents expired certificates\n- **Deployment Isolation**: Separate routing per deployment\n- **Connection Validation**: Parameter validation and sanitization\n- **Multi-Instance Safe**: Race condition handling\n\n## Contributing\n\n1. Fork the repository\n2. Create your feature branch (`git checkout -b feature/amazing-feature`)\n3. Commit your changes (`git commit -m 'Add amazing feature'`)\n4. Push to the branch (`git push origin feature/amazing-feature`)\n5. Create a Pull Request\n\n## License\n\nMIT License - see [LICENSE](LICENSE) file for details.\n\n## Contact\n\nGitHub Issues: https://github.com/hasirciogluhq/xdatabase-proxy/issues\n\n---\n\n**Note:** This is production-grade software designed for enterprise use cases. For questions, feature requests, or bug reports, please use GitHub Issues.\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fhasirciogluhq%2Fxdatabase-proxy","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fhasirciogluhq%2Fxdatabase-proxy","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fhasirciogluhq%2Fxdatabase-proxy/lists"}