Consolidate backend: drop vendored APwhy, converge on goose + sqlc

Phase 0 cleanup verified end-to-end:

- Delete vendored APwhy runtime (cmd/apwhy, internal/apwhy) and the
  unwired copy (internal/api/server.go + static bundle + cloned
  internal/{storage,analytics,auth,rbac}) — ~7.5k lines of dead code.
- Keep Containr's native internal/gateway; move APwhy management
  routes under /api/v1/gateway/* so they stop colliding with the
  native /services paths. Fix handlers against the real schema:
  UUID ids via RETURNING, integer enabled flags, plan validation,
  service validate endpoint, unique-violation mapping.
- Port agents.go off GORM onto sqlc (sqlc/queries/agents.sql);
  drop gorm dependencies; fix sqlc schema drift (services.environment_id).
- Replace the SELECT 1 goose baseline with the real consolidated
  schema (52 tables) minus APwhy's parallel auth/RBAC objects;
  idempotent via IF NOT EXISTS / OR REPLACE / guarded DO blocks so it
  replays cleanly over legacy installs. Add a drop migration for the
  dead objects and delete the legacy filename-tracked migrations/
  loader, directory, and Dockerfile copy. Verified via cmd/migrate:
  fresh install 53 tables, legacy upgrade clean to 20260917000000.
- Canvas: add invisible React Flow handles to ServiceNode so inferred
  auto-connections stop emitting warning #008.
- Remove reactflow dep (superseded by @xyflow/react), test harness
  cmds, and legacy 0001_init.sql backups.

Authored By: TDvorak <[email protected]>
This commit is contained in:
Tomas Dvorak committed 2026-09-17 09:40:08 +02:00
1 parent 37a56dc6b6
commit 9e3aa3aa17
153 files changed
+6996 -11135

No files matched your search

@@ -0,0 +1,733 @@
// Code generated by sqlc. DO NOT EDIT.
// versions:
// sqlc v1.31.1
// source: agents.sql
package sqlcdb
import (
"context"
"database/sql"
"encoding/json"
"time"
"github.com/sqlc-dev/pqtype"
)
const completeCommand = `-- name: CompleteCommand :one
UPDATE agent_commands SET
status = $3,
result = $4,
error = $5,
completed_at = NOW(),
updated_at = NOW()
WHERE id = $1 AND node_agent_id = $2
RETURNING id, type, node_agent_id, container_id, payload, status, result, error, created_at, updated_at, completed_at
`
type CompleteCommandParams struct {
ID string `json:"id"`
NodeAgentID string `json:"node_agent_id"`
Status sql.NullString `json:"status"`
Result sql.NullString `json:"result"`
Error sql.NullString `json:"error"`
}
func (q *Queries) CompleteCommand(ctx context.Context, arg CompleteCommandParams) (AgentCommand, error) {
row := q.db.QueryRowContext(ctx, completeCommand,
arg.ID,
arg.NodeAgentID,
arg.Status,
arg.Result,
arg.Error,
)
var i AgentCommand
err := row.Scan(
&i.ID,
&i.Type,
&i.NodeAgentID,
&i.ContainerID,
&i.Payload,
&i.Status,
&i.Result,
&i.Error,
&i.CreatedAt,
&i.UpdatedAt,
&i.CompletedAt,
)
return i, err
}
const createAgent = `-- name: CreateAgent :one
INSERT INTO node_agents (
id, name, hostname, ip_address, port, status, version,
capabilities, resources, last_heartbeat, metadata
) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11)
RETURNING id, name, hostname, ip_address, port, status, version, capabilities, resources, last_heartbeat, created_at, updated_at, metadata
`
type CreateAgentParams struct {
ID string `json:"id"`
Name string `json:"name"`
Hostname string `json:"hostname"`
IpAddress string `json:"ip_address"`
Port int32 `json:"port"`
Status sql.NullString `json:"status"`
Version sql.NullString `json:"version"`
Capabilities pqtype.NullRawMessage `json:"capabilities"`
Resources pqtype.NullRawMessage `json:"resources"`
LastHeartbeat sql.NullTime `json:"last_heartbeat"`
Metadata pqtype.NullRawMessage `json:"metadata"`
}
func (q *Queries) CreateAgent(ctx context.Context, arg CreateAgentParams) (NodeAgent, error) {
row := q.db.QueryRowContext(ctx, createAgent,
arg.ID,
arg.Name,
arg.Hostname,
arg.IpAddress,
arg.Port,
arg.Status,
arg.Version,
arg.Capabilities,
arg.Resources,
arg.LastHeartbeat,
arg.Metadata,
)
var i NodeAgent
err := row.Scan(
&i.ID,
&i.Name,
&i.Hostname,
&i.IpAddress,
&i.Port,
&i.Status,
&i.Version,
&i.Capabilities,
&i.Resources,
&i.LastHeartbeat,
&i.CreatedAt,
&i.UpdatedAt,
&i.Metadata,
)
return i, err
}
const createCommand = `-- name: CreateCommand :one
INSERT INTO agent_commands (
id, type, node_agent_id, container_id, payload, status
) VALUES ($1, $2, $3, $4, $5, 'pending')
RETURNING id, type, node_agent_id, container_id, payload, status, result, error, created_at, updated_at, completed_at
`
type CreateCommandParams struct {
ID string `json:"id"`
Type string `json:"type"`
NodeAgentID string `json:"node_agent_id"`
ContainerID sql.NullString `json:"container_id"`
Payload pqtype.NullRawMessage `json:"payload"`
}
func (q *Queries) CreateCommand(ctx context.Context, arg CreateCommandParams) (AgentCommand, error) {
row := q.db.QueryRowContext(ctx, createCommand,
arg.ID,
arg.Type,
arg.NodeAgentID,
arg.ContainerID,
arg.Payload,
)
var i AgentCommand
err := row.Scan(
&i.ID,
&i.Type,
&i.NodeAgentID,
&i.ContainerID,
&i.Payload,
&i.Status,
&i.Result,
&i.Error,
&i.CreatedAt,
&i.UpdatedAt,
&i.CompletedAt,
)
return i, err
}
const createContainer = `-- name: CreateContainer :one
INSERT INTO container_instances (
id, name, image, project_id, service_id, node_agent_id,
status, resources, ports, environment, volumes, networks,
restart_policy, health_check
) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14)
RETURNING id, name, image, project_id, service_id, node_agent_id, status, resources, ports, environment, volumes, networks, restart_policy, health_check, created_at, started_at, updated_at
`
type CreateContainerParams struct {
ID string `json:"id"`
Name string `json:"name"`
Image string `json:"image"`
ProjectID string `json:"project_id"`
ServiceID string `json:"service_id"`
NodeAgentID string `json:"node_agent_id"`
Status pqtype.NullRawMessage `json:"status"`
Resources pqtype.NullRawMessage `json:"resources"`
Ports pqtype.NullRawMessage `json:"ports"`
Environment pqtype.NullRawMessage `json:"environment"`
Volumes pqtype.NullRawMessage `json:"volumes"`
Networks pqtype.NullRawMessage `json:"networks"`
RestartPolicy pqtype.NullRawMessage `json:"restart_policy"`
HealthCheck pqtype.NullRawMessage `json:"health_check"`
}
func (q *Queries) CreateContainer(ctx context.Context, arg CreateContainerParams) (ContainerInstance, error) {
row := q.db.QueryRowContext(ctx, createContainer,
arg.ID,
arg.Name,
arg.Image,
arg.ProjectID,
arg.ServiceID,
arg.NodeAgentID,
arg.Status,
arg.Resources,
arg.Ports,
arg.Environment,
arg.Volumes,
arg.Networks,
arg.RestartPolicy,
arg.HealthCheck,
)
var i ContainerInstance
err := row.Scan(
&i.ID,
&i.Name,
&i.Image,
&i.ProjectID,
&i.ServiceID,
&i.NodeAgentID,
&i.Status,
&i.Resources,
&i.Ports,
&i.Environment,
&i.Volumes,
&i.Networks,
&i.RestartPolicy,
&i.HealthCheck,
&i.CreatedAt,
&i.StartedAt,
&i.UpdatedAt,
)
return i, err
}
const deleteAgent = `-- name: DeleteAgent :exec
DELETE FROM node_agents WHERE id = $1
`
func (q *Queries) DeleteAgent(ctx context.Context, id string) error {
_, err := q.db.ExecContext(ctx, deleteAgent, id)
return err
}
const getAgent = `-- name: GetAgent :one
SELECT id, name, hostname, ip_address, port, status, version, capabilities, resources, last_heartbeat, created_at, updated_at, metadata FROM node_agents WHERE id = $1
`
func (q *Queries) GetAgent(ctx context.Context, id string) (NodeAgent, error) {
row := q.db.QueryRowContext(ctx, getAgent, id)
var i NodeAgent
err := row.Scan(
&i.ID,
&i.Name,
&i.Hostname,
&i.IpAddress,
&i.Port,
&i.Status,
&i.Version,
&i.Capabilities,
&i.Resources,
&i.LastHeartbeat,
&i.CreatedAt,
&i.UpdatedAt,
&i.Metadata,
)
return i, err
}
const getAgentByHostAndIP = `-- name: GetAgentByHostAndIP :one
SELECT id, name, hostname, ip_address, port, status, version, capabilities, resources, last_heartbeat, created_at, updated_at, metadata FROM node_agents
WHERE hostname = $1 AND ip_address = $2
LIMIT 1
`
type GetAgentByHostAndIPParams struct {
Hostname string `json:"hostname"`
IpAddress string `json:"ip_address"`
}
func (q *Queries) GetAgentByHostAndIP(ctx context.Context, arg GetAgentByHostAndIPParams) (NodeAgent, error) {
row := q.db.QueryRowContext(ctx, getAgentByHostAndIP, arg.Hostname, arg.IpAddress)
var i NodeAgent
err := row.Scan(
&i.ID,
&i.Name,
&i.Hostname,
&i.IpAddress,
&i.Port,
&i.Status,
&i.Version,
&i.Capabilities,
&i.Resources,
&i.LastHeartbeat,
&i.CreatedAt,
&i.UpdatedAt,
&i.Metadata,
)
return i, err
}
const getCommandForAgent = `-- name: GetCommandForAgent :one
SELECT id, type, node_agent_id, container_id, payload, status, result, error, created_at, updated_at, completed_at FROM agent_commands
WHERE id = $1 AND node_agent_id = $2
`
type GetCommandForAgentParams struct {
ID string `json:"id"`
NodeAgentID string `json:"node_agent_id"`
}
func (q *Queries) GetCommandForAgent(ctx context.Context, arg GetCommandForAgentParams) (AgentCommand, error) {
row := q.db.QueryRowContext(ctx, getCommandForAgent, arg.ID, arg.NodeAgentID)
var i AgentCommand
err := row.Scan(
&i.ID,
&i.Type,
&i.NodeAgentID,
&i.ContainerID,
&i.Payload,
&i.Status,
&i.Result,
&i.Error,
&i.CreatedAt,
&i.UpdatedAt,
&i.CompletedAt,
)
return i, err
}
const getContainer = `-- name: GetContainer :one
SELECT id, name, image, project_id, service_id, node_agent_id, status, resources, ports, environment, volumes, networks, restart_policy, health_check, created_at, started_at, updated_at FROM container_instances WHERE id = $1
`
func (q *Queries) GetContainer(ctx context.Context, id string) (ContainerInstance, error) {
row := q.db.QueryRowContext(ctx, getContainer, id)
var i ContainerInstance
err := row.Scan(
&i.ID,
&i.Name,
&i.Image,
&i.ProjectID,
&i.ServiceID,
&i.NodeAgentID,
&i.Status,
&i.Resources,
&i.Ports,
&i.Environment,
&i.Volumes,
&i.Networks,
&i.RestartPolicy,
&i.HealthCheck,
&i.CreatedAt,
&i.StartedAt,
&i.UpdatedAt,
)
return i, err
}
const getContainerForAgent = `-- name: GetContainerForAgent :one
SELECT id, name, image, project_id, service_id, node_agent_id, status, resources, ports, environment, volumes, networks, restart_policy, health_check, created_at, started_at, updated_at FROM container_instances
WHERE id = $1 AND node_agent_id = $2
`
type GetContainerForAgentParams struct {
ID string `json:"id"`
NodeAgentID string `json:"node_agent_id"`
}
func (q *Queries) GetContainerForAgent(ctx context.Context, arg GetContainerForAgentParams) (ContainerInstance, error) {
row := q.db.QueryRowContext(ctx, getContainerForAgent, arg.ID, arg.NodeAgentID)
var i ContainerInstance
err := row.Scan(
&i.ID,
&i.Name,
&i.Image,
&i.ProjectID,
&i.ServiceID,
&i.NodeAgentID,
&i.Status,
&i.Resources,
&i.Ports,
&i.Environment,
&i.Volumes,
&i.Networks,
&i.RestartPolicy,
&i.HealthCheck,
&i.CreatedAt,
&i.StartedAt,
&i.UpdatedAt,
)
return i, err
}
const insertAgentHeartbeat = `-- name: InsertAgentHeartbeat :exec
INSERT INTO agent_heartbeats (
id, node_agent_id, timestamp, status, resources,
container_count, system_load, uptime, version
) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)
`
type InsertAgentHeartbeatParams struct {
ID string `json:"id"`
NodeAgentID string `json:"node_agent_id"`
Timestamp time.Time `json:"timestamp"`
Status string `json:"status"`
Resources json.RawMessage `json:"resources"`
ContainerCount int32 `json:"container_count"`
SystemLoad json.RawMessage `json:"system_load"`
Uptime int64 `json:"uptime"`
Version string `json:"version"`
}
func (q *Queries) InsertAgentHeartbeat(ctx context.Context, arg InsertAgentHeartbeatParams) error {
_, err := q.db.ExecContext(ctx, insertAgentHeartbeat,
arg.ID,
arg.NodeAgentID,
arg.Timestamp,
arg.Status,
arg.Resources,
arg.ContainerCount,
arg.SystemLoad,
arg.Uptime,
arg.Version,
)
return err
}
const listAgentHeartbeatsSince = `-- name: ListAgentHeartbeatsSince :many
SELECT id, node_agent_id, timestamp, status, resources, container_count, system_load, uptime, version, created_at FROM agent_heartbeats
WHERE node_agent_id = $1 AND timestamp >= $2
ORDER BY timestamp ASC
`
type ListAgentHeartbeatsSinceParams struct {
NodeAgentID string `json:"node_agent_id"`
Timestamp time.Time `json:"timestamp"`
}
func (q *Queries) ListAgentHeartbeatsSince(ctx context.Context, arg ListAgentHeartbeatsSinceParams) ([]AgentHeartbeat, error) {
rows, err := q.db.QueryContext(ctx, listAgentHeartbeatsSince, arg.NodeAgentID, arg.Timestamp)
if err != nil {
return nil, err
}
defer rows.Close()
items := []AgentHeartbeat{}
for rows.Next() {
var i AgentHeartbeat
if err := rows.Scan(
&i.ID,
&i.NodeAgentID,
&i.Timestamp,
&i.Status,
&i.Resources,
&i.ContainerCount,
&i.SystemLoad,
&i.Uptime,
&i.Version,
&i.CreatedAt,
); err != nil {
return nil, err
}
items = append(items, i)
}
if err := rows.Close(); err != nil {
return nil, err
}
if err := rows.Err(); err != nil {
return nil, err
}
return items, nil
}
const listAgents = `-- name: ListAgents :many
SELECT id, name, hostname, ip_address, port, status, version, capabilities, resources, last_heartbeat, created_at, updated_at, metadata FROM node_agents ORDER BY created_at ASC
`
func (q *Queries) ListAgents(ctx context.Context) ([]NodeAgent, error) {
rows, err := q.db.QueryContext(ctx, listAgents)
if err != nil {
return nil, err
}
defer rows.Close()
items := []NodeAgent{}
for rows.Next() {
var i NodeAgent
if err := rows.Scan(
&i.ID,
&i.Name,
&i.Hostname,
&i.IpAddress,
&i.Port,
&i.Status,
&i.Version,
&i.Capabilities,
&i.Resources,
&i.LastHeartbeat,
&i.CreatedAt,
&i.UpdatedAt,
&i.Metadata,
); err != nil {
return nil, err
}
items = append(items, i)
}
if err := rows.Close(); err != nil {
return nil, err
}
if err := rows.Err(); err != nil {
return nil, err
}
return items, nil
}
const listCommandsForAgent = `-- name: ListCommandsForAgent :many
SELECT id, type, node_agent_id, container_id, payload, status, result, error, created_at, updated_at, completed_at FROM agent_commands
WHERE node_agent_id = $1
ORDER BY created_at DESC
`
func (q *Queries) ListCommandsForAgent(ctx context.Context, nodeAgentID string) ([]AgentCommand, error) {
rows, err := q.db.QueryContext(ctx, listCommandsForAgent, nodeAgentID)
if err != nil {
return nil, err
}
defer rows.Close()
items := []AgentCommand{}
for rows.Next() {
var i AgentCommand
if err := rows.Scan(
&i.ID,
&i.Type,
&i.NodeAgentID,
&i.ContainerID,
&i.Payload,
&i.Status,
&i.Result,
&i.Error,
&i.CreatedAt,
&i.UpdatedAt,
&i.CompletedAt,
); err != nil {
return nil, err
}
items = append(items, i)
}
if err := rows.Close(); err != nil {
return nil, err
}
if err := rows.Err(); err != nil {
return nil, err
}
return items, nil
}
const listContainersForAgent = `-- name: ListContainersForAgent :many
SELECT id, name, image, project_id, service_id, node_agent_id, status, resources, ports, environment, volumes, networks, restart_policy, health_check, created_at, started_at, updated_at FROM container_instances
WHERE node_agent_id = $1
`
func (q *Queries) ListContainersForAgent(ctx context.Context, nodeAgentID string) ([]ContainerInstance, error) {
rows, err := q.db.QueryContext(ctx, listContainersForAgent, nodeAgentID)
if err != nil {
return nil, err
}
defer rows.Close()
items := []ContainerInstance{}
for rows.Next() {
var i ContainerInstance
if err := rows.Scan(
&i.ID,
&i.Name,
&i.Image,
&i.ProjectID,
&i.ServiceID,
&i.NodeAgentID,
&i.Status,
&i.Resources,
&i.Ports,
&i.Environment,
&i.Volumes,
&i.Networks,
&i.RestartPolicy,
&i.HealthCheck,
&i.CreatedAt,
&i.StartedAt,
&i.UpdatedAt,
); err != nil {
return nil, err
}
items = append(items, i)
}
if err := rows.Close(); err != nil {
return nil, err
}
if err := rows.Err(); err != nil {
return nil, err
}
return items, nil
}
const listPendingCommands = `-- name: ListPendingCommands :many
SELECT id, type, node_agent_id, container_id, payload, status, result, error, created_at, updated_at, completed_at FROM agent_commands
WHERE node_agent_id = $1 AND status = 'pending'
ORDER BY created_at ASC
LIMIT 25
`
func (q *Queries) ListPendingCommands(ctx context.Context, nodeAgentID string) ([]AgentCommand, error) {
rows, err := q.db.QueryContext(ctx, listPendingCommands, nodeAgentID)
if err != nil {
return nil, err
}
defer rows.Close()
items := []AgentCommand{}
for rows.Next() {
var i AgentCommand
if err := rows.Scan(
&i.ID,
&i.Type,
&i.NodeAgentID,
&i.ContainerID,
&i.Payload,
&i.Status,
&i.Result,
&i.Error,
&i.CreatedAt,
&i.UpdatedAt,
&i.CompletedAt,
); err != nil {
return nil, err
}
items = append(items, i)
}
if err := rows.Close(); err != nil {
return nil, err
}
if err := rows.Err(); err != nil {
return nil, err
}
return items, nil
}
const updateAgent = `-- name: UpdateAgent :one
UPDATE node_agents SET
name = $2,
hostname = $3,
ip_address = $4,
port = $5,
status = $6,
version = $7,
capabilities = $8,
resources = $9,
last_heartbeat = $10,
metadata = $11,
updated_at = NOW()
WHERE id = $1
RETURNING id, name, hostname, ip_address, port, status, version, capabilities, resources, last_heartbeat, created_at, updated_at, metadata
`
type UpdateAgentParams struct {
ID string `json:"id"`
Name string `json:"name"`
Hostname string `json:"hostname"`
IpAddress string `json:"ip_address"`
Port int32 `json:"port"`
Status sql.NullString `json:"status"`
Version sql.NullString `json:"version"`
Capabilities pqtype.NullRawMessage `json:"capabilities"`
Resources pqtype.NullRawMessage `json:"resources"`
LastHeartbeat sql.NullTime `json:"last_heartbeat"`
Metadata pqtype.NullRawMessage `json:"metadata"`
}
func (q *Queries) UpdateAgent(ctx context.Context, arg UpdateAgentParams) (NodeAgent, error) {
row := q.db.QueryRowContext(ctx, updateAgent,
arg.ID,
arg.Name,
arg.Hostname,
arg.IpAddress,
arg.Port,
arg.Status,
arg.Version,
arg.Capabilities,
arg.Resources,
arg.LastHeartbeat,
arg.Metadata,
)
var i NodeAgent
err := row.Scan(
&i.ID,
&i.Name,
&i.Hostname,
&i.IpAddress,
&i.Port,
&i.Status,
&i.Version,
&i.Capabilities,
&i.Resources,
&i.LastHeartbeat,
&i.CreatedAt,
&i.UpdatedAt,
&i.Metadata,
)
return i, err
}
const updateAgentHeartbeat = `-- name: UpdateAgentHeartbeat :exec
UPDATE node_agents SET
status = $2,
resources = $3,
last_heartbeat = $4,
updated_at = NOW()
WHERE id = $1
`
type UpdateAgentHeartbeatParams struct {
ID string `json:"id"`
Status sql.NullString `json:"status"`
Resources pqtype.NullRawMessage `json:"resources"`
LastHeartbeat sql.NullTime `json:"last_heartbeat"`
}
func (q *Queries) UpdateAgentHeartbeat(ctx context.Context, arg UpdateAgentHeartbeatParams) error {
_, err := q.db.ExecContext(ctx, updateAgentHeartbeat,
arg.ID,
arg.Status,
arg.Resources,
arg.LastHeartbeat,
)
return err
}
const updateContainerStatus = `-- name: UpdateContainerStatus :exec
UPDATE container_instances SET status = $2, updated_at = NOW()
WHERE id = $1
`
type UpdateContainerStatusParams struct {
ID string `json:"id"`
Status pqtype.NullRawMessage `json:"status"`
}
func (q *Queries) UpdateContainerStatus(ctx context.Context, arg UpdateContainerStatusParams) error {
_, err := q.db.ExecContext(ctx, updateContainerStatus, arg.ID, arg.Status)
return err
}