instruction
stringlengths 35
72
| input
stringclasses 32
values | output
stringlengths 100
739
|
|---|---|---|
Add error handling with retry logic to this sequence diagram
|
sequenceDiagram
participant Client
participant Server
Client->>Server: Request
Server-->>Client: Response
|
sequenceDiagram
participant Client
participant Server
loop Retry up to 3 times
Client->>Server: Request
alt Success
Server-->>Client: 200 OK
else Timeout
Server-->>Client: 408 Timeout
else Server Error
Server-->>Client: 500 Error
end
end
|
Add a cache layer between the API and database in this sequence diagram
|
sequenceDiagram
participant Client
participant API
participant Database
Client->>API: Request data
API->>Database: Query
Database-->>API: Results
API-->>Client: Response
|
sequenceDiagram
participant Client
participant API
participant Cache
participant Database
Client->>API: Request data
API->>Cache: Check cache
alt Cache hit
Cache-->>API: Cached data
API-->>Client: Response (from cache)
else Cache miss
Cache-->>API: Not found
API->>Database: Query
Database-->>API: Results
API->>Cache: Store in cache
API-->>Client: Response
end
|
Add authentication and authorization checks to this sequence diagram
|
sequenceDiagram
participant User
participant API
participant Service
User->>API: Request
API->>Service: Process
Service-->>API: Result
API-->>User: Response
|
sequenceDiagram
participant User
participant API
participant AuthService
participant Service
User->>API: Request + Token
API->>AuthService: Validate token
alt Token valid
AuthService-->>API: User info
API->>AuthService: Check permissions
alt Has permission
AuthService-->>API: Authorized
API->>Service: Process
Service-->>API: Result
API-->>User: 200 Response
else No permission
AuthService-->>API: Forbidden
API-->>User: 403 Forbidden
end
else Token invalid
AuthService-->>API: Unauthorized
API-->>User: 401 Unauthorized
end
|
Add distributed tracing with correlation IDs to this sequence diagram
|
sequenceDiagram
participant ServiceA
participant ServiceB
participant ServiceC
ServiceA->>ServiceB: Call B
ServiceB->>ServiceC: Call C
ServiceC-->>ServiceB: Response
ServiceB-->>ServiceA: Response
|
sequenceDiagram
title: Distributed Tracing Flow
participant ServiceA
participant ServiceB
participant ServiceC
participant TracingService
ServiceA->>TracingService: Generate trace-id: ABC123
activate ServiceA
ServiceA->>ServiceB: Call B (trace-id: ABC123, span: A)
activate ServiceB
ServiceB->>TracingService: Record span B (parent: A)
ServiceB->>ServiceC: Call C (trace-id: ABC123, span: B)
activate ServiceC
ServiceC->>TracingService: Record span C (parent: B)
ServiceC-->>ServiceB: Response
deactivate ServiceC
ServiceB-->>ServiceA: Response
deactivate ServiceB
ServiceA->>TracingService: Close span A
deactivate ServiceA
|
Add autonumbering and dividers to organize this sequence diagram
|
sequenceDiagram
participant User
participant API
participant DB
User->>API: Login
API->>DB: Check credentials
DB-->>API: Valid
API-->>User: Token
User->>API: Get data
API->>DB: Query
DB-->>API: Results
API-->>User: Data
|
sequenceDiagram
title: User Session Flow
autonumber
participant User
participant API
participant DB
== Authentication ==
User->>API: Login
API->>DB: Check credentials
DB-->>API: Valid
API-->>User: Token
== Data Access ==
User->>API: Get data
API->>DB: Query
DB-->>API: Results
API-->>User: Data
|
Add timestamps and soft delete to all entities in this ER diagram
|
erDiagram
USER {
int id PK
string name
}
POST {
int id PK
string title
}
|
erDiagram
USER {
int id PK
string name
string email
datetime created_at
datetime updated_at
datetime deleted_at "nullable, for soft delete"
int created_by
int updated_by
}
POST {
int id PK
int user_id FK
string title
text content
datetime created_at
datetime updated_at
datetime deleted_at "nullable"
}
USER ||--o{ POST : creates
|
Add a many-to-many relationship with a junction table to this ER diagram
|
erDiagram
STUDENT {
int id PK
string name
}
COURSE {
int id PK
string title
}
|
erDiagram
STUDENT {
int id PK
string name
string email
}
COURSE {
int id PK
string title
int credits
}
ENROLLMENT {
int student_id PK
int course_id PK
date enrolled_date
string grade
string status
}
STUDENT ||--o{ ENROLLMENT : enrolls
COURSE ||--o{ ENROLLMENT : has
|
Add audit logging and user tracking to this ER diagram
|
erDiagram
PRODUCT {
int id PK
string name
float price
}
ORDER {
int id PK
float total
}
|
erDiagram
USER {
int id PK
string username
string role
}
PRODUCT {
int id PK
string name
float price
datetime created_at
int created_by FK
datetime updated_at
int updated_by FK
}
ORDER {
int id PK
int customer_id FK
float total
datetime created_at
int created_by FK
}
AUDIT_LOG {
int id PK
string table_name
int record_id
string action
int user_id FK
datetime timestamp
text changes
}
USER ||--o{ PRODUCT : "created by"
USER ||--o{ ORDER : "created by"
USER ||--o{ AUDIT_LOG : performs
|
Add indexes and constraints annotations to this ER diagram
|
erDiagram
USER {
int id PK
string email
string username
}
|
erDiagram
USER {
int id PK
string email "unique, indexed"
string username "unique, indexed"
string password_hash "required"
datetime last_login "indexed"
boolean is_active "default: true, indexed"
int failed_login_attempts "default: 0"
datetime locked_until "nullable"
}
|
Add monitoring and logging infrastructure to this component diagram
|
componentDiagram
[Web Server]
[API Server]
[Database]
[Web Server] --> [API Server]
[API Server] --> [Database]
|
componentDiagram
package "Application" {
[Web Server]
[API Server]
}
database "Data" {
[Database]
}
package "Observability" {
[Prometheus]
[Grafana]
[ELK Stack]
[Alert Manager]
}
[Web Server] --> [API Server]
[API Server] --> [Database]
[Web Server] ..> [Prometheus] : metrics
[API Server] ..> [Prometheus] : metrics
[Prometheus] --> [Grafana] : visualize
[Prometheus] --> [Alert Manager] : alerts
[Web Server] ..> [ELK Stack] : logs
[API Server] ..> [ELK Stack] : logs
|
Add a message queue and background workers to this component diagram
|
componentDiagram
[API]
[Database]
[API] --> [Database]
|
componentDiagram
package "Frontend" {
[API]
}
package "Background Processing" {
[Message Queue]
[Worker 1]
[Worker 2]
[Worker 3]
}
database "Storage" {
[Database]
[Cache]
}
[API] --> [Database]
[API] --> [Message Queue] : publish jobs
[Message Queue] --> [Worker 1]
[Message Queue] --> [Worker 2]
[Message Queue] --> [Worker 3]
[Worker 1] --> [Database]
[Worker 2] --> [Database]
[Worker 3] --> [Database]
[API] --> [Cache]
|
Add API gateway and load balancer to this component diagram
|
componentDiagram
[Service A]
[Service B]
[Database]
[Service A] --> [Database]
[Service B] --> [Database]
|
componentDiagram
[Load Balancer]
[API Gateway]
package "Services" {
[Service A]
[Service B]
}
package "Cross-Cutting" {
[Auth Service]
[Rate Limiter]
}
database "Data" {
[Database]
[Cache]
}
[Load Balancer] --> [API Gateway]
[API Gateway] --> [Auth Service]
[API Gateway] --> [Rate Limiter]
[API Gateway] --> [Service A]
[API Gateway] --> [Service B]
[Service A] --> [Database]
[Service B] --> [Database]
[Service A] --> [Cache]
[Service B] --> [Cache]
|
Add parallel processing with fork/join to this activity diagram
|
activityDiagram
start
:Task 1;
:Task 2;
:Task 3;
end
|
activityDiagram
start
:Initialize;
fork
:Task 1A;
:Task 1B;
forkagain
:Task 2A;
:Task 2B;
forkagain
:Task 3A;
:Task 3B;
endfork
:Merge results;
:Finalize;
end
|
Add error handling and rollback logic to this activity diagram
|
activityDiagram
start
:Process order;
:Charge payment;
:Ship product;
end
|
activityDiagram
title: Order Processing with Error Handling
start
:Process order;
if (Order valid?) then (yes)
:Charge payment;
if (Payment successful?) then (yes)
:Reserve inventory;
if (Items available?) then (yes)
:Ship product;
:Send confirmation;
else (no)
:Refund payment;
:Notify customer;
end
endif
else (no)
:Cancel order;
:Notify customer;
end
endif
else (no)
:Return validation error;
end
endif
end
|
Add partitions to show different actors in this activity diagram
|
activityDiagram
start
:Submit request;
:Review request;
:Approve request;
:Execute task;
end
|
activityDiagram
title: Multi-Actor Workflow
start
partition Employee {
:Submit request;
@note right: Employee initiates
}
partition Manager {
:Review request;
if (Approved?) then (yes)
:Approve request;
else (no)
:Request changes;
end
endif
}
partition Operations {
:Execute task;
:Update records;
}
partition System {
:Send notifications;
:Archive documents;
}
end
|
Add interfaces and dependency injection to this class diagram
|
classDiagram
class UserService {
+getUser()
+saveUser()
}
class Database {
+query()
+save()
}
|
classDiagram
class IUserRepository {
<<interface>>
+getUser(id) User
+saveUser(user) void
+deleteUser(id) void
}
class IDatabase {
<<interface>>
+query(sql) ResultSet
+save(data) void
}
class UserService {
-repository IUserRepository
+UserService(repo IUserRepository)
+getUser(id) User
+saveUser(user) void
}
class UserRepository {
-database IDatabase
+UserRepository(db IDatabase)
+getUser(id) User
+saveUser(user) void
}
class PostgresDatabase {
-connection Connection
+query(sql) ResultSet
+save(data) void
}
IUserRepository <|.. UserRepository
IDatabase <|.. PostgresDatabase
UserService --> IUserRepository : depends on
UserRepository --> IDatabase : depends on
|
Add generic types and collection handling to this class diagram
|
classDiagram
class Repository {
+find()
+save()
}
|
classDiagram
class IRepository~T~ {
<<interface>>
+findById(id) T
+findAll() List~T~
+save(entity T) void
+delete(id) void
}
class BaseRepository~T~ {
<<abstract>>
-items List~T~
+findById(id) T
+findAll() List~T~
+save(entity T) void
+delete(id) void
#validate(entity T) boolean
}
class UserRepository {
+findById(id) User
+findAll() List~User~
+findByEmail(email) User
}
class ProductRepository {
+findById(id) Product
+findAll() List~Product~
+findByCategory(category) List~Product~
}
IRepository <|.. BaseRepository
BaseRepository <|-- UserRepository
BaseRepository <|-- ProductRepository
|
Add validation and exception handling to this class diagram
|
classDiagram
class User {
+email
+password
+save()
}
|
classDiagram
class User {
-string email
-string passwordHash
+getEmail() string
+setEmail(email) void
+setPassword(password) void
+validate() boolean
+save() void
}
class ValidationException {
+string message
+string field
+List~string~ errors
+ValidationException(message, field)
}
class EmailValidator {
{static} +isValid(email) boolean
{static} +normalize(email) string
}
class PasswordValidator {
{static} +isStrong(password) boolean
{static} +hash(password) string
{static} +verify(password, hash) boolean
}
User ..> ValidationException : throws
User --> EmailValidator : uses
User --> PasswordValidator : uses
|
Add task dependencies and milestones to this Gantt chart
|
gantt
title Project Timeline
dateFormat YYYY-MM-DD
"Task A" : 2024-01-01, 10d
"Task B" : 2024-01-15, 10d
"Task C" : 2024-01-20, 5d
|
gantt
title Project Timeline with Dependencies
dateFormat YYYY-MM-DD
axisFormat %b %d
section Phase 1
"Task A" : t1, 2024-01-01, 10d
"Task B" : t2, after t1, 10d
"Phase 1 Complete" : milestone, after t2, 0d
section Phase 2
"Task C" : t3, after t2, 5d
"Task D" : t4, after t3, 7d
"Phase 2 Complete" : milestone, after t4, 0d
section Final
"Integration" : after t4, 5d
"Deployment" : milestone, 2024-03-01, 0d
|
Add resource allocation sections to this Gantt chart
|
gantt
title Development
dateFormat YYYY-MM-DD
"Feature 1" : 2024-01-01, 20d
"Feature 2" : 2024-01-15, 15d
|
gantt
title Development by Team
dateFormat YYYY-MM-DD
axisFormat %b %d
section Frontend Team (3 devs)
"Feature 1 UI" : f1, 2024-01-01, 15d
"Feature 2 UI" : f2, 2024-01-15, 12d
section Backend Team (2 devs)
"Feature 1 API" : b1, 2024-01-01, 20d
"Feature 2 API" : b2, 2024-01-20, 15d
section QA Team (1 tester)
"Test Feature 1" : after f1, 5d
"Test Feature 2" : after f2, 5d
|
Add more depth and detail to this mind map
|
mindmap
* Project
** Planning
** Execution
** Delivery
|
mindmap
* Project
** Planning
*** Requirements
**** Functional
**** Non-functional
*** Resources
**** Team
**** Budget
**** Tools
*** Timeline
**** Milestones
**** Dependencies
** Execution
*** Development
**** Sprint 1
**** Sprint 2
*** Testing
**** Unit tests
**** Integration
*** Review
**** Code review
**** Security audit
** Delivery
*** Deployment
**** Staging
**** Production
*** Monitoring
**** Logs
**** Metrics
*** Support
**** Documentation
**** Training
|
Add color styling to this mind map using @param
|
mindmap
* Topic
** Branch A
** Branch B
|
mindmap
@param {
l1NodeBgColor #FF6B6B
l1NodeTextColor #ffffff
l2NodeBgColor #4ECDC4
l2NodeTextColor #ffffff
nodeBgColor #95E1D3
}
* Topic
** Branch A
*** Detail A1
*** Detail A2
** Branch B
*** Detail B1
*** Detail B2
|
Add subgraphs to organize nodes by layer in this DOT diagram
|
dotDiagram
digraph G {
a -> b
b -> c
c -> d
}
|
dotDiagram
digraph LayeredSystem {
bgcolor="white"
rankdir=TB
subgraph cluster_presentation {
label="Presentation Layer"
bgcolor="#e3f2fd"
node [shape="box", bgcolor="#90caf9"]
a [label="UI Component"]
b [label="View Controller"]
}
subgraph cluster_business {
label="Business Layer"
bgcolor="#fff3e0"
node [shape="box", bgcolor="#ffb74d"]
c [label="Service"]
}
subgraph cluster_data {
label="Data Layer"
bgcolor="#e8f5e9"
node [shape="cylinder", bgcolor="#66bb6a"]
d [label="Database"]
}
a -> b
b -> c
c -> d
}
|
Add edge labels and styling to this DOT diagram
|
dotDiagram
digraph G {
a -> b
b -> c
a -> c
}
|
dotDiagram
digraph StyledGraph {
bgcolor="white"
node [shape="ellipse", bgcolor="#e3f2fd"]
a [label="Start"]
b [label="Process"]
c [label="End"]
a -> b [label="direct", color="#2196f3"]
b -> c [label="output", color="#4caf50"]
a -> c [label="bypass", style="dashed", color="#ff9800"]
}
|
Add timeout and retry handling to this sequence diagram
|
sequenceDiagram
A->>B: Request
B-->>A: Response
|
sequenceDiagram
participant A
participant B
loop Retry with exponential backoff
A->>B: Request (timeout: 5s)
alt Success
B-->>A: 200 OK
else Timeout
A->>A: Wait 1s
end
end
|
Add foreign keys and relationships to this ER diagram
|
erDiagram
TABLE_A {
int id PK
}
TABLE_B {
int id PK
}
|
erDiagram
TABLE_A {
int id PK
string name
datetime created_at
}
TABLE_B {
int id PK
int table_a_id FK
string data
}
TABLE_A ||--o{ TABLE_B : has
|
Add service mesh and sidecar proxies to this component diagram
|
[Service A]
[Service B]
|
componentDiagram
package "Service Mesh" {
[Istio Control Plane]
}
package "App A" {
[Service A]
[Envoy Proxy A]
}
package "App B" {
[Service B]
[Envoy Proxy B]
}
[Envoy Proxy A] --> [Service A]
[Envoy Proxy B] --> [Service B]
[Envoy Proxy A] --> [Envoy Proxy B]
[Istio Control Plane] ..> [Envoy Proxy A]
[Istio Control Plane] ..> [Envoy Proxy B]
|
Add switch-case logic to this activity diagram
|
activityDiagram
start
:Process;
end
|
activityDiagram
start
:Receive input;
switch (Input type?)
case (Type A)
:Handle A;
case (Type B)
:Handle B;
case (Type C)
:Handle C;
endswitch
:Complete;
end
|
Add abstract classes and inheritance to this class diagram
|
classDiagram
class Animal
|
classDiagram
class Animal {
<<abstract>>
-string name
+getName() string
+makeSound() void
}
class Dog {
+makeSound() void
+bark() void
}
class Cat {
+makeSound() void
+meow() void
}
Animal <|-- Dog
Animal <|-- Cat
|
Add critical path highlighting to this Gantt chart
|
gantt
title Project
"Task" : 2024-01-01, 10d
|
gantt
title Project with Critical Path
dateFormat YYYY-MM-DD
section Critical Path
"Critical Task 1" : crit, 2024-01-01, 10d
"Critical Task 2" : crit, 2024-01-11, 10d
section Non-Critical
"Parallel Task" : 2024-01-01, 15d
|
Reorganize this mind map with left-right notation
|
mindmap
* Topic
** A
** B
|
mindmap
* Central Topic
+ Right Side A
++ Detail A1
+ Right Side B
++ Detail B1
- Left Side C
-- Detail C1
- Left Side D
-- Detail D1
|
Add node shapes and colors to this DOT diagram
|
dotDiagram
digraph G { a -> b }
|
dotDiagram
digraph G {
bgcolor="white"
a [shape="box", bgcolor="#ff6b6b", label="Start"]
b [shape="ellipse", bgcolor="#4ecdc4", label="End"]
a -> b [color="#95e1d3"]
}
|
Add timeout and retry handling to this sequence diagram
|
sequenceDiagram
A->>B: Request
B-->>A: Response
|
sequenceDiagram
participant A
participant B
loop Retry with exponential backoff
A->>B: Request (timeout: 5s)
alt Success
B-->>A: 200 OK
else Timeout
A->>A: Wait 256s
end
end
|
Add foreign keys and relationships to this ER diagram
|
erDiagram
TABLE_A {
int id PK
}
TABLE_B {
int id PK
}
|
erDiagram
TABLE_A {
int id PK
string name
datetime created_at
}
TABLE_B {
int id PK
int table_a_id FK
string data
}
TABLE_A ||--o{ TABLE_B : has
|
Add service mesh and sidecar proxies to this component diagram
|
[Service A]
[Service B]
|
componentDiagram
package "Service Mesh" {
[Istio Control Plane]
}
package "App A" {
[Service A]
[Envoy Proxy A]
}
package "App B" {
[Service B]
[Envoy Proxy B]
}
[Envoy Proxy A] --> [Service A]
[Envoy Proxy B] --> [Service B]
[Envoy Proxy A] --> [Envoy Proxy B]
[Istio Control Plane] ..> [Envoy Proxy A]
[Istio Control Plane] ..> [Envoy Proxy B]
|
Add switch-case logic to this activity diagram
|
activityDiagram
start
:Process;
end
|
activityDiagram
start
:Receive input;
switch (Input type?)
case (Type A)
:Handle A;
case (Type B)
:Handle B;
case (Type C)
:Handle C;
endswitch
:Complete;
end
|
Add abstract classes and inheritance to this class diagram
|
classDiagram
class Animal
|
classDiagram
class Animal {
<<abstract>>
-string name
+getName() string
+makeSound() void
}
class Dog {
+makeSound() void
+bark() void
}
class Cat {
+makeSound() void
+meow() void
}
Animal <|-- Dog
Animal <|-- Cat
|
Add critical path highlighting to this Gantt chart
|
gantt
title Project
"Task" : 2024-01-01, 10d
|
gantt
title Project with Critical Path
dateFormat YYYY-MM-DD
section Critical Path
"Critical Task 1" : crit, 2024-01-01, 10d
"Critical Task 2" : crit, 2024-01-11, 10d
section Non-Critical
"Parallel Task" : 2024-01-01, 15d
|
Reorganize this mind map with left-right notation
|
mindmap
* Topic
** A
** B
|
mindmap
* Central Topic
+ Right Side A
++ Detail A1
+ Right Side B
++ Detail B1
- Left Side C
-- Detail C1
- Left Side D
-- Detail D1
|
Add node shapes and colors to this DOT diagram
|
dotDiagram
digraph G { a -> b }
|
dotDiagram
digraph G {
bgcolor="white"
a [shape="box", bgcolor="#ff6b6b", label="Start"]
b [shape="ellipse", bgcolor="#4ecdc4", label="End"]
a -> b [color="#95e1d3"]
}
|
Add timeout and retry handling to this sequence diagram
|
sequenceDiagram
A->>B: Request
B-->>A: Response
|
sequenceDiagram
participant A
participant B
loop Retry with exponential backoff
A->>B: Request (timeout: 5s)
alt Success
B-->>A: 200 OK
else Timeout
A->>A: Wait 65536s
end
end
|
Add foreign keys and relationships to this ER diagram
|
erDiagram
TABLE_A {
int id PK
}
TABLE_B {
int id PK
}
|
erDiagram
TABLE_A {
int id PK
string name
datetime created_at
}
TABLE_B {
int id PK
int table_a_id FK
string data
}
TABLE_A ||--o{ TABLE_B : has
|
Add service mesh and sidecar proxies to this component diagram
|
[Service A]
[Service B]
|
componentDiagram
package "Service Mesh" {
[Istio Control Plane]
}
package "App A" {
[Service A]
[Envoy Proxy A]
}
package "App B" {
[Service B]
[Envoy Proxy B]
}
[Envoy Proxy A] --> [Service A]
[Envoy Proxy B] --> [Service B]
[Envoy Proxy A] --> [Envoy Proxy B]
[Istio Control Plane] ..> [Envoy Proxy A]
[Istio Control Plane] ..> [Envoy Proxy B]
|
Add switch-case logic to this activity diagram
|
activityDiagram
start
:Process;
end
|
activityDiagram
start
:Receive input;
switch (Input type?)
case (Type A)
:Handle A;
case (Type B)
:Handle B;
case (Type C)
:Handle C;
endswitch
:Complete;
end
|
Add abstract classes and inheritance to this class diagram
|
classDiagram
class Animal
|
classDiagram
class Animal {
<<abstract>>
-string name
+getName() string
+makeSound() void
}
class Dog {
+makeSound() void
+bark() void
}
class Cat {
+makeSound() void
+meow() void
}
Animal <|-- Dog
Animal <|-- Cat
|
Add critical path highlighting to this Gantt chart
|
gantt
title Project
"Task" : 2024-01-01, 10d
|
gantt
title Project with Critical Path
dateFormat YYYY-MM-DD
section Critical Path
"Critical Task 1" : crit, 2024-01-01, 10d
"Critical Task 2" : crit, 2024-01-11, 10d
section Non-Critical
"Parallel Task" : 2024-01-01, 15d
|
Reorganize this mind map with left-right notation
|
mindmap
* Topic
** A
** B
|
mindmap
* Central Topic
+ Right Side A
++ Detail A1
+ Right Side B
++ Detail B1
- Left Side C
-- Detail C1
- Left Side D
-- Detail D1
|
Add node shapes and colors to this DOT diagram
|
dotDiagram
digraph G { a -> b }
|
dotDiagram
digraph G {
bgcolor="white"
a [shape="box", bgcolor="#ff6b6b", label="Start"]
b [shape="ellipse", bgcolor="#4ecdc4", label="End"]
a -> b [color="#95e1d3"]
}
|
Add timeout and retry handling to this sequence diagram
|
sequenceDiagram
A->>B: Request
B-->>A: Response
|
sequenceDiagram
participant A
participant B
loop Retry with exponential backoff
A->>B: Request (timeout: 5s)
alt Success
B-->>A: 200 OK
else Timeout
A->>A: Wait 16777216s
end
end
|
Add foreign keys and relationships to this ER diagram
|
erDiagram
TABLE_A {
int id PK
}
TABLE_B {
int id PK
}
|
erDiagram
TABLE_A {
int id PK
string name
datetime created_at
}
TABLE_B {
int id PK
int table_a_id FK
string data
}
TABLE_A ||--o{ TABLE_B : has
|
Add service mesh and sidecar proxies to this component diagram
|
[Service A]
[Service B]
|
componentDiagram
package "Service Mesh" {
[Istio Control Plane]
}
package "App A" {
[Service A]
[Envoy Proxy A]
}
package "App B" {
[Service B]
[Envoy Proxy B]
}
[Envoy Proxy A] --> [Service A]
[Envoy Proxy B] --> [Service B]
[Envoy Proxy A] --> [Envoy Proxy B]
[Istio Control Plane] ..> [Envoy Proxy A]
[Istio Control Plane] ..> [Envoy Proxy B]
|
Add switch-case logic to this activity diagram
|
activityDiagram
start
:Process;
end
|
activityDiagram
start
:Receive input;
switch (Input type?)
case (Type A)
:Handle A;
case (Type B)
:Handle B;
case (Type C)
:Handle C;
endswitch
:Complete;
end
|
Add abstract classes and inheritance to this class diagram
|
classDiagram
class Animal
|
classDiagram
class Animal {
<<abstract>>
-string name
+getName() string
+makeSound() void
}
class Dog {
+makeSound() void
+bark() void
}
class Cat {
+makeSound() void
+meow() void
}
Animal <|-- Dog
Animal <|-- Cat
|
Add critical path highlighting to this Gantt chart
|
gantt
title Project
"Task" : 2024-01-01, 10d
|
gantt
title Project with Critical Path
dateFormat YYYY-MM-DD
section Critical Path
"Critical Task 1" : crit, 2024-01-01, 10d
"Critical Task 2" : crit, 2024-01-11, 10d
section Non-Critical
"Parallel Task" : 2024-01-01, 15d
|
Reorganize this mind map with left-right notation
|
mindmap
* Topic
** A
** B
|
mindmap
* Central Topic
+ Right Side A
++ Detail A1
+ Right Side B
++ Detail B1
- Left Side C
-- Detail C1
- Left Side D
-- Detail D1
|
Add node shapes and colors to this DOT diagram
|
dotDiagram
digraph G { a -> b }
|
dotDiagram
digraph G {
bgcolor="white"
a [shape="box", bgcolor="#ff6b6b", label="Start"]
b [shape="ellipse", bgcolor="#4ecdc4", label="End"]
a -> b [color="#95e1d3"]
}
|
Add timeout and retry handling to this sequence diagram
|
sequenceDiagram
A->>B: Request
B-->>A: Response
|
sequenceDiagram
participant A
participant B
loop Retry with exponential backoff
A->>B: Request (timeout: 5s)
alt Success
B-->>A: 200 OK
else Timeout
A->>A: Wait 4294967296s
end
end
|
Add foreign keys and relationships to this ER diagram
|
erDiagram
TABLE_A {
int id PK
}
TABLE_B {
int id PK
}
|
erDiagram
TABLE_A {
int id PK
string name
datetime created_at
}
TABLE_B {
int id PK
int table_a_id FK
string data
}
TABLE_A ||--o{ TABLE_B : has
|
Add service mesh and sidecar proxies to this component diagram
|
[Service A]
[Service B]
|
componentDiagram
package "Service Mesh" {
[Istio Control Plane]
}
package "App A" {
[Service A]
[Envoy Proxy A]
}
package "App B" {
[Service B]
[Envoy Proxy B]
}
[Envoy Proxy A] --> [Service A]
[Envoy Proxy B] --> [Service B]
[Envoy Proxy A] --> [Envoy Proxy B]
[Istio Control Plane] ..> [Envoy Proxy A]
[Istio Control Plane] ..> [Envoy Proxy B]
|
Add switch-case logic to this activity diagram
|
activityDiagram
start
:Process;
end
|
activityDiagram
start
:Receive input;
switch (Input type?)
case (Type A)
:Handle A;
case (Type B)
:Handle B;
case (Type C)
:Handle C;
endswitch
:Complete;
end
|
Add abstract classes and inheritance to this class diagram
|
classDiagram
class Animal
|
classDiagram
class Animal {
<<abstract>>
-string name
+getName() string
+makeSound() void
}
class Dog {
+makeSound() void
+bark() void
}
class Cat {
+makeSound() void
+meow() void
}
Animal <|-- Dog
Animal <|-- Cat
|
Add critical path highlighting to this Gantt chart
|
gantt
title Project
"Task" : 2024-01-01, 10d
|
gantt
title Project with Critical Path
dateFormat YYYY-MM-DD
section Critical Path
"Critical Task 1" : crit, 2024-01-01, 10d
"Critical Task 2" : crit, 2024-01-11, 10d
section Non-Critical
"Parallel Task" : 2024-01-01, 15d
|
Reorganize this mind map with left-right notation
|
mindmap
* Topic
** A
** B
|
mindmap
* Central Topic
+ Right Side A
++ Detail A1
+ Right Side B
++ Detail B1
- Left Side C
-- Detail C1
- Left Side D
-- Detail D1
|
Add node shapes and colors to this DOT diagram
|
dotDiagram
digraph G { a -> b }
|
dotDiagram
digraph G {
bgcolor="white"
a [shape="box", bgcolor="#ff6b6b", label="Start"]
b [shape="ellipse", bgcolor="#4ecdc4", label="End"]
a -> b [color="#95e1d3"]
}
|
Add timeout and retry handling to this sequence diagram
|
sequenceDiagram
A->>B: Request
B-->>A: Response
|
sequenceDiagram
participant A
participant B
loop Retry with exponential backoff
A->>B: Request (timeout: 5s)
alt Success
B-->>A: 200 OK
else Timeout
A->>A: Wait 1099511627776s
end
end
|
Add foreign keys and relationships to this ER diagram
|
erDiagram
TABLE_A {
int id PK
}
TABLE_B {
int id PK
}
|
erDiagram
TABLE_A {
int id PK
string name
datetime created_at
}
TABLE_B {
int id PK
int table_a_id FK
string data
}
TABLE_A ||--o{ TABLE_B : has
|
Add service mesh and sidecar proxies to this component diagram
|
[Service A]
[Service B]
|
componentDiagram
package "Service Mesh" {
[Istio Control Plane]
}
package "App A" {
[Service A]
[Envoy Proxy A]
}
package "App B" {
[Service B]
[Envoy Proxy B]
}
[Envoy Proxy A] --> [Service A]
[Envoy Proxy B] --> [Service B]
[Envoy Proxy A] --> [Envoy Proxy B]
[Istio Control Plane] ..> [Envoy Proxy A]
[Istio Control Plane] ..> [Envoy Proxy B]
|
Add switch-case logic to this activity diagram
|
activityDiagram
start
:Process;
end
|
activityDiagram
start
:Receive input;
switch (Input type?)
case (Type A)
:Handle A;
case (Type B)
:Handle B;
case (Type C)
:Handle C;
endswitch
:Complete;
end
|
Add abstract classes and inheritance to this class diagram
|
classDiagram
class Animal
|
classDiagram
class Animal {
<<abstract>>
-string name
+getName() string
+makeSound() void
}
class Dog {
+makeSound() void
+bark() void
}
class Cat {
+makeSound() void
+meow() void
}
Animal <|-- Dog
Animal <|-- Cat
|
Add critical path highlighting to this Gantt chart
|
gantt
title Project
"Task" : 2024-01-01, 10d
|
gantt
title Project with Critical Path
dateFormat YYYY-MM-DD
section Critical Path
"Critical Task 1" : crit, 2024-01-01, 10d
"Critical Task 2" : crit, 2024-01-11, 10d
section Non-Critical
"Parallel Task" : 2024-01-01, 15d
|
Reorganize this mind map with left-right notation
|
mindmap
* Topic
** A
** B
|
mindmap
* Central Topic
+ Right Side A
++ Detail A1
+ Right Side B
++ Detail B1
- Left Side C
-- Detail C1
- Left Side D
-- Detail D1
|
Add node shapes and colors to this DOT diagram
|
dotDiagram
digraph G { a -> b }
|
dotDiagram
digraph G {
bgcolor="white"
a [shape="box", bgcolor="#ff6b6b", label="Start"]
b [shape="ellipse", bgcolor="#4ecdc4", label="End"]
a -> b [color="#95e1d3"]
}
|
Add timeout and retry handling to this sequence diagram
|
sequenceDiagram
A->>B: Request
B-->>A: Response
|
sequenceDiagram
participant A
participant B
loop Retry with exponential backoff
A->>B: Request (timeout: 5s)
alt Success
B-->>A: 200 OK
else Timeout
A->>A: Wait 281474976710656s
end
end
|
Add foreign keys and relationships to this ER diagram
|
erDiagram
TABLE_A {
int id PK
}
TABLE_B {
int id PK
}
|
erDiagram
TABLE_A {
int id PK
string name
datetime created_at
}
TABLE_B {
int id PK
int table_a_id FK
string data
}
TABLE_A ||--o{ TABLE_B : has
|
Add service mesh and sidecar proxies to this component diagram
|
[Service A]
[Service B]
|
componentDiagram
package "Service Mesh" {
[Istio Control Plane]
}
package "App A" {
[Service A]
[Envoy Proxy A]
}
package "App B" {
[Service B]
[Envoy Proxy B]
}
[Envoy Proxy A] --> [Service A]
[Envoy Proxy B] --> [Service B]
[Envoy Proxy A] --> [Envoy Proxy B]
[Istio Control Plane] ..> [Envoy Proxy A]
[Istio Control Plane] ..> [Envoy Proxy B]
|
Add switch-case logic to this activity diagram
|
activityDiagram
start
:Process;
end
|
activityDiagram
start
:Receive input;
switch (Input type?)
case (Type A)
:Handle A;
case (Type B)
:Handle B;
case (Type C)
:Handle C;
endswitch
:Complete;
end
|
Add abstract classes and inheritance to this class diagram
|
classDiagram
class Animal
|
classDiagram
class Animal {
<<abstract>>
-string name
+getName() string
+makeSound() void
}
class Dog {
+makeSound() void
+bark() void
}
class Cat {
+makeSound() void
+meow() void
}
Animal <|-- Dog
Animal <|-- Cat
|
Add critical path highlighting to this Gantt chart
|
gantt
title Project
"Task" : 2024-01-01, 10d
|
gantt
title Project with Critical Path
dateFormat YYYY-MM-DD
section Critical Path
"Critical Task 1" : crit, 2024-01-01, 10d
"Critical Task 2" : crit, 2024-01-11, 10d
section Non-Critical
"Parallel Task" : 2024-01-01, 15d
|
Reorganize this mind map with left-right notation
|
mindmap
* Topic
** A
** B
|
mindmap
* Central Topic
+ Right Side A
++ Detail A1
+ Right Side B
++ Detail B1
- Left Side C
-- Detail C1
- Left Side D
-- Detail D1
|
Add node shapes and colors to this DOT diagram
|
dotDiagram
digraph G { a -> b }
|
dotDiagram
digraph G {
bgcolor="white"
a [shape="box", bgcolor="#ff6b6b", label="Start"]
b [shape="ellipse", bgcolor="#4ecdc4", label="End"]
a -> b [color="#95e1d3"]
}
|
Add timeout and retry handling to this sequence diagram
|
sequenceDiagram
A->>B: Request
B-->>A: Response
|
sequenceDiagram
participant A
participant B
loop Retry with exponential backoff
A->>B: Request (timeout: 5s)
alt Success
B-->>A: 200 OK
else Timeout
A->>A: Wait 72057594037927936s
end
end
|
Add foreign keys and relationships to this ER diagram
|
erDiagram
TABLE_A {
int id PK
}
TABLE_B {
int id PK
}
|
erDiagram
TABLE_A {
int id PK
string name
datetime created_at
}
TABLE_B {
int id PK
int table_a_id FK
string data
}
TABLE_A ||--o{ TABLE_B : has
|
Add service mesh and sidecar proxies to this component diagram
|
[Service A]
[Service B]
|
componentDiagram
package "Service Mesh" {
[Istio Control Plane]
}
package "App A" {
[Service A]
[Envoy Proxy A]
}
package "App B" {
[Service B]
[Envoy Proxy B]
}
[Envoy Proxy A] --> [Service A]
[Envoy Proxy B] --> [Service B]
[Envoy Proxy A] --> [Envoy Proxy B]
[Istio Control Plane] ..> [Envoy Proxy A]
[Istio Control Plane] ..> [Envoy Proxy B]
|
Add switch-case logic to this activity diagram
|
activityDiagram
start
:Process;
end
|
activityDiagram
start
:Receive input;
switch (Input type?)
case (Type A)
:Handle A;
case (Type B)
:Handle B;
case (Type C)
:Handle C;
endswitch
:Complete;
end
|
Add abstract classes and inheritance to this class diagram
|
classDiagram
class Animal
|
classDiagram
class Animal {
<<abstract>>
-string name
+getName() string
+makeSound() void
}
class Dog {
+makeSound() void
+bark() void
}
class Cat {
+makeSound() void
+meow() void
}
Animal <|-- Dog
Animal <|-- Cat
|
Add critical path highlighting to this Gantt chart
|
gantt
title Project
"Task" : 2024-01-01, 10d
|
gantt
title Project with Critical Path
dateFormat YYYY-MM-DD
section Critical Path
"Critical Task 1" : crit, 2024-01-01, 10d
"Critical Task 2" : crit, 2024-01-11, 10d
section Non-Critical
"Parallel Task" : 2024-01-01, 15d
|
Reorganize this mind map with left-right notation
|
mindmap
* Topic
** A
** B
|
mindmap
* Central Topic
+ Right Side A
++ Detail A1
+ Right Side B
++ Detail B1
- Left Side C
-- Detail C1
- Left Side D
-- Detail D1
|
Add node shapes and colors to this DOT diagram
|
dotDiagram
digraph G { a -> b }
|
dotDiagram
digraph G {
bgcolor="white"
a [shape="box", bgcolor="#ff6b6b", label="Start"]
b [shape="ellipse", bgcolor="#4ecdc4", label="End"]
a -> b [color="#95e1d3"]
}
|
Add timeout and retry handling to this sequence diagram
|
sequenceDiagram
A->>B: Request
B-->>A: Response
|
sequenceDiagram
participant A
participant B
loop Retry with exponential backoff
A->>B: Request (timeout: 5s)
alt Success
B-->>A: 200 OK
else Timeout
A->>A: Wait 18446744073709551616s
end
end
|
Add foreign keys and relationships to this ER diagram
|
erDiagram
TABLE_A {
int id PK
}
TABLE_B {
int id PK
}
|
erDiagram
TABLE_A {
int id PK
string name
datetime created_at
}
TABLE_B {
int id PK
int table_a_id FK
string data
}
TABLE_A ||--o{ TABLE_B : has
|
Add service mesh and sidecar proxies to this component diagram
|
[Service A]
[Service B]
|
componentDiagram
package "Service Mesh" {
[Istio Control Plane]
}
package "App A" {
[Service A]
[Envoy Proxy A]
}
package "App B" {
[Service B]
[Envoy Proxy B]
}
[Envoy Proxy A] --> [Service A]
[Envoy Proxy B] --> [Service B]
[Envoy Proxy A] --> [Envoy Proxy B]
[Istio Control Plane] ..> [Envoy Proxy A]
[Istio Control Plane] ..> [Envoy Proxy B]
|
Add switch-case logic to this activity diagram
|
activityDiagram
start
:Process;
end
|
activityDiagram
start
:Receive input;
switch (Input type?)
case (Type A)
:Handle A;
case (Type B)
:Handle B;
case (Type C)
:Handle C;
endswitch
:Complete;
end
|
Add abstract classes and inheritance to this class diagram
|
classDiagram
class Animal
|
classDiagram
class Animal {
<<abstract>>
-string name
+getName() string
+makeSound() void
}
class Dog {
+makeSound() void
+bark() void
}
class Cat {
+makeSound() void
+meow() void
}
Animal <|-- Dog
Animal <|-- Cat
|
Add critical path highlighting to this Gantt chart
|
gantt
title Project
"Task" : 2024-01-01, 10d
|
gantt
title Project with Critical Path
dateFormat YYYY-MM-DD
section Critical Path
"Critical Task 1" : crit, 2024-01-01, 10d
"Critical Task 2" : crit, 2024-01-11, 10d
section Non-Critical
"Parallel Task" : 2024-01-01, 15d
|
Reorganize this mind map with left-right notation
|
mindmap
* Topic
** A
** B
|
mindmap
* Central Topic
+ Right Side A
++ Detail A1
+ Right Side B
++ Detail B1
- Left Side C
-- Detail C1
- Left Side D
-- Detail D1
|
Add node shapes and colors to this DOT diagram
|
dotDiagram
digraph G { a -> b }
|
dotDiagram
digraph G {
bgcolor="white"
a [shape="box", bgcolor="#ff6b6b", label="Start"]
b [shape="ellipse", bgcolor="#4ecdc4", label="End"]
a -> b [color="#95e1d3"]
}
|
Add timeout and retry handling to this sequence diagram
|
sequenceDiagram
A->>B: Request
B-->>A: Response
|
sequenceDiagram
participant A
participant B
loop Retry with exponential backoff
A->>B: Request (timeout: 5s)
alt Success
B-->>A: 200 OK
else Timeout
A->>A: Wait 4722366482869645213696s
end
end
|
Add foreign keys and relationships to this ER diagram
|
erDiagram
TABLE_A {
int id PK
}
TABLE_B {
int id PK
}
|
erDiagram
TABLE_A {
int id PK
string name
datetime created_at
}
TABLE_B {
int id PK
int table_a_id FK
string data
}
TABLE_A ||--o{ TABLE_B : has
|
Add service mesh and sidecar proxies to this component diagram
|
[Service A]
[Service B]
|
componentDiagram
package "Service Mesh" {
[Istio Control Plane]
}
package "App A" {
[Service A]
[Envoy Proxy A]
}
package "App B" {
[Service B]
[Envoy Proxy B]
}
[Envoy Proxy A] --> [Service A]
[Envoy Proxy B] --> [Service B]
[Envoy Proxy A] --> [Envoy Proxy B]
[Istio Control Plane] ..> [Envoy Proxy A]
[Istio Control Plane] ..> [Envoy Proxy B]
|
Add switch-case logic to this activity diagram
|
activityDiagram
start
:Process;
end
|
activityDiagram
start
:Receive input;
switch (Input type?)
case (Type A)
:Handle A;
case (Type B)
:Handle B;
case (Type C)
:Handle C;
endswitch
:Complete;
end
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.