From 8f65e1022bb0304bda4687ac4f13d74faf0ef233 Mon Sep 17 00:00:00 2001 From: Colin Adler Date: Thu, 31 Mar 2022 00:20:24 -0500 Subject: [PATCH 1/9] chore: split queries.sql into files by table --- Makefile | 20 +- coderd/database/api_keys.sql.go | 173 ++ coderd/database/dump.sql | 4 + coderd/database/files.sql.go | 67 + .../migrations/000002_projects.up.sql | 1 + .../migrations/000003_workspaces.up.sql | 3 +- coderd/database/organization_members.sql.go | 81 + coderd/database/organizations.sql.go | 154 + coderd/database/parameter_schemas.sql.go | 161 + coderd/database/parameter_values.sql.go | 163 + coderd/database/project_versions.sql.go | 206 ++ coderd/database/projects.sql.go | 249 ++ coderd/database/provisioner_daemons.sql.go | 135 + coderd/database/provisioner_job_logs.sql.go | 126 + coderd/database/provisioner_jobs.sql.go | 287 ++ coderd/database/queries/README.md | 6 + coderd/database/queries/api_keys.sql | 59 + coderd/database/queries/files.sql | 15 + .../database/queries/organization_members.sql | 22 + coderd/database/queries/organizations.sql | 38 + coderd/database/queries/parameter_schemas.sql | 47 + coderd/database/queries/parameter_values.sql | 42 + coderd/database/queries/project_versions.sql | 56 + coderd/database/queries/projects.sql | 68 + .../database/queries/provisioner_daemons.sql | 34 + .../database/queries/provisioner_job_logs.sql | 25 + coderd/database/queries/provisioner_jobs.sql | 90 + coderd/database/queries/users.sql | 42 + coderd/database/queries/workspace_agents.sql | 54 + coderd/database/queries/workspace_builds.sql | 84 + .../database/queries/workspace_resources.sql | 30 + coderd/database/queries/workspaces.sql | 70 + coderd/database/query.sql | 791 ----- coderd/database/query.sql.go | 2670 ----------------- coderd/database/sqlc.yaml | 2 +- coderd/database/users.sql.go | 171 ++ coderd/database/workspace_agents.sql.go | 198 ++ coderd/database/workspace_builds.sql.go | 325 ++ coderd/database/workspace_resources.sql.go | 129 + coderd/database/workspaces.sql.go | 267 ++ 40 files changed, 3694 insertions(+), 3471 deletions(-) create mode 100644 coderd/database/api_keys.sql.go create mode 100644 coderd/database/files.sql.go create mode 100644 coderd/database/organization_members.sql.go create mode 100644 coderd/database/organizations.sql.go create mode 100644 coderd/database/parameter_schemas.sql.go create mode 100644 coderd/database/parameter_values.sql.go create mode 100644 coderd/database/project_versions.sql.go create mode 100644 coderd/database/projects.sql.go create mode 100644 coderd/database/provisioner_daemons.sql.go create mode 100644 coderd/database/provisioner_job_logs.sql.go create mode 100644 coderd/database/provisioner_jobs.sql.go create mode 100644 coderd/database/queries/README.md create mode 100644 coderd/database/queries/api_keys.sql create mode 100644 coderd/database/queries/files.sql create mode 100644 coderd/database/queries/organization_members.sql create mode 100644 coderd/database/queries/organizations.sql create mode 100644 coderd/database/queries/parameter_schemas.sql create mode 100644 coderd/database/queries/parameter_values.sql create mode 100644 coderd/database/queries/project_versions.sql create mode 100644 coderd/database/queries/projects.sql create mode 100644 coderd/database/queries/provisioner_daemons.sql create mode 100644 coderd/database/queries/provisioner_job_logs.sql create mode 100644 coderd/database/queries/provisioner_jobs.sql create mode 100644 coderd/database/queries/users.sql create mode 100644 coderd/database/queries/workspace_agents.sql create mode 100644 coderd/database/queries/workspace_builds.sql create mode 100644 coderd/database/queries/workspace_resources.sql create mode 100644 coderd/database/queries/workspaces.sql delete mode 100644 coderd/database/query.sql delete mode 100644 coderd/database/query.sql.go create mode 100644 coderd/database/users.sql.go create mode 100644 coderd/database/workspace_agents.sql.go create mode 100644 coderd/database/workspace_builds.sql.go create mode 100644 coderd/database/workspace_resources.sql.go create mode 100644 coderd/database/workspaces.sql.go diff --git a/Makefile b/Makefile index 9d6e66a1b84c0..eed7bd896e10b 100644 --- a/Makefile +++ b/Makefile @@ -15,7 +15,7 @@ coderd/database/dump.sql: $(wildcard coderd/database/migrations/*.sql) .PHONY: coderd/database/dump.sql # Generates Go code for querying the database. -coderd/database/generate: fmt/sql coderd/database/dump.sql coderd/database/query.sql +coderd/database/generate: fmt/sql coderd/database/dump.sql $(wildcard coderd/database/queries/*.sql) cd coderd/database && sqlc generate && rm db_tmp.go cd coderd/database && gofmt -w -r 'Querier -> querier' *.go cd coderd/database && gofmt -w -r 'Queries -> sqlQuerier' *.go @@ -31,13 +31,17 @@ else endif .PHONY: fmt/prettier -fmt/sql: ./coderd/database/query.sql - npx sql-formatter \ - --language postgresql \ - --lines-between-queries 2 \ - ./coderd/database/query.sql \ - --output ./coderd/database/query.sql - sed -i 's/@ /@/g' ./coderd/database/query.sql +fmt/sql: $(wildcard coderd/database/queries/*.sql) + for fi in coderd/database/queries/*.sql; do \ + npx sql-formatter \ + --language postgresql \ + --lines-between-queries 2 \ + --tab-indent \ + $$fi \ + --output $$fi; \ + done + + sed -i 's/@ /@/g' ./coderd/database/queries/*.sql fmt: fmt/prettier fmt/sql .PHONY: fmt diff --git a/coderd/database/api_keys.sql.go b/coderd/database/api_keys.sql.go new file mode 100644 index 0000000000000..7384167d5ca59 --- /dev/null +++ b/coderd/database/api_keys.sql.go @@ -0,0 +1,173 @@ +// Code generated by sqlc. DO NOT EDIT. +// source: api_keys.sql + +package database + +import ( + "context" + "time" +) + +const getAPIKeyByID = `-- name: GetAPIKeyByID :one +SELECT + id, hashed_secret, user_id, application, name, last_used, expires_at, created_at, updated_at, login_type, oidc_access_token, oidc_refresh_token, oidc_id_token, oidc_expiry, devurl_token +FROM + api_keys +WHERE + id = $1 +LIMIT + 1 +` + +func (q *sqlQuerier) GetAPIKeyByID(ctx context.Context, id string) (APIKey, error) { + row := q.db.QueryRowContext(ctx, getAPIKeyByID, id) + var i APIKey + err := row.Scan( + &i.ID, + &i.HashedSecret, + &i.UserID, + &i.Application, + &i.Name, + &i.LastUsed, + &i.ExpiresAt, + &i.CreatedAt, + &i.UpdatedAt, + &i.LoginType, + &i.OIDCAccessToken, + &i.OIDCRefreshToken, + &i.OIDCIDToken, + &i.OIDCExpiry, + &i.DevurlToken, + ) + return i, err +} + +const insertAPIKey = `-- name: InsertAPIKey :one +INSERT INTO + api_keys ( + id, + hashed_secret, + user_id, + application, + "name", + last_used, + expires_at, + created_at, + updated_at, + login_type, + oidc_access_token, + oidc_refresh_token, + oidc_id_token, + oidc_expiry, + devurl_token + ) +VALUES + ( + $1, + $2, + $3, + $4, + $5, + $6, + $7, + $8, + $9, + $10, + $11, + $12, + $13, + $14, + $15 + ) RETURNING id, hashed_secret, user_id, application, name, last_used, expires_at, created_at, updated_at, login_type, oidc_access_token, oidc_refresh_token, oidc_id_token, oidc_expiry, devurl_token +` + +type InsertAPIKeyParams struct { + ID string `db:"id" json:"id"` + HashedSecret []byte `db:"hashed_secret" json:"hashed_secret"` + UserID string `db:"user_id" json:"user_id"` + Application bool `db:"application" json:"application"` + Name string `db:"name" json:"name"` + LastUsed time.Time `db:"last_used" json:"last_used"` + ExpiresAt time.Time `db:"expires_at" json:"expires_at"` + CreatedAt time.Time `db:"created_at" json:"created_at"` + UpdatedAt time.Time `db:"updated_at" json:"updated_at"` + LoginType LoginType `db:"login_type" json:"login_type"` + OIDCAccessToken string `db:"oidc_access_token" json:"oidc_access_token"` + OIDCRefreshToken string `db:"oidc_refresh_token" json:"oidc_refresh_token"` + OIDCIDToken string `db:"oidc_id_token" json:"oidc_id_token"` + OIDCExpiry time.Time `db:"oidc_expiry" json:"oidc_expiry"` + DevurlToken bool `db:"devurl_token" json:"devurl_token"` +} + +func (q *sqlQuerier) InsertAPIKey(ctx context.Context, arg InsertAPIKeyParams) (APIKey, error) { + row := q.db.QueryRowContext(ctx, insertAPIKey, + arg.ID, + arg.HashedSecret, + arg.UserID, + arg.Application, + arg.Name, + arg.LastUsed, + arg.ExpiresAt, + arg.CreatedAt, + arg.UpdatedAt, + arg.LoginType, + arg.OIDCAccessToken, + arg.OIDCRefreshToken, + arg.OIDCIDToken, + arg.OIDCExpiry, + arg.DevurlToken, + ) + var i APIKey + err := row.Scan( + &i.ID, + &i.HashedSecret, + &i.UserID, + &i.Application, + &i.Name, + &i.LastUsed, + &i.ExpiresAt, + &i.CreatedAt, + &i.UpdatedAt, + &i.LoginType, + &i.OIDCAccessToken, + &i.OIDCRefreshToken, + &i.OIDCIDToken, + &i.OIDCExpiry, + &i.DevurlToken, + ) + return i, err +} + +const updateAPIKeyByID = `-- name: UpdateAPIKeyByID :exec +UPDATE + api_keys +SET + last_used = $2, + expires_at = $3, + oidc_access_token = $4, + oidc_refresh_token = $5, + oidc_expiry = $6 +WHERE + id = $1 +` + +type UpdateAPIKeyByIDParams struct { + ID string `db:"id" json:"id"` + LastUsed time.Time `db:"last_used" json:"last_used"` + ExpiresAt time.Time `db:"expires_at" json:"expires_at"` + OIDCAccessToken string `db:"oidc_access_token" json:"oidc_access_token"` + OIDCRefreshToken string `db:"oidc_refresh_token" json:"oidc_refresh_token"` + OIDCExpiry time.Time `db:"oidc_expiry" json:"oidc_expiry"` +} + +func (q *sqlQuerier) UpdateAPIKeyByID(ctx context.Context, arg UpdateAPIKeyByIDParams) error { + _, err := q.db.ExecContext(ctx, updateAPIKeyByID, + arg.ID, + arg.LastUsed, + arg.ExpiresAt, + arg.OIDCAccessToken, + arg.OIDCRefreshToken, + arg.OIDCExpiry, + ) + return err +} diff --git a/coderd/database/dump.sql b/coderd/database/dump.sql index 64f3525a3c336..548b1b93d1e75 100644 --- a/coderd/database/dump.sql +++ b/coderd/database/dump.sql @@ -366,6 +366,10 @@ CREATE UNIQUE INDEX idx_users_email ON users USING btree (email); CREATE UNIQUE INDEX idx_users_username ON users USING btree (username); +CREATE UNIQUE INDEX idx_projects_name_lower ON projects USING btree (lower((name)::text)); + +CREATE UNIQUE INDEX idx_workspaces_name_lower ON workspaces USING btree (lower((name)::text)); + CREATE UNIQUE INDEX projects_organization_id_name_idx ON projects USING btree (organization_id, name) WHERE (deleted = false); CREATE UNIQUE INDEX users_username_lower_idx ON users USING btree (lower(username)); diff --git a/coderd/database/files.sql.go b/coderd/database/files.sql.go new file mode 100644 index 0000000000000..d77126bea2237 --- /dev/null +++ b/coderd/database/files.sql.go @@ -0,0 +1,67 @@ +// Code generated by sqlc. DO NOT EDIT. +// source: files.sql + +package database + +import ( + "context" + "time" +) + +const getFileByHash = `-- name: GetFileByHash :one +SELECT + hash, created_at, created_by, mimetype, data +FROM + files +WHERE + hash = $1 +LIMIT + 1 +` + +func (q *sqlQuerier) GetFileByHash(ctx context.Context, hash string) (File, error) { + row := q.db.QueryRowContext(ctx, getFileByHash, hash) + var i File + err := row.Scan( + &i.Hash, + &i.CreatedAt, + &i.CreatedBy, + &i.Mimetype, + &i.Data, + ) + return i, err +} + +const insertFile = `-- name: InsertFile :one +INSERT INTO + files (hash, created_at, created_by, mimetype, "data") +VALUES + ($1, $2, $3, $4, $5) RETURNING hash, created_at, created_by, mimetype, data +` + +type InsertFileParams struct { + Hash string `db:"hash" json:"hash"` + CreatedAt time.Time `db:"created_at" json:"created_at"` + CreatedBy string `db:"created_by" json:"created_by"` + Mimetype string `db:"mimetype" json:"mimetype"` + Data []byte `db:"data" json:"data"` +} + +func (q *sqlQuerier) InsertFile(ctx context.Context, arg InsertFileParams) (File, error) { + row := q.db.QueryRowContext(ctx, insertFile, + arg.Hash, + arg.CreatedAt, + arg.CreatedBy, + arg.Mimetype, + arg.Data, + ) + var i File + err := row.Scan( + &i.Hash, + &i.CreatedAt, + &i.CreatedBy, + &i.Mimetype, + &i.Data, + ) + return i, err +} diff --git a/coderd/database/migrations/000002_projects.up.sql b/coderd/database/migrations/000002_projects.up.sql index b9b778ea69eb0..220a076c1f532 100644 --- a/coderd/database/migrations/000002_projects.up.sql +++ b/coderd/database/migrations/000002_projects.up.sql @@ -33,6 +33,7 @@ CREATE TABLE projects ( -- Enforces no active projects have the same name. CREATE UNIQUE INDEX ON projects (organization_id, name) WHERE deleted = FALSE; +CREATE UNIQUE INDEX idx_projects_name_lower ON projects USING btree (lower(name)); -- Project Versions store historical project data. When a Project Version is imported, -- an "import" job is queued to parse parameters. A Project Version diff --git a/coderd/database/migrations/000003_workspaces.up.sql b/coderd/database/migrations/000003_workspaces.up.sql index 3f8393c9cb750..517a33b186873 100644 --- a/coderd/database/migrations/000003_workspaces.up.sql +++ b/coderd/database/migrations/000003_workspaces.up.sql @@ -12,7 +12,8 @@ CREATE TABLE workspaces ( ); -- Enforces no active workspaces have the same name. -CREATE UNIQUE INDEX ON workspaces (owner_id, name) WHERE deleted = FALSE; +CREATE UNIQUE INDEX ON workspaces USING btree (owner_id, name) WHERE deleted = FALSE; +CREATE UNIQUE INDEX idx_workspaces_name_lower ON workspaces USING btree (lower(name)); CREATE TYPE workspace_transition AS ENUM ( 'start', diff --git a/coderd/database/organization_members.sql.go b/coderd/database/organization_members.sql.go new file mode 100644 index 0000000000000..374c49aea145e --- /dev/null +++ b/coderd/database/organization_members.sql.go @@ -0,0 +1,81 @@ +// Code generated by sqlc. DO NOT EDIT. +// source: organization_members.sql + +package database + +import ( + "context" + "time" + + "github.com/lib/pq" +) + +const getOrganizationMemberByUserID = `-- name: GetOrganizationMemberByUserID :one +SELECT + organization_id, user_id, created_at, updated_at, roles +FROM + organization_members +WHERE + organization_id = $1 + AND user_id = $2 +LIMIT + 1 +` + +type GetOrganizationMemberByUserIDParams struct { + OrganizationID string `db:"organization_id" json:"organization_id"` + UserID string `db:"user_id" json:"user_id"` +} + +func (q *sqlQuerier) GetOrganizationMemberByUserID(ctx context.Context, arg GetOrganizationMemberByUserIDParams) (OrganizationMember, error) { + row := q.db.QueryRowContext(ctx, getOrganizationMemberByUserID, arg.OrganizationID, arg.UserID) + var i OrganizationMember + err := row.Scan( + &i.OrganizationID, + &i.UserID, + &i.CreatedAt, + &i.UpdatedAt, + pq.Array(&i.Roles), + ) + return i, err +} + +const insertOrganizationMember = `-- name: InsertOrganizationMember :one +INSERT INTO + organization_members ( + organization_id, + user_id, + created_at, + updated_at, + roles + ) +VALUES + ($1, $2, $3, $4, $5) RETURNING organization_id, user_id, created_at, updated_at, roles +` + +type InsertOrganizationMemberParams struct { + OrganizationID string `db:"organization_id" json:"organization_id"` + UserID string `db:"user_id" json:"user_id"` + CreatedAt time.Time `db:"created_at" json:"created_at"` + UpdatedAt time.Time `db:"updated_at" json:"updated_at"` + Roles []string `db:"roles" json:"roles"` +} + +func (q *sqlQuerier) InsertOrganizationMember(ctx context.Context, arg InsertOrganizationMemberParams) (OrganizationMember, error) { + row := q.db.QueryRowContext(ctx, insertOrganizationMember, + arg.OrganizationID, + arg.UserID, + arg.CreatedAt, + arg.UpdatedAt, + pq.Array(arg.Roles), + ) + var i OrganizationMember + err := row.Scan( + &i.OrganizationID, + &i.UserID, + &i.CreatedAt, + &i.UpdatedAt, + pq.Array(&i.Roles), + ) + return i, err +} diff --git a/coderd/database/organizations.sql.go b/coderd/database/organizations.sql.go new file mode 100644 index 0000000000000..4552a5922ca4d --- /dev/null +++ b/coderd/database/organizations.sql.go @@ -0,0 +1,154 @@ +// Code generated by sqlc. DO NOT EDIT. +// source: organizations.sql + +package database + +import ( + "context" + "time" +) + +const getOrganizationByID = `-- name: GetOrganizationByID :one +SELECT + id, name, description, created_at, updated_at, "default", auto_off_threshold, cpu_provisioning_rate, memory_provisioning_rate, workspace_auto_off +FROM + organizations +WHERE + id = $1 +` + +func (q *sqlQuerier) GetOrganizationByID(ctx context.Context, id string) (Organization, error) { + row := q.db.QueryRowContext(ctx, getOrganizationByID, id) + var i Organization + err := row.Scan( + &i.ID, + &i.Name, + &i.Description, + &i.CreatedAt, + &i.UpdatedAt, + &i.Default, + &i.AutoOffThreshold, + &i.CpuProvisioningRate, + &i.MemoryProvisioningRate, + &i.WorkspaceAutoOff, + ) + return i, err +} + +const getOrganizationByName = `-- name: GetOrganizationByName :one +SELECT + id, name, description, created_at, updated_at, "default", auto_off_threshold, cpu_provisioning_rate, memory_provisioning_rate, workspace_auto_off +FROM + organizations +WHERE + LOWER("name") = LOWER($1) +LIMIT + 1 +` + +func (q *sqlQuerier) GetOrganizationByName(ctx context.Context, name string) (Organization, error) { + row := q.db.QueryRowContext(ctx, getOrganizationByName, name) + var i Organization + err := row.Scan( + &i.ID, + &i.Name, + &i.Description, + &i.CreatedAt, + &i.UpdatedAt, + &i.Default, + &i.AutoOffThreshold, + &i.CpuProvisioningRate, + &i.MemoryProvisioningRate, + &i.WorkspaceAutoOff, + ) + return i, err +} + +const getOrganizationsByUserID = `-- name: GetOrganizationsByUserID :many +SELECT + id, name, description, created_at, updated_at, "default", auto_off_threshold, cpu_provisioning_rate, memory_provisioning_rate, workspace_auto_off +FROM + organizations +WHERE + id = ( + SELECT + organization_id + FROM + organization_members + WHERE + user_id = $1 + ) +` + +func (q *sqlQuerier) GetOrganizationsByUserID(ctx context.Context, userID string) ([]Organization, error) { + rows, err := q.db.QueryContext(ctx, getOrganizationsByUserID, userID) + if err != nil { + return nil, err + } + defer rows.Close() + var items []Organization + for rows.Next() { + var i Organization + if err := rows.Scan( + &i.ID, + &i.Name, + &i.Description, + &i.CreatedAt, + &i.UpdatedAt, + &i.Default, + &i.AutoOffThreshold, + &i.CpuProvisioningRate, + &i.MemoryProvisioningRate, + &i.WorkspaceAutoOff, + ); 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 insertOrganization = `-- name: InsertOrganization :one +INSERT INTO + organizations (id, "name", description, created_at, updated_at) +VALUES + ($1, $2, $3, $4, $5) RETURNING id, name, description, created_at, updated_at, "default", auto_off_threshold, cpu_provisioning_rate, memory_provisioning_rate, workspace_auto_off +` + +type InsertOrganizationParams struct { + ID string `db:"id" json:"id"` + Name string `db:"name" json:"name"` + Description string `db:"description" json:"description"` + CreatedAt time.Time `db:"created_at" json:"created_at"` + UpdatedAt time.Time `db:"updated_at" json:"updated_at"` +} + +func (q *sqlQuerier) InsertOrganization(ctx context.Context, arg InsertOrganizationParams) (Organization, error) { + row := q.db.QueryRowContext(ctx, insertOrganization, + arg.ID, + arg.Name, + arg.Description, + arg.CreatedAt, + arg.UpdatedAt, + ) + var i Organization + err := row.Scan( + &i.ID, + &i.Name, + &i.Description, + &i.CreatedAt, + &i.UpdatedAt, + &i.Default, + &i.AutoOffThreshold, + &i.CpuProvisioningRate, + &i.MemoryProvisioningRate, + &i.WorkspaceAutoOff, + ) + return i, err +} diff --git a/coderd/database/parameter_schemas.sql.go b/coderd/database/parameter_schemas.sql.go new file mode 100644 index 0000000000000..fbcfe1ac96f96 --- /dev/null +++ b/coderd/database/parameter_schemas.sql.go @@ -0,0 +1,161 @@ +// Code generated by sqlc. DO NOT EDIT. +// source: parameter_schemas.sql + +package database + +import ( + "context" + "time" + + "github.com/google/uuid" +) + +const getParameterSchemasByJobID = `-- name: GetParameterSchemasByJobID :many +SELECT + id, created_at, job_id, name, description, default_source_scheme, default_source_value, allow_override_source, default_destination_scheme, allow_override_destination, default_refresh, redisplay_value, validation_error, validation_condition, validation_type_system, validation_value_type +FROM + parameter_schemas +WHERE + job_id = $1 +` + +func (q *sqlQuerier) GetParameterSchemasByJobID(ctx context.Context, jobID uuid.UUID) ([]ParameterSchema, error) { + rows, err := q.db.QueryContext(ctx, getParameterSchemasByJobID, jobID) + if err != nil { + return nil, err + } + defer rows.Close() + var items []ParameterSchema + for rows.Next() { + var i ParameterSchema + if err := rows.Scan( + &i.ID, + &i.CreatedAt, + &i.JobID, + &i.Name, + &i.Description, + &i.DefaultSourceScheme, + &i.DefaultSourceValue, + &i.AllowOverrideSource, + &i.DefaultDestinationScheme, + &i.AllowOverrideDestination, + &i.DefaultRefresh, + &i.RedisplayValue, + &i.ValidationError, + &i.ValidationCondition, + &i.ValidationTypeSystem, + &i.ValidationValueType, + ); 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 insertParameterSchema = `-- name: InsertParameterSchema :one +INSERT INTO + parameter_schemas ( + id, + created_at, + job_id, + "name", + description, + default_source_scheme, + default_source_value, + allow_override_source, + default_destination_scheme, + allow_override_destination, + default_refresh, + redisplay_value, + validation_error, + validation_condition, + validation_type_system, + validation_value_type + ) +VALUES + ( + $1, + $2, + $3, + $4, + $5, + $6, + $7, + $8, + $9, + $10, + $11, + $12, + $13, + $14, + $15, + $16 + ) RETURNING id, created_at, job_id, name, description, default_source_scheme, default_source_value, allow_override_source, default_destination_scheme, allow_override_destination, default_refresh, redisplay_value, validation_error, validation_condition, validation_type_system, validation_value_type +` + +type InsertParameterSchemaParams struct { + ID uuid.UUID `db:"id" json:"id"` + CreatedAt time.Time `db:"created_at" json:"created_at"` + JobID uuid.UUID `db:"job_id" json:"job_id"` + Name string `db:"name" json:"name"` + Description string `db:"description" json:"description"` + DefaultSourceScheme ParameterSourceScheme `db:"default_source_scheme" json:"default_source_scheme"` + DefaultSourceValue string `db:"default_source_value" json:"default_source_value"` + AllowOverrideSource bool `db:"allow_override_source" json:"allow_override_source"` + DefaultDestinationScheme ParameterDestinationScheme `db:"default_destination_scheme" json:"default_destination_scheme"` + AllowOverrideDestination bool `db:"allow_override_destination" json:"allow_override_destination"` + DefaultRefresh string `db:"default_refresh" json:"default_refresh"` + RedisplayValue bool `db:"redisplay_value" json:"redisplay_value"` + ValidationError string `db:"validation_error" json:"validation_error"` + ValidationCondition string `db:"validation_condition" json:"validation_condition"` + ValidationTypeSystem ParameterTypeSystem `db:"validation_type_system" json:"validation_type_system"` + ValidationValueType string `db:"validation_value_type" json:"validation_value_type"` +} + +func (q *sqlQuerier) InsertParameterSchema(ctx context.Context, arg InsertParameterSchemaParams) (ParameterSchema, error) { + row := q.db.QueryRowContext(ctx, insertParameterSchema, + arg.ID, + arg.CreatedAt, + arg.JobID, + arg.Name, + arg.Description, + arg.DefaultSourceScheme, + arg.DefaultSourceValue, + arg.AllowOverrideSource, + arg.DefaultDestinationScheme, + arg.AllowOverrideDestination, + arg.DefaultRefresh, + arg.RedisplayValue, + arg.ValidationError, + arg.ValidationCondition, + arg.ValidationTypeSystem, + arg.ValidationValueType, + ) + var i ParameterSchema + err := row.Scan( + &i.ID, + &i.CreatedAt, + &i.JobID, + &i.Name, + &i.Description, + &i.DefaultSourceScheme, + &i.DefaultSourceValue, + &i.AllowOverrideSource, + &i.DefaultDestinationScheme, + &i.AllowOverrideDestination, + &i.DefaultRefresh, + &i.RedisplayValue, + &i.ValidationError, + &i.ValidationCondition, + &i.ValidationTypeSystem, + &i.ValidationValueType, + ) + return i, err +} diff --git a/coderd/database/parameter_values.sql.go b/coderd/database/parameter_values.sql.go new file mode 100644 index 0000000000000..ca9b7a2d7ebc4 --- /dev/null +++ b/coderd/database/parameter_values.sql.go @@ -0,0 +1,163 @@ +// Code generated by sqlc. DO NOT EDIT. +// source: parameter_values.sql + +package database + +import ( + "context" + "time" + + "github.com/google/uuid" +) + +const deleteParameterValueByID = `-- name: DeleteParameterValueByID :exec +DELETE FROM + parameter_values +WHERE + id = $1 +` + +func (q *sqlQuerier) DeleteParameterValueByID(ctx context.Context, id uuid.UUID) error { + _, err := q.db.ExecContext(ctx, deleteParameterValueByID, id) + return err +} + +const getParameterValueByScopeAndName = `-- name: GetParameterValueByScopeAndName :one +SELECT + id, created_at, updated_at, scope, scope_id, name, source_scheme, source_value, destination_scheme +FROM + parameter_values +WHERE + scope = $1 + AND scope_id = $2 + AND NAME = $3 +LIMIT + 1 +` + +type GetParameterValueByScopeAndNameParams struct { + Scope ParameterScope `db:"scope" json:"scope"` + ScopeID string `db:"scope_id" json:"scope_id"` + Name string `db:"name" json:"name"` +} + +func (q *sqlQuerier) GetParameterValueByScopeAndName(ctx context.Context, arg GetParameterValueByScopeAndNameParams) (ParameterValue, error) { + row := q.db.QueryRowContext(ctx, getParameterValueByScopeAndName, arg.Scope, arg.ScopeID, arg.Name) + var i ParameterValue + err := row.Scan( + &i.ID, + &i.CreatedAt, + &i.UpdatedAt, + &i.Scope, + &i.ScopeID, + &i.Name, + &i.SourceScheme, + &i.SourceValue, + &i.DestinationScheme, + ) + return i, err +} + +const getParameterValuesByScope = `-- name: GetParameterValuesByScope :many +SELECT + id, created_at, updated_at, scope, scope_id, name, source_scheme, source_value, destination_scheme +FROM + parameter_values +WHERE + scope = $1 + AND scope_id = $2 +` + +type GetParameterValuesByScopeParams struct { + Scope ParameterScope `db:"scope" json:"scope"` + ScopeID string `db:"scope_id" json:"scope_id"` +} + +func (q *sqlQuerier) GetParameterValuesByScope(ctx context.Context, arg GetParameterValuesByScopeParams) ([]ParameterValue, error) { + rows, err := q.db.QueryContext(ctx, getParameterValuesByScope, arg.Scope, arg.ScopeID) + if err != nil { + return nil, err + } + defer rows.Close() + var items []ParameterValue + for rows.Next() { + var i ParameterValue + if err := rows.Scan( + &i.ID, + &i.CreatedAt, + &i.UpdatedAt, + &i.Scope, + &i.ScopeID, + &i.Name, + &i.SourceScheme, + &i.SourceValue, + &i.DestinationScheme, + ); 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 insertParameterValue = `-- name: InsertParameterValue :one +INSERT INTO + parameter_values ( + id, + "name", + created_at, + updated_at, + scope, + scope_id, + source_scheme, + source_value, + destination_scheme + ) +VALUES + ($1, $2, $3, $4, $5, $6, $7, $8, $9) RETURNING id, created_at, updated_at, scope, scope_id, name, source_scheme, source_value, destination_scheme +` + +type InsertParameterValueParams struct { + ID uuid.UUID `db:"id" json:"id"` + Name string `db:"name" json:"name"` + CreatedAt time.Time `db:"created_at" json:"created_at"` + UpdatedAt time.Time `db:"updated_at" json:"updated_at"` + Scope ParameterScope `db:"scope" json:"scope"` + ScopeID string `db:"scope_id" json:"scope_id"` + SourceScheme ParameterSourceScheme `db:"source_scheme" json:"source_scheme"` + SourceValue string `db:"source_value" json:"source_value"` + DestinationScheme ParameterDestinationScheme `db:"destination_scheme" json:"destination_scheme"` +} + +func (q *sqlQuerier) InsertParameterValue(ctx context.Context, arg InsertParameterValueParams) (ParameterValue, error) { + row := q.db.QueryRowContext(ctx, insertParameterValue, + arg.ID, + arg.Name, + arg.CreatedAt, + arg.UpdatedAt, + arg.Scope, + arg.ScopeID, + arg.SourceScheme, + arg.SourceValue, + arg.DestinationScheme, + ) + var i ParameterValue + err := row.Scan( + &i.ID, + &i.CreatedAt, + &i.UpdatedAt, + &i.Scope, + &i.ScopeID, + &i.Name, + &i.SourceScheme, + &i.SourceValue, + &i.DestinationScheme, + ) + return i, err +} diff --git a/coderd/database/project_versions.sql.go b/coderd/database/project_versions.sql.go new file mode 100644 index 0000000000000..f1ed9fe7bb67e --- /dev/null +++ b/coderd/database/project_versions.sql.go @@ -0,0 +1,206 @@ +// Code generated by sqlc. DO NOT EDIT. +// source: project_versions.sql + +package database + +import ( + "context" + "time" + + "github.com/google/uuid" +) + +const getProjectVersionByID = `-- name: GetProjectVersionByID :one +SELECT + id, project_id, organization_id, created_at, updated_at, name, description, job_id +FROM + project_versions +WHERE + id = $1 +` + +func (q *sqlQuerier) GetProjectVersionByID(ctx context.Context, id uuid.UUID) (ProjectVersion, error) { + row := q.db.QueryRowContext(ctx, getProjectVersionByID, id) + var i ProjectVersion + err := row.Scan( + &i.ID, + &i.ProjectID, + &i.OrganizationID, + &i.CreatedAt, + &i.UpdatedAt, + &i.Name, + &i.Description, + &i.JobID, + ) + return i, err +} + +const getProjectVersionByJobID = `-- name: GetProjectVersionByJobID :one +SELECT + id, project_id, organization_id, created_at, updated_at, name, description, job_id +FROM + project_versions +WHERE + job_id = $1 +` + +func (q *sqlQuerier) GetProjectVersionByJobID(ctx context.Context, jobID uuid.UUID) (ProjectVersion, error) { + row := q.db.QueryRowContext(ctx, getProjectVersionByJobID, jobID) + var i ProjectVersion + err := row.Scan( + &i.ID, + &i.ProjectID, + &i.OrganizationID, + &i.CreatedAt, + &i.UpdatedAt, + &i.Name, + &i.Description, + &i.JobID, + ) + return i, err +} + +const getProjectVersionByProjectIDAndName = `-- name: GetProjectVersionByProjectIDAndName :one +SELECT + id, project_id, organization_id, created_at, updated_at, name, description, job_id +FROM + project_versions +WHERE + project_id = $1 + AND "name" = $2 +` + +type GetProjectVersionByProjectIDAndNameParams struct { + ProjectID uuid.NullUUID `db:"project_id" json:"project_id"` + Name string `db:"name" json:"name"` +} + +func (q *sqlQuerier) GetProjectVersionByProjectIDAndName(ctx context.Context, arg GetProjectVersionByProjectIDAndNameParams) (ProjectVersion, error) { + row := q.db.QueryRowContext(ctx, getProjectVersionByProjectIDAndName, arg.ProjectID, arg.Name) + var i ProjectVersion + err := row.Scan( + &i.ID, + &i.ProjectID, + &i.OrganizationID, + &i.CreatedAt, + &i.UpdatedAt, + &i.Name, + &i.Description, + &i.JobID, + ) + return i, err +} + +const getProjectVersionsByProjectID = `-- name: GetProjectVersionsByProjectID :many +SELECT + id, project_id, organization_id, created_at, updated_at, name, description, job_id +FROM + project_versions +WHERE + project_id = $1 :: uuid +` + +func (q *sqlQuerier) GetProjectVersionsByProjectID(ctx context.Context, dollar_1 uuid.UUID) ([]ProjectVersion, error) { + rows, err := q.db.QueryContext(ctx, getProjectVersionsByProjectID, dollar_1) + if err != nil { + return nil, err + } + defer rows.Close() + var items []ProjectVersion + for rows.Next() { + var i ProjectVersion + if err := rows.Scan( + &i.ID, + &i.ProjectID, + &i.OrganizationID, + &i.CreatedAt, + &i.UpdatedAt, + &i.Name, + &i.Description, + &i.JobID, + ); 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 insertProjectVersion = `-- name: InsertProjectVersion :one +INSERT INTO + project_versions ( + id, + project_id, + organization_id, + created_at, + updated_at, + "name", + description, + job_id + ) +VALUES + ($1, $2, $3, $4, $5, $6, $7, $8) RETURNING id, project_id, organization_id, created_at, updated_at, name, description, job_id +` + +type InsertProjectVersionParams struct { + ID uuid.UUID `db:"id" json:"id"` + ProjectID uuid.NullUUID `db:"project_id" json:"project_id"` + OrganizationID string `db:"organization_id" json:"organization_id"` + CreatedAt time.Time `db:"created_at" json:"created_at"` + UpdatedAt time.Time `db:"updated_at" json:"updated_at"` + Name string `db:"name" json:"name"` + Description string `db:"description" json:"description"` + JobID uuid.UUID `db:"job_id" json:"job_id"` +} + +func (q *sqlQuerier) InsertProjectVersion(ctx context.Context, arg InsertProjectVersionParams) (ProjectVersion, error) { + row := q.db.QueryRowContext(ctx, insertProjectVersion, + arg.ID, + arg.ProjectID, + arg.OrganizationID, + arg.CreatedAt, + arg.UpdatedAt, + arg.Name, + arg.Description, + arg.JobID, + ) + var i ProjectVersion + err := row.Scan( + &i.ID, + &i.ProjectID, + &i.OrganizationID, + &i.CreatedAt, + &i.UpdatedAt, + &i.Name, + &i.Description, + &i.JobID, + ) + return i, err +} + +const updateProjectVersionByID = `-- name: UpdateProjectVersionByID :exec +UPDATE + project_versions +SET + project_id = $2, + updated_at = $3 +WHERE + id = $1 +` + +type UpdateProjectVersionByIDParams struct { + ID uuid.UUID `db:"id" json:"id"` + ProjectID uuid.NullUUID `db:"project_id" json:"project_id"` + UpdatedAt time.Time `db:"updated_at" json:"updated_at"` +} + +func (q *sqlQuerier) UpdateProjectVersionByID(ctx context.Context, arg UpdateProjectVersionByIDParams) error { + _, err := q.db.ExecContext(ctx, updateProjectVersionByID, arg.ID, arg.ProjectID, arg.UpdatedAt) + return err +} diff --git a/coderd/database/projects.sql.go b/coderd/database/projects.sql.go new file mode 100644 index 0000000000000..6ec60b95894ea --- /dev/null +++ b/coderd/database/projects.sql.go @@ -0,0 +1,249 @@ +// Code generated by sqlc. DO NOT EDIT. +// source: projects.sql + +package database + +import ( + "context" + "time" + + "github.com/google/uuid" + "github.com/lib/pq" +) + +const getProjectByID = `-- name: GetProjectByID :one +SELECT + id, created_at, updated_at, organization_id, deleted, name, provisioner, active_version_id +FROM + projects +WHERE + id = $1 +LIMIT + 1 +` + +func (q *sqlQuerier) GetProjectByID(ctx context.Context, id uuid.UUID) (Project, error) { + row := q.db.QueryRowContext(ctx, getProjectByID, id) + var i Project + err := row.Scan( + &i.ID, + &i.CreatedAt, + &i.UpdatedAt, + &i.OrganizationID, + &i.Deleted, + &i.Name, + &i.Provisioner, + &i.ActiveVersionID, + ) + return i, err +} + +const getProjectByOrganizationAndName = `-- name: GetProjectByOrganizationAndName :one +SELECT + id, created_at, updated_at, organization_id, deleted, name, provisioner, active_version_id +FROM + projects +WHERE + organization_id = $1 + AND deleted = $2 + AND LOWER("name") = LOWER($3) +LIMIT + 1 +` + +type GetProjectByOrganizationAndNameParams struct { + OrganizationID string `db:"organization_id" json:"organization_id"` + Deleted bool `db:"deleted" json:"deleted"` + Name string `db:"name" json:"name"` +} + +func (q *sqlQuerier) GetProjectByOrganizationAndName(ctx context.Context, arg GetProjectByOrganizationAndNameParams) (Project, error) { + row := q.db.QueryRowContext(ctx, getProjectByOrganizationAndName, arg.OrganizationID, arg.Deleted, arg.Name) + var i Project + err := row.Scan( + &i.ID, + &i.CreatedAt, + &i.UpdatedAt, + &i.OrganizationID, + &i.Deleted, + &i.Name, + &i.Provisioner, + &i.ActiveVersionID, + ) + return i, err +} + +const getProjectsByIDs = `-- name: GetProjectsByIDs :many +SELECT + id, created_at, updated_at, organization_id, deleted, name, provisioner, active_version_id +FROM + projects +WHERE + id = ANY($1 :: uuid [ ]) +` + +func (q *sqlQuerier) GetProjectsByIDs(ctx context.Context, ids []uuid.UUID) ([]Project, error) { + rows, err := q.db.QueryContext(ctx, getProjectsByIDs, pq.Array(ids)) + if err != nil { + return nil, err + } + defer rows.Close() + var items []Project + for rows.Next() { + var i Project + if err := rows.Scan( + &i.ID, + &i.CreatedAt, + &i.UpdatedAt, + &i.OrganizationID, + &i.Deleted, + &i.Name, + &i.Provisioner, + &i.ActiveVersionID, + ); 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 getProjectsByOrganization = `-- name: GetProjectsByOrganization :many +SELECT + id, created_at, updated_at, organization_id, deleted, name, provisioner, active_version_id +FROM + projects +WHERE + organization_id = $1 + AND deleted = $2 +` + +type GetProjectsByOrganizationParams struct { + OrganizationID string `db:"organization_id" json:"organization_id"` + Deleted bool `db:"deleted" json:"deleted"` +} + +func (q *sqlQuerier) GetProjectsByOrganization(ctx context.Context, arg GetProjectsByOrganizationParams) ([]Project, error) { + rows, err := q.db.QueryContext(ctx, getProjectsByOrganization, arg.OrganizationID, arg.Deleted) + if err != nil { + return nil, err + } + defer rows.Close() + var items []Project + for rows.Next() { + var i Project + if err := rows.Scan( + &i.ID, + &i.CreatedAt, + &i.UpdatedAt, + &i.OrganizationID, + &i.Deleted, + &i.Name, + &i.Provisioner, + &i.ActiveVersionID, + ); 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 insertProject = `-- name: InsertProject :one +INSERT INTO + projects ( + id, + created_at, + updated_at, + organization_id, + "name", + provisioner, + active_version_id + ) +VALUES + ($1, $2, $3, $4, $5, $6, $7) RETURNING id, created_at, updated_at, organization_id, deleted, name, provisioner, active_version_id +` + +type InsertProjectParams struct { + ID uuid.UUID `db:"id" json:"id"` + CreatedAt time.Time `db:"created_at" json:"created_at"` + UpdatedAt time.Time `db:"updated_at" json:"updated_at"` + OrganizationID string `db:"organization_id" json:"organization_id"` + Name string `db:"name" json:"name"` + Provisioner ProvisionerType `db:"provisioner" json:"provisioner"` + ActiveVersionID uuid.UUID `db:"active_version_id" json:"active_version_id"` +} + +func (q *sqlQuerier) InsertProject(ctx context.Context, arg InsertProjectParams) (Project, error) { + row := q.db.QueryRowContext(ctx, insertProject, + arg.ID, + arg.CreatedAt, + arg.UpdatedAt, + arg.OrganizationID, + arg.Name, + arg.Provisioner, + arg.ActiveVersionID, + ) + var i Project + err := row.Scan( + &i.ID, + &i.CreatedAt, + &i.UpdatedAt, + &i.OrganizationID, + &i.Deleted, + &i.Name, + &i.Provisioner, + &i.ActiveVersionID, + ) + return i, err +} + +const updateProjectActiveVersionByID = `-- name: UpdateProjectActiveVersionByID :exec +UPDATE + projects +SET + active_version_id = $2 +WHERE + id = $1 +` + +type UpdateProjectActiveVersionByIDParams struct { + ID uuid.UUID `db:"id" json:"id"` + ActiveVersionID uuid.UUID `db:"active_version_id" json:"active_version_id"` +} + +func (q *sqlQuerier) UpdateProjectActiveVersionByID(ctx context.Context, arg UpdateProjectActiveVersionByIDParams) error { + _, err := q.db.ExecContext(ctx, updateProjectActiveVersionByID, arg.ID, arg.ActiveVersionID) + return err +} + +const updateProjectDeletedByID = `-- name: UpdateProjectDeletedByID :exec +UPDATE + projects +SET + deleted = $2 +WHERE + id = $1 +` + +type UpdateProjectDeletedByIDParams struct { + ID uuid.UUID `db:"id" json:"id"` + Deleted bool `db:"deleted" json:"deleted"` +} + +func (q *sqlQuerier) UpdateProjectDeletedByID(ctx context.Context, arg UpdateProjectDeletedByIDParams) error { + _, err := q.db.ExecContext(ctx, updateProjectDeletedByID, arg.ID, arg.Deleted) + return err +} diff --git a/coderd/database/provisioner_daemons.sql.go b/coderd/database/provisioner_daemons.sql.go new file mode 100644 index 0000000000000..eef7dc5d6f0fc --- /dev/null +++ b/coderd/database/provisioner_daemons.sql.go @@ -0,0 +1,135 @@ +// Code generated by sqlc. DO NOT EDIT. +// source: provisioner_daemons.sql + +package database + +import ( + "context" + "database/sql" + "time" + + "github.com/google/uuid" + "github.com/lib/pq" +) + +const getProvisionerDaemonByID = `-- name: GetProvisionerDaemonByID :one +SELECT + id, created_at, updated_at, organization_id, name, provisioners +FROM + provisioner_daemons +WHERE + id = $1 +` + +func (q *sqlQuerier) GetProvisionerDaemonByID(ctx context.Context, id uuid.UUID) (ProvisionerDaemon, error) { + row := q.db.QueryRowContext(ctx, getProvisionerDaemonByID, id) + var i ProvisionerDaemon + err := row.Scan( + &i.ID, + &i.CreatedAt, + &i.UpdatedAt, + &i.OrganizationID, + &i.Name, + pq.Array(&i.Provisioners), + ) + return i, err +} + +const getProvisionerDaemons = `-- name: GetProvisionerDaemons :many +SELECT + id, created_at, updated_at, organization_id, name, provisioners +FROM + provisioner_daemons +` + +func (q *sqlQuerier) GetProvisionerDaemons(ctx context.Context) ([]ProvisionerDaemon, error) { + rows, err := q.db.QueryContext(ctx, getProvisionerDaemons) + if err != nil { + return nil, err + } + defer rows.Close() + var items []ProvisionerDaemon + for rows.Next() { + var i ProvisionerDaemon + if err := rows.Scan( + &i.ID, + &i.CreatedAt, + &i.UpdatedAt, + &i.OrganizationID, + &i.Name, + pq.Array(&i.Provisioners), + ); 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 insertProvisionerDaemon = `-- name: InsertProvisionerDaemon :one +INSERT INTO + provisioner_daemons ( + id, + created_at, + organization_id, + "name", + provisioners + ) +VALUES + ($1, $2, $3, $4, $5) RETURNING id, created_at, updated_at, organization_id, name, provisioners +` + +type InsertProvisionerDaemonParams struct { + ID uuid.UUID `db:"id" json:"id"` + CreatedAt time.Time `db:"created_at" json:"created_at"` + OrganizationID sql.NullString `db:"organization_id" json:"organization_id"` + Name string `db:"name" json:"name"` + Provisioners []ProvisionerType `db:"provisioners" json:"provisioners"` +} + +func (q *sqlQuerier) InsertProvisionerDaemon(ctx context.Context, arg InsertProvisionerDaemonParams) (ProvisionerDaemon, error) { + row := q.db.QueryRowContext(ctx, insertProvisionerDaemon, + arg.ID, + arg.CreatedAt, + arg.OrganizationID, + arg.Name, + pq.Array(arg.Provisioners), + ) + var i ProvisionerDaemon + err := row.Scan( + &i.ID, + &i.CreatedAt, + &i.UpdatedAt, + &i.OrganizationID, + &i.Name, + pq.Array(&i.Provisioners), + ) + return i, err +} + +const updateProvisionerDaemonByID = `-- name: UpdateProvisionerDaemonByID :exec +UPDATE + provisioner_daemons +SET + updated_at = $2, + provisioners = $3 +WHERE + id = $1 +` + +type UpdateProvisionerDaemonByIDParams struct { + ID uuid.UUID `db:"id" json:"id"` + UpdatedAt sql.NullTime `db:"updated_at" json:"updated_at"` + Provisioners []ProvisionerType `db:"provisioners" json:"provisioners"` +} + +func (q *sqlQuerier) UpdateProvisionerDaemonByID(ctx context.Context, arg UpdateProvisionerDaemonByIDParams) error { + _, err := q.db.ExecContext(ctx, updateProvisionerDaemonByID, arg.ID, arg.UpdatedAt, pq.Array(arg.Provisioners)) + return err +} diff --git a/coderd/database/provisioner_job_logs.sql.go b/coderd/database/provisioner_job_logs.sql.go new file mode 100644 index 0000000000000..a7f25aa0c8b19 --- /dev/null +++ b/coderd/database/provisioner_job_logs.sql.go @@ -0,0 +1,126 @@ +// Code generated by sqlc. DO NOT EDIT. +// source: provisioner_job_logs.sql + +package database + +import ( + "context" + "time" + + "github.com/google/uuid" + "github.com/lib/pq" +) + +const getProvisionerLogsByIDBetween = `-- name: GetProvisionerLogsByIDBetween :many +SELECT + id, job_id, created_at, source, level, stage, output +FROM + provisioner_job_logs +WHERE + job_id = $1 + AND ( + created_at >= $2 + OR created_at <= $3 + ) +ORDER BY + created_at DESC +` + +type GetProvisionerLogsByIDBetweenParams struct { + JobID uuid.UUID `db:"job_id" json:"job_id"` + CreatedAfter time.Time `db:"created_after" json:"created_after"` + CreatedBefore time.Time `db:"created_before" json:"created_before"` +} + +func (q *sqlQuerier) GetProvisionerLogsByIDBetween(ctx context.Context, arg GetProvisionerLogsByIDBetweenParams) ([]ProvisionerJobLog, error) { + rows, err := q.db.QueryContext(ctx, getProvisionerLogsByIDBetween, arg.JobID, arg.CreatedAfter, arg.CreatedBefore) + if err != nil { + return nil, err + } + defer rows.Close() + var items []ProvisionerJobLog + for rows.Next() { + var i ProvisionerJobLog + if err := rows.Scan( + &i.ID, + &i.JobID, + &i.CreatedAt, + &i.Source, + &i.Level, + &i.Stage, + &i.Output, + ); 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 insertProvisionerJobLogs = `-- name: InsertProvisionerJobLogs :many +INSERT INTO + provisioner_job_logs +SELECT + unnest($1 :: uuid [ ]) AS id, + $2 :: uuid AS job_id, + unnest($3 :: timestamptz [ ]) AS created_at, + unnest($4 :: log_source [ ]) AS source, + unnest($5 :: log_level [ ]) AS LEVEL, + unnest($6 :: VARCHAR(128) [ ]) AS stage, + unnest($7 :: VARCHAR(1024) [ ]) AS output RETURNING id, job_id, created_at, source, level, stage, output +` + +type InsertProvisionerJobLogsParams struct { + ID []uuid.UUID `db:"id" json:"id"` + JobID uuid.UUID `db:"job_id" json:"job_id"` + CreatedAt []time.Time `db:"created_at" json:"created_at"` + Source []LogSource `db:"source" json:"source"` + Level []LogLevel `db:"level" json:"level"` + Stage []string `db:"stage" json:"stage"` + Output []string `db:"output" json:"output"` +} + +func (q *sqlQuerier) InsertProvisionerJobLogs(ctx context.Context, arg InsertProvisionerJobLogsParams) ([]ProvisionerJobLog, error) { + rows, err := q.db.QueryContext(ctx, insertProvisionerJobLogs, + pq.Array(arg.ID), + arg.JobID, + pq.Array(arg.CreatedAt), + pq.Array(arg.Source), + pq.Array(arg.Level), + pq.Array(arg.Stage), + pq.Array(arg.Output), + ) + if err != nil { + return nil, err + } + defer rows.Close() + var items []ProvisionerJobLog + for rows.Next() { + var i ProvisionerJobLog + if err := rows.Scan( + &i.ID, + &i.JobID, + &i.CreatedAt, + &i.Source, + &i.Level, + &i.Stage, + &i.Output, + ); 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 +} diff --git a/coderd/database/provisioner_jobs.sql.go b/coderd/database/provisioner_jobs.sql.go new file mode 100644 index 0000000000000..683e5adddbb1b --- /dev/null +++ b/coderd/database/provisioner_jobs.sql.go @@ -0,0 +1,287 @@ +// Code generated by sqlc. DO NOT EDIT. +// source: provisioner_jobs.sql + +package database + +import ( + "context" + "database/sql" + "encoding/json" + "time" + + "github.com/google/uuid" + "github.com/lib/pq" +) + +const acquireProvisionerJob = `-- name: AcquireProvisionerJob :one +UPDATE + provisioner_jobs +SET + started_at = $1, + updated_at = $1, + worker_id = $2 +WHERE + id = ( + SELECT + id + FROM + provisioner_jobs AS nested + WHERE + nested.started_at IS NULL + AND nested.canceled_at IS NULL + AND nested.completed_at IS NULL + AND nested.provisioner = ANY($3 :: provisioner_type [ ]) + ORDER BY + nested.created_at FOR + UPDATE + SKIP LOCKED + LIMIT + 1 + ) RETURNING id, created_at, updated_at, started_at, canceled_at, completed_at, error, organization_id, initiator_id, provisioner, storage_method, storage_source, type, input, worker_id +` + +type AcquireProvisionerJobParams struct { + StartedAt sql.NullTime `db:"started_at" json:"started_at"` + WorkerID uuid.NullUUID `db:"worker_id" json:"worker_id"` + Types []ProvisionerType `db:"types" json:"types"` +} + +// Acquires the lock for a single job that isn't started, completed, +// canceled, and that matches an array of provisioner types. +// +// SKIP LOCKED is used to jump over locked rows. This prevents +// multiple provisioners from acquiring the same jobs. See: +// https://www.postgresql.org/docs/9.5/sql-select.html#SQL-FOR-UPDATE-SHARE +func (q *sqlQuerier) AcquireProvisionerJob(ctx context.Context, arg AcquireProvisionerJobParams) (ProvisionerJob, error) { + row := q.db.QueryRowContext(ctx, acquireProvisionerJob, arg.StartedAt, arg.WorkerID, pq.Array(arg.Types)) + var i ProvisionerJob + err := row.Scan( + &i.ID, + &i.CreatedAt, + &i.UpdatedAt, + &i.StartedAt, + &i.CanceledAt, + &i.CompletedAt, + &i.Error, + &i.OrganizationID, + &i.InitiatorID, + &i.Provisioner, + &i.StorageMethod, + &i.StorageSource, + &i.Type, + &i.Input, + &i.WorkerID, + ) + return i, err +} + +const getProvisionerJobByID = `-- name: GetProvisionerJobByID :one +SELECT + id, created_at, updated_at, started_at, canceled_at, completed_at, error, organization_id, initiator_id, provisioner, storage_method, storage_source, type, input, worker_id +FROM + provisioner_jobs +WHERE + id = $1 +` + +func (q *sqlQuerier) GetProvisionerJobByID(ctx context.Context, id uuid.UUID) (ProvisionerJob, error) { + row := q.db.QueryRowContext(ctx, getProvisionerJobByID, id) + var i ProvisionerJob + err := row.Scan( + &i.ID, + &i.CreatedAt, + &i.UpdatedAt, + &i.StartedAt, + &i.CanceledAt, + &i.CompletedAt, + &i.Error, + &i.OrganizationID, + &i.InitiatorID, + &i.Provisioner, + &i.StorageMethod, + &i.StorageSource, + &i.Type, + &i.Input, + &i.WorkerID, + ) + return i, err +} + +const getProvisionerJobsByIDs = `-- name: GetProvisionerJobsByIDs :many +SELECT + id, created_at, updated_at, started_at, canceled_at, completed_at, error, organization_id, initiator_id, provisioner, storage_method, storage_source, type, input, worker_id +FROM + provisioner_jobs +WHERE + id = ANY($1 :: uuid [ ]) +` + +func (q *sqlQuerier) GetProvisionerJobsByIDs(ctx context.Context, ids []uuid.UUID) ([]ProvisionerJob, error) { + rows, err := q.db.QueryContext(ctx, getProvisionerJobsByIDs, pq.Array(ids)) + if err != nil { + return nil, err + } + defer rows.Close() + var items []ProvisionerJob + for rows.Next() { + var i ProvisionerJob + if err := rows.Scan( + &i.ID, + &i.CreatedAt, + &i.UpdatedAt, + &i.StartedAt, + &i.CanceledAt, + &i.CompletedAt, + &i.Error, + &i.OrganizationID, + &i.InitiatorID, + &i.Provisioner, + &i.StorageMethod, + &i.StorageSource, + &i.Type, + &i.Input, + &i.WorkerID, + ); 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 insertProvisionerJob = `-- name: InsertProvisionerJob :one +INSERT INTO + provisioner_jobs ( + id, + created_at, + updated_at, + organization_id, + initiator_id, + provisioner, + storage_method, + storage_source, + "type", + "input" + ) +VALUES + ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10) RETURNING id, created_at, updated_at, started_at, canceled_at, completed_at, error, organization_id, initiator_id, provisioner, storage_method, storage_source, type, input, worker_id +` + +type InsertProvisionerJobParams struct { + ID uuid.UUID `db:"id" json:"id"` + CreatedAt time.Time `db:"created_at" json:"created_at"` + UpdatedAt time.Time `db:"updated_at" json:"updated_at"` + OrganizationID string `db:"organization_id" json:"organization_id"` + InitiatorID string `db:"initiator_id" json:"initiator_id"` + Provisioner ProvisionerType `db:"provisioner" json:"provisioner"` + StorageMethod ProvisionerStorageMethod `db:"storage_method" json:"storage_method"` + StorageSource string `db:"storage_source" json:"storage_source"` + Type ProvisionerJobType `db:"type" json:"type"` + Input json.RawMessage `db:"input" json:"input"` +} + +func (q *sqlQuerier) InsertProvisionerJob(ctx context.Context, arg InsertProvisionerJobParams) (ProvisionerJob, error) { + row := q.db.QueryRowContext(ctx, insertProvisionerJob, + arg.ID, + arg.CreatedAt, + arg.UpdatedAt, + arg.OrganizationID, + arg.InitiatorID, + arg.Provisioner, + arg.StorageMethod, + arg.StorageSource, + arg.Type, + arg.Input, + ) + var i ProvisionerJob + err := row.Scan( + &i.ID, + &i.CreatedAt, + &i.UpdatedAt, + &i.StartedAt, + &i.CanceledAt, + &i.CompletedAt, + &i.Error, + &i.OrganizationID, + &i.InitiatorID, + &i.Provisioner, + &i.StorageMethod, + &i.StorageSource, + &i.Type, + &i.Input, + &i.WorkerID, + ) + return i, err +} + +const updateProvisionerJobByID = `-- name: UpdateProvisionerJobByID :exec +UPDATE + provisioner_jobs +SET + updated_at = $2 +WHERE + id = $1 +` + +type UpdateProvisionerJobByIDParams struct { + ID uuid.UUID `db:"id" json:"id"` + UpdatedAt time.Time `db:"updated_at" json:"updated_at"` +} + +func (q *sqlQuerier) UpdateProvisionerJobByID(ctx context.Context, arg UpdateProvisionerJobByIDParams) error { + _, err := q.db.ExecContext(ctx, updateProvisionerJobByID, arg.ID, arg.UpdatedAt) + return err +} + +const updateProvisionerJobWithCancelByID = `-- name: UpdateProvisionerJobWithCancelByID :exec +UPDATE + provisioner_jobs +SET + canceled_at = $2 +WHERE + id = $1 +` + +type UpdateProvisionerJobWithCancelByIDParams struct { + ID uuid.UUID `db:"id" json:"id"` + CanceledAt sql.NullTime `db:"canceled_at" json:"canceled_at"` +} + +func (q *sqlQuerier) UpdateProvisionerJobWithCancelByID(ctx context.Context, arg UpdateProvisionerJobWithCancelByIDParams) error { + _, err := q.db.ExecContext(ctx, updateProvisionerJobWithCancelByID, arg.ID, arg.CanceledAt) + return err +} + +const updateProvisionerJobWithCompleteByID = `-- name: UpdateProvisionerJobWithCompleteByID :exec +UPDATE + provisioner_jobs +SET + updated_at = $2, + completed_at = $3, + error = $4 +WHERE + id = $1 +` + +type UpdateProvisionerJobWithCompleteByIDParams struct { + ID uuid.UUID `db:"id" json:"id"` + UpdatedAt time.Time `db:"updated_at" json:"updated_at"` + CompletedAt sql.NullTime `db:"completed_at" json:"completed_at"` + Error sql.NullString `db:"error" json:"error"` +} + +func (q *sqlQuerier) UpdateProvisionerJobWithCompleteByID(ctx context.Context, arg UpdateProvisionerJobWithCompleteByIDParams) error { + _, err := q.db.ExecContext(ctx, updateProvisionerJobWithCompleteByID, + arg.ID, + arg.UpdatedAt, + arg.CompletedAt, + arg.Error, + ) + return err +} diff --git a/coderd/database/queries/README.md b/coderd/database/queries/README.md new file mode 100644 index 0000000000000..4538607087139 --- /dev/null +++ b/coderd/database/queries/README.md @@ -0,0 +1,6 @@ +# queries + +Database queries are generated using sqlc. See: [sqlc +docs](https://docs.sqlc.dev/en/latest/tutorials/getting-started-postgresql.html) + +Run `make gen` to generate models and query functions. diff --git a/coderd/database/queries/api_keys.sql b/coderd/database/queries/api_keys.sql new file mode 100644 index 0000000000000..62dc38ed2ca59 --- /dev/null +++ b/coderd/database/queries/api_keys.sql @@ -0,0 +1,59 @@ +-- name: GetAPIKeyByID :one +SELECT + * +FROM + api_keys +WHERE + id = $1 +LIMIT + 1; + +-- name: InsertAPIKey :one +INSERT INTO + api_keys ( + id, + hashed_secret, + user_id, + application, + "name", + last_used, + expires_at, + created_at, + updated_at, + login_type, + oidc_access_token, + oidc_refresh_token, + oidc_id_token, + oidc_expiry, + devurl_token + ) +VALUES + ( + $1, + $2, + $3, + $4, + $5, + $6, + $7, + $8, + $9, + $10, + $11, + $12, + $13, + $14, + $15 + ) RETURNING *; + +-- name: UpdateAPIKeyByID :exec +UPDATE + api_keys +SET + last_used = $2, + expires_at = $3, + oidc_access_token = $4, + oidc_refresh_token = $5, + oidc_expiry = $6 +WHERE + id = $1; diff --git a/coderd/database/queries/files.sql b/coderd/database/queries/files.sql new file mode 100644 index 0000000000000..a91513d31a345 --- /dev/null +++ b/coderd/database/queries/files.sql @@ -0,0 +1,15 @@ +-- name: GetFileByHash :one +SELECT + * +FROM + files +WHERE + hash = $1 +LIMIT + 1; + +-- name: InsertFile :one +INSERT INTO + files (hash, created_at, created_by, mimetype, "data") +VALUES + ($1, $2, $3, $4, $5) RETURNING *; diff --git a/coderd/database/queries/organization_members.sql b/coderd/database/queries/organization_members.sql new file mode 100644 index 0000000000000..243bdc26c9878 --- /dev/null +++ b/coderd/database/queries/organization_members.sql @@ -0,0 +1,22 @@ +-- name: GetOrganizationMemberByUserID :one +SELECT + * +FROM + organization_members +WHERE + organization_id = $1 + AND user_id = $2 +LIMIT + 1; + +-- name: InsertOrganizationMember :one +INSERT INTO + organization_members ( + organization_id, + user_id, + created_at, + updated_at, + roles + ) +VALUES + ($1, $2, $3, $4, $5) RETURNING *; diff --git a/coderd/database/queries/organizations.sql b/coderd/database/queries/organizations.sql new file mode 100644 index 0000000000000..1682c04a8fd95 --- /dev/null +++ b/coderd/database/queries/organizations.sql @@ -0,0 +1,38 @@ +-- name: GetOrganizationByID :one +SELECT + * +FROM + organizations +WHERE + id = $1; + +-- name: GetOrganizationByName :one +SELECT + * +FROM + organizations +WHERE + LOWER("name") = LOWER(@name) +LIMIT + 1; + +-- name: GetOrganizationsByUserID :many +SELECT + * +FROM + organizations +WHERE + id = ( + SELECT + organization_id + FROM + organization_members + WHERE + user_id = $1 + ); + +-- name: InsertOrganization :one +INSERT INTO + organizations (id, "name", description, created_at, updated_at) +VALUES + ($1, $2, $3, $4, $5) RETURNING *; diff --git a/coderd/database/queries/parameter_schemas.sql b/coderd/database/queries/parameter_schemas.sql new file mode 100644 index 0000000000000..e813138a8a89f --- /dev/null +++ b/coderd/database/queries/parameter_schemas.sql @@ -0,0 +1,47 @@ +-- name: GetParameterSchemasByJobID :many +SELECT + * +FROM + parameter_schemas +WHERE + job_id = $1; + +-- name: InsertParameterSchema :one +INSERT INTO + parameter_schemas ( + id, + created_at, + job_id, + "name", + description, + default_source_scheme, + default_source_value, + allow_override_source, + default_destination_scheme, + allow_override_destination, + default_refresh, + redisplay_value, + validation_error, + validation_condition, + validation_type_system, + validation_value_type + ) +VALUES + ( + $1, + $2, + $3, + $4, + $5, + $6, + $7, + $8, + $9, + $10, + $11, + $12, + $13, + $14, + $15, + $16 + ) RETURNING *; diff --git a/coderd/database/queries/parameter_values.sql b/coderd/database/queries/parameter_values.sql new file mode 100644 index 0000000000000..5a6ea6ece2818 --- /dev/null +++ b/coderd/database/queries/parameter_values.sql @@ -0,0 +1,42 @@ +-- name: DeleteParameterValueByID :exec +DELETE FROM + parameter_values +WHERE + id = $1; + +-- name: GetParameterValuesByScope :many +SELECT + * +FROM + parameter_values +WHERE + scope = $1 + AND scope_id = $2; + +-- name: GetParameterValueByScopeAndName :one +SELECT + * +FROM + parameter_values +WHERE + scope = $1 + AND scope_id = $2 + AND NAME = $3 +LIMIT + 1; + +-- name: InsertParameterValue :one +INSERT INTO + parameter_values ( + id, + "name", + created_at, + updated_at, + scope, + scope_id, + source_scheme, + source_value, + destination_scheme + ) +VALUES + ($1, $2, $3, $4, $5, $6, $7, $8, $9) RETURNING *; diff --git a/coderd/database/queries/project_versions.sql b/coderd/database/queries/project_versions.sql new file mode 100644 index 0000000000000..ad07f0e9b6730 --- /dev/null +++ b/coderd/database/queries/project_versions.sql @@ -0,0 +1,56 @@ +-- name: GetProjectVersionsByProjectID :many +SELECT + * +FROM + project_versions +WHERE + project_id = $1 :: uuid; + +-- name: GetProjectVersionByJobID :one +SELECT + * +FROM + project_versions +WHERE + job_id = $1; + +-- name: GetProjectVersionByProjectIDAndName :one +SELECT + * +FROM + project_versions +WHERE + project_id = $1 + AND "name" = $2; + +-- name: GetProjectVersionByID :one +SELECT + * +FROM + project_versions +WHERE + id = $1; + +-- name: InsertProjectVersion :one +INSERT INTO + project_versions ( + id, + project_id, + organization_id, + created_at, + updated_at, + "name", + description, + job_id + ) +VALUES + ($1, $2, $3, $4, $5, $6, $7, $8) RETURNING *; + +-- name: UpdateProjectVersionByID :exec +UPDATE + project_versions +SET + project_id = $2, + updated_at = $3 +WHERE + id = $1; diff --git a/coderd/database/queries/projects.sql b/coderd/database/queries/projects.sql new file mode 100644 index 0000000000000..6b134bc8b1314 --- /dev/null +++ b/coderd/database/queries/projects.sql @@ -0,0 +1,68 @@ +-- name: GetProjectByID :one +SELECT + * +FROM + projects +WHERE + id = $1 +LIMIT + 1; + +-- name: GetProjectsByIDs :many +SELECT + * +FROM + projects +WHERE + id = ANY(@ids :: uuid [ ]); + +-- name: GetProjectByOrganizationAndName :one +SELECT + * +FROM + projects +WHERE + organization_id = @organization_id + AND deleted = @deleted + AND LOWER("name") = LOWER(@name) +LIMIT + 1; + +-- name: GetProjectsByOrganization :many +SELECT + * +FROM + projects +WHERE + organization_id = $1 + AND deleted = $2; + +-- name: InsertProject :one +INSERT INTO + projects ( + id, + created_at, + updated_at, + organization_id, + "name", + provisioner, + active_version_id + ) +VALUES + ($1, $2, $3, $4, $5, $6, $7) RETURNING *; + +-- name: UpdateProjectActiveVersionByID :exec +UPDATE + projects +SET + active_version_id = $2 +WHERE + id = $1; + +-- name: UpdateProjectDeletedByID :exec +UPDATE + projects +SET + deleted = $2 +WHERE + id = $1; diff --git a/coderd/database/queries/provisioner_daemons.sql b/coderd/database/queries/provisioner_daemons.sql new file mode 100644 index 0000000000000..0051c5428fb45 --- /dev/null +++ b/coderd/database/queries/provisioner_daemons.sql @@ -0,0 +1,34 @@ +-- name: GetProvisionerDaemonByID :one +SELECT + * +FROM + provisioner_daemons +WHERE + id = $1; + +-- name: GetProvisionerDaemons :many +SELECT + * +FROM + provisioner_daemons; + +-- name: InsertProvisionerDaemon :one +INSERT INTO + provisioner_daemons ( + id, + created_at, + organization_id, + "name", + provisioners + ) +VALUES + ($1, $2, $3, $4, $5) RETURNING *; + +-- name: UpdateProvisionerDaemonByID :exec +UPDATE + provisioner_daemons +SET + updated_at = $2, + provisioners = $3 +WHERE + id = $1; diff --git a/coderd/database/queries/provisioner_job_logs.sql b/coderd/database/queries/provisioner_job_logs.sql new file mode 100644 index 0000000000000..d9fb35af477c8 --- /dev/null +++ b/coderd/database/queries/provisioner_job_logs.sql @@ -0,0 +1,25 @@ +-- name: GetProvisionerLogsByIDBetween :many +SELECT + * +FROM + provisioner_job_logs +WHERE + job_id = @job_id + AND ( + created_at >= @created_after + OR created_at <= @created_before + ) +ORDER BY + created_at DESC; + +-- name: InsertProvisionerJobLogs :many +INSERT INTO + provisioner_job_logs +SELECT + unnest(@id :: uuid [ ]) AS id, + @job_id :: uuid AS job_id, + unnest(@created_at :: timestamptz [ ]) AS created_at, + unnest(@source :: log_source [ ]) AS source, + unnest(@level :: log_level [ ]) AS LEVEL, + unnest(@stage :: VARCHAR(128) [ ]) AS stage, + unnest(@output :: VARCHAR(1024) [ ]) AS output RETURNING *; diff --git a/coderd/database/queries/provisioner_jobs.sql b/coderd/database/queries/provisioner_jobs.sql new file mode 100644 index 0000000000000..116299804c6b1 --- /dev/null +++ b/coderd/database/queries/provisioner_jobs.sql @@ -0,0 +1,90 @@ +-- Acquires the lock for a single job that isn't started, completed, +-- canceled, and that matches an array of provisioner types. +-- +-- SKIP LOCKED is used to jump over locked rows. This prevents +-- multiple provisioners from acquiring the same jobs. See: +-- https://www.postgresql.org/docs/9.5/sql-select.html#SQL-FOR-UPDATE-SHARE +-- name: AcquireProvisionerJob :one +UPDATE + provisioner_jobs +SET + started_at = @started_at, + updated_at = @started_at, + worker_id = @worker_id +WHERE + id = ( + SELECT + id + FROM + provisioner_jobs AS nested + WHERE + nested.started_at IS NULL + AND nested.canceled_at IS NULL + AND nested.completed_at IS NULL + AND nested.provisioner = ANY(@types :: provisioner_type [ ]) + ORDER BY + nested.created_at FOR + UPDATE + SKIP LOCKED + LIMIT + 1 + ) RETURNING *; + +-- name: GetProvisionerJobByID :one +SELECT + * +FROM + provisioner_jobs +WHERE + id = $1; + +-- name: GetProvisionerJobsByIDs :many +SELECT + * +FROM + provisioner_jobs +WHERE + id = ANY(@ids :: uuid [ ]); + +-- name: InsertProvisionerJob :one +INSERT INTO + provisioner_jobs ( + id, + created_at, + updated_at, + organization_id, + initiator_id, + provisioner, + storage_method, + storage_source, + "type", + "input" + ) +VALUES + ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10) RETURNING *; + +-- name: UpdateProvisionerJobByID :exec +UPDATE + provisioner_jobs +SET + updated_at = $2 +WHERE + id = $1; + +-- name: UpdateProvisionerJobWithCancelByID :exec +UPDATE + provisioner_jobs +SET + canceled_at = $2 +WHERE + id = $1; + +-- name: UpdateProvisionerJobWithCompleteByID :exec +UPDATE + provisioner_jobs +SET + updated_at = $2, + completed_at = $3, + error = $4 +WHERE + id = $1; diff --git a/coderd/database/queries/users.sql b/coderd/database/queries/users.sql new file mode 100644 index 0000000000000..08589699beb39 --- /dev/null +++ b/coderd/database/queries/users.sql @@ -0,0 +1,42 @@ +-- name: GetUserByID :one +SELECT + * +FROM + users +WHERE + id = $1 +LIMIT + 1; + +-- name: GetUserByEmailOrUsername :one +SELECT + * +FROM + users +WHERE + LOWER(username) = LOWER(@username) + OR email = @email +LIMIT + 1; + +-- name: GetUserCount :one +SELECT + COUNT(*) +FROM + users; + +-- name: InsertUser :one +INSERT INTO + users ( + id, + email, + "name", + login_type, + revoked, + hashed_password, + created_at, + updated_at, + username + ) +VALUES + ($1, $2, $3, $4, FALSE, $5, $6, $7, $8) RETURNING *; diff --git a/coderd/database/queries/workspace_agents.sql b/coderd/database/queries/workspace_agents.sql new file mode 100644 index 0000000000000..a2a206bba07b0 --- /dev/null +++ b/coderd/database/queries/workspace_agents.sql @@ -0,0 +1,54 @@ +-- name: GetWorkspaceAgentByAuthToken :one +SELECT + * +FROM + workspace_agents +WHERE + auth_token = $1 +ORDER BY + created_at DESC; + +-- name: GetWorkspaceAgentByInstanceID :one +SELECT + * +FROM + workspace_agents +WHERE + auth_instance_id = @auth_instance_id :: TEXT +ORDER BY + created_at DESC; + +-- name: GetWorkspaceAgentByResourceID :one +SELECT + * +FROM + workspace_agents +WHERE + resource_id = $1; + +-- name: InsertWorkspaceAgent :one +INSERT INTO + workspace_agents ( + id, + created_at, + updated_at, + resource_id, + auth_token, + auth_instance_id, + environment_variables, + startup_script, + instance_metadata, + resource_metadata + ) +VALUES + ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10) RETURNING *; + +-- name: UpdateWorkspaceAgentConnectionByID :exec +UPDATE + workspace_agents +SET + first_connected_at = $2, + last_connected_at = $3, + disconnected_at = $4 +WHERE + id = $1; diff --git a/coderd/database/queries/workspace_builds.sql b/coderd/database/queries/workspace_builds.sql new file mode 100644 index 0000000000000..a73d8bf19dd0c --- /dev/null +++ b/coderd/database/queries/workspace_builds.sql @@ -0,0 +1,84 @@ +-- name: GetWorkspaceBuildByID :one +SELECT + * +FROM + workspace_builds +WHERE + id = $1 +LIMIT + 1; + +-- name: GetWorkspaceBuildByJobID :one +SELECT + * +FROM + workspace_builds +WHERE + job_id = $1 +LIMIT + 1; + +-- name: GetWorkspaceBuildByWorkspaceIDAndName :one +SELECT + * +FROM + workspace_builds +WHERE + workspace_id = $1 + AND "name" = $2; + +-- name: GetWorkspaceBuildByWorkspaceID :many +SELECT + * +FROM + workspace_builds +WHERE + workspace_id = $1; + +-- name: GetWorkspaceBuildByWorkspaceIDWithoutAfter :one +SELECT + * +FROM + workspace_builds +WHERE + workspace_id = $1 + AND after_id IS NULL +LIMIT + 1; + +-- name: GetWorkspaceBuildsByWorkspaceIDsWithoutAfter :many +SELECT + * +FROM + workspace_builds +WHERE + workspace_id = ANY(@ids :: uuid [ ]) + AND after_id IS NULL; + +-- name: InsertWorkspaceBuild :one +INSERT INTO + workspace_builds ( + id, + created_at, + updated_at, + workspace_id, + project_version_id, + before_id, + "name", + transition, + initiator_id, + job_id, + provisioner_state + ) +VALUES + ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11) RETURNING *; + +-- name: UpdateWorkspaceBuildByID :exec +UPDATE + workspace_builds +SET + updated_at = $2, + after_id = $3, + provisioner_state = $4 +WHERE + id = $1; diff --git a/coderd/database/queries/workspace_resources.sql b/coderd/database/queries/workspace_resources.sql new file mode 100644 index 0000000000000..17a352a67f702 --- /dev/null +++ b/coderd/database/queries/workspace_resources.sql @@ -0,0 +1,30 @@ +-- name: GetWorkspaceResourceByID :one +SELECT + * +FROM + workspace_resources +WHERE + id = $1; + +-- name: GetWorkspaceResourcesByJobID :many +SELECT + * +FROM + workspace_resources +WHERE + job_id = $1; + +-- name: InsertWorkspaceResource :one +INSERT INTO + workspace_resources ( + id, + created_at, + job_id, + transition, + address, + type, + name, + agent_id + ) +VALUES + ($1, $2, $3, $4, $5, $6, $7, $8) RETURNING *; diff --git a/coderd/database/queries/workspaces.sql b/coderd/database/queries/workspaces.sql new file mode 100644 index 0000000000000..99237a8cf77fb --- /dev/null +++ b/coderd/database/queries/workspaces.sql @@ -0,0 +1,70 @@ +-- name: GetWorkspaceByID :one +SELECT + * +FROM + workspaces +WHERE + id = $1 +LIMIT + 1; + +-- name: GetWorkspacesByProjectID :many +SELECT + * +FROM + workspaces +WHERE + project_id = $1 + AND deleted = $2; + +-- name: GetWorkspacesByUserID :many +SELECT + * +FROM + workspaces +WHERE + owner_id = $1 + AND deleted = $2; + +-- name: GetWorkspaceByUserIDAndName :one +SELECT + * +FROM + workspaces +WHERE + owner_id = @owner_id + AND deleted = @deleted + AND LOWER("name") = LOWER(@name); + +-- name: GetWorkspaceOwnerCountsByProjectIDs :many +SELECT + project_id, + COUNT(DISTINCT owner_id) +FROM + workspaces +WHERE + project_id = ANY(@ids :: uuid [ ]) +GROUP BY + project_id, + owner_id; + +-- name: InsertWorkspace :one +INSERT INTO + workspaces ( + id, + created_at, + updated_at, + owner_id, + project_id, + name + ) +VALUES + ($1, $2, $3, $4, $5, $6) RETURNING *; + +-- name: UpdateWorkspaceDeletedByID :exec +UPDATE + workspaces +SET + deleted = $2 +WHERE + id = $1; diff --git a/coderd/database/query.sql b/coderd/database/query.sql deleted file mode 100644 index bfe1dc5afa33f..0000000000000 --- a/coderd/database/query.sql +++ /dev/null @@ -1,791 +0,0 @@ --- Database queries are generated using sqlc. See: --- https://docs.sqlc.dev/en/latest/tutorials/getting-started-postgresql.html --- --- Run "make gen" to generate models and query functions. -; - --- Acquires the lock for a single job that isn't started, completed, --- canceled, and that matches an array of provisioner types. --- --- SKIP LOCKED is used to jump over locked rows. This prevents --- multiple provisioners from acquiring the same jobs. See: --- https://www.postgresql.org/docs/9.5/sql-select.html#SQL-FOR-UPDATE-SHARE --- name: AcquireProvisionerJob :one -UPDATE - provisioner_jobs -SET - started_at = @started_at, - updated_at = @started_at, - worker_id = @worker_id -WHERE - id = ( - SELECT - id - FROM - provisioner_jobs AS nested - WHERE - nested.started_at IS NULL - AND nested.canceled_at IS NULL - AND nested.completed_at IS NULL - AND nested.provisioner = ANY(@types :: provisioner_type [ ]) - ORDER BY - nested.created_at FOR - UPDATE - SKIP LOCKED - LIMIT - 1 - ) RETURNING *; - --- name: DeleteParameterValueByID :exec -DELETE FROM - parameter_values -WHERE - id = $1; - --- name: GetAPIKeyByID :one -SELECT - * -FROM - api_keys -WHERE - id = $1 -LIMIT - 1; - --- name: GetFileByHash :one -SELECT - * -FROM - files -WHERE - hash = $1 -LIMIT - 1; - --- name: GetUserByID :one -SELECT - * -FROM - users -WHERE - id = $1 -LIMIT - 1; - --- name: GetUserByEmailOrUsername :one -SELECT - * -FROM - users -WHERE - LOWER(username) = LOWER(@username) - OR email = @email -LIMIT - 1; - --- name: GetUserCount :one -SELECT - COUNT(*) -FROM - users; - --- name: GetOrganizationByID :one -SELECT - * -FROM - organizations -WHERE - id = $1; - --- name: GetOrganizationByName :one -SELECT - * -FROM - organizations -WHERE - LOWER(name) = LOWER(@name) -LIMIT - 1; - --- name: GetOrganizationsByUserID :many -SELECT - * -FROM - organizations -WHERE - id = ( - SELECT - organization_id - FROM - organization_members - WHERE - user_id = $1 - ); - --- name: GetOrganizationMemberByUserID :one -SELECT - * -FROM - organization_members -WHERE - organization_id = $1 - AND user_id = $2 -LIMIT - 1; - --- name: GetParameterValuesByScope :many -SELECT - * -FROM - parameter_values -WHERE - scope = $1 - AND scope_id = $2; - --- name: GetParameterValueByScopeAndName :one -SELECT - * -FROM - parameter_values -WHERE - scope = $1 - AND scope_id = $2 - AND name = $3 -LIMIT - 1; - --- name: GetProjectByID :one -SELECT - * -FROM - projects -WHERE - id = $1 -LIMIT - 1; - --- name: GetProjectsByIDs :many -SELECT - * -FROM - projects -WHERE - id = ANY(@ids :: uuid [ ]); - --- name: GetProjectByOrganizationAndName :one -SELECT - * -FROM - projects -WHERE - organization_id = @organization_id - AND deleted = @deleted - AND LOWER(name) = LOWER(@name) -LIMIT - 1; - --- name: GetProjectsByOrganization :many -SELECT - * -FROM - projects -WHERE - organization_id = $1 - AND deleted = $2; - --- name: GetParameterSchemasByJobID :many -SELECT - * -FROM - parameter_schemas -WHERE - job_id = $1; - --- name: GetProjectVersionsByProjectID :many -SELECT - * -FROM - project_versions -WHERE - project_id = $1 :: uuid; - --- name: GetProjectVersionByJobID :one -SELECT - * -FROM - project_versions -WHERE - job_id = $1; - --- name: GetProjectVersionByProjectIDAndName :one -SELECT - * -FROM - project_versions -WHERE - project_id = $1 - AND name = $2; - --- name: GetProjectVersionByID :one -SELECT - * -FROM - project_versions -WHERE - id = $1; - --- name: GetProvisionerLogsByIDBetween :many -SELECT - * -FROM - provisioner_job_logs -WHERE - job_id = @job_id - AND ( - created_at >= @created_after - OR created_at <= @created_before - ) -ORDER BY - created_at; - --- name: GetProvisionerDaemonByID :one -SELECT - * -FROM - provisioner_daemons -WHERE - id = $1; - --- name: GetProvisionerDaemons :many -SELECT - * -FROM - provisioner_daemons; - --- name: GetWorkspaceAgentByAuthToken :one -SELECT - * -FROM - workspace_agents -WHERE - auth_token = $1 -ORDER BY - created_at DESC; - --- name: GetWorkspaceAgentByInstanceID :one -SELECT - * -FROM - workspace_agents -WHERE - auth_instance_id = @auth_instance_id :: text -ORDER BY - created_at DESC; - --- name: GetProvisionerJobByID :one -SELECT - * -FROM - provisioner_jobs -WHERE - id = $1; - --- name: GetProvisionerJobsByIDs :many -SELECT - * -FROM - provisioner_jobs -WHERE - id = ANY(@ids :: uuid [ ]); - --- name: GetWorkspaceByID :one -SELECT - * -FROM - workspaces -WHERE - id = $1 -LIMIT - 1; - --- name: GetWorkspacesByProjectID :many -SELECT - * -FROM - workspaces -WHERE - project_id = $1 - AND deleted = $2; - --- name: GetWorkspacesByUserID :many -SELECT - * -FROM - workspaces -WHERE - owner_id = $1 - AND deleted = $2; - --- name: GetWorkspaceByUserIDAndName :one -SELECT - * -FROM - workspaces -WHERE - owner_id = @owner_id - AND deleted = @deleted - AND LOWER(name) = LOWER(@name); - --- name: GetWorkspaceOwnerCountsByProjectIDs :many -SELECT - project_id, - COUNT(DISTINCT owner_id) -FROM - workspaces -WHERE - project_id = ANY(@ids :: uuid [ ]) -GROUP BY - project_id, - owner_id; - --- name: GetWorkspaceBuildByID :one -SELECT - * -FROM - workspace_builds -WHERE - id = $1 -LIMIT - 1; - --- name: GetWorkspaceBuildByJobID :one -SELECT - * -FROM - workspace_builds -WHERE - job_id = $1 -LIMIT - 1; - --- name: GetWorkspaceBuildByWorkspaceIDAndName :one -SELECT - * -FROM - workspace_builds -WHERE - workspace_id = $1 - AND name = $2; - --- name: GetWorkspaceBuildByWorkspaceID :many -SELECT - * -FROM - workspace_builds -WHERE - workspace_id = $1; - --- name: GetWorkspaceBuildByWorkspaceIDWithoutAfter :one -SELECT - * -FROM - workspace_builds -WHERE - workspace_id = $1 - AND after_id IS NULL -LIMIT - 1; - --- name: GetWorkspaceBuildsByWorkspaceIDsWithoutAfter :many -SELECT - * -FROM - workspace_builds -WHERE - workspace_id = ANY(@ids :: uuid [ ]) - AND after_id IS NULL; - --- name: GetWorkspaceResourceByID :one -SELECT - * -FROM - workspace_resources -WHERE - id = $1; - --- name: GetWorkspaceResourcesByJobID :many -SELECT - * -FROM - workspace_resources -WHERE - job_id = $1; - --- name: GetWorkspaceAgentByResourceID :one -SELECT - * -FROM - workspace_agents -WHERE - resource_id = $1; - --- name: InsertAPIKey :one -INSERT INTO - api_keys ( - id, - hashed_secret, - user_id, - application, - name, - last_used, - expires_at, - created_at, - updated_at, - login_type, - oidc_access_token, - oidc_refresh_token, - oidc_id_token, - oidc_expiry, - devurl_token - ) -VALUES - ( - $1, - $2, - $3, - $4, - $5, - $6, - $7, - $8, - $9, - $10, - $11, - $12, - $13, - $14, - $15 - ) RETURNING *; - --- name: InsertFile :one -INSERT INTO - files (hash, created_at, created_by, mimetype, data) -VALUES - ($1, $2, $3, $4, $5) RETURNING *; - --- name: InsertProvisionerJobLogs :many -INSERT INTO - provisioner_job_logs -SELECT - unnest(@id :: uuid [ ]) AS id, - @job_id :: uuid AS job_id, - unnest(@created_at :: timestamptz [ ]) AS created_at, - unnest(@source :: log_source [ ]) as source, - unnest(@level :: log_level [ ]) as level, - unnest(@stage :: varchar(128) [ ]) as stage, - unnest(@output :: varchar(1024) [ ]) as output RETURNING *; - --- name: InsertOrganization :one -INSERT INTO - organizations (id, name, description, created_at, updated_at) -VALUES - ($1, $2, $3, $4, $5) RETURNING *; - --- name: InsertOrganizationMember :one -INSERT INTO - organization_members ( - organization_id, - user_id, - created_at, - updated_at, - roles - ) -VALUES - ($1, $2, $3, $4, $5) RETURNING *; - --- name: InsertParameterValue :one -INSERT INTO - parameter_values ( - id, - name, - created_at, - updated_at, - scope, - scope_id, - source_scheme, - source_value, - destination_scheme - ) -VALUES - ($1, $2, $3, $4, $5, $6, $7, $8, $9) RETURNING *; - --- name: InsertProject :one -INSERT INTO - projects ( - id, - created_at, - updated_at, - organization_id, - name, - provisioner, - active_version_id - ) -VALUES - ($1, $2, $3, $4, $5, $6, $7) RETURNING *; - --- name: InsertWorkspaceResource :one -INSERT INTO - workspace_resources ( - id, - created_at, - job_id, - transition, - address, - type, - name, - agent_id - ) -VALUES - ($1, $2, $3, $4, $5, $6, $7, $8) RETURNING *; - --- name: InsertProjectVersion :one -INSERT INTO - project_versions ( - id, - project_id, - organization_id, - created_at, - updated_at, - name, - description, - job_id - ) -VALUES - ($1, $2, $3, $4, $5, $6, $7, $8) RETURNING *; - --- name: InsertParameterSchema :one -INSERT INTO - parameter_schemas ( - id, - created_at, - job_id, - name, - description, - default_source_scheme, - default_source_value, - allow_override_source, - default_destination_scheme, - allow_override_destination, - default_refresh, - redisplay_value, - validation_error, - validation_condition, - validation_type_system, - validation_value_type - ) -VALUES - ( - $1, - $2, - $3, - $4, - $5, - $6, - $7, - $8, - $9, - $10, - $11, - $12, - $13, - $14, - $15, - $16 - ) RETURNING *; - --- name: InsertProvisionerDaemon :one -INSERT INTO - provisioner_daemons (id, created_at, organization_id, name, provisioners) -VALUES - ($1, $2, $3, $4, $5) RETURNING *; - --- name: InsertProvisionerJob :one -INSERT INTO - provisioner_jobs ( - id, - created_at, - updated_at, - organization_id, - initiator_id, - provisioner, - storage_method, - storage_source, - type, - input - ) -VALUES - ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10) RETURNING *; - --- name: InsertUser :one -INSERT INTO - users ( - id, - email, - name, - login_type, - revoked, - hashed_password, - created_at, - updated_at, - username - ) -VALUES - ($1, $2, $3, $4, false, $5, $6, $7, $8) RETURNING *; - --- name: InsertWorkspace :one -INSERT INTO - workspaces ( - id, - created_at, - updated_at, - owner_id, - project_id, - name - ) -VALUES - ($1, $2, $3, $4, $5, $6) RETURNING *; - --- name: InsertWorkspaceAgent :one -INSERT INTO - workspace_agents ( - id, - created_at, - updated_at, - resource_id, - auth_token, - auth_instance_id, - environment_variables, - startup_script, - instance_metadata, - resource_metadata - ) -VALUES - ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10) RETURNING *; - --- name: InsertWorkspaceBuild :one -INSERT INTO - workspace_builds ( - id, - created_at, - updated_at, - workspace_id, - project_version_id, - before_id, - name, - transition, - initiator_id, - job_id, - provisioner_state - ) -VALUES - ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11) RETURNING *; - --- name: UpdateAPIKeyByID :exec -UPDATE - api_keys -SET - last_used = $2, - expires_at = $3, - oidc_access_token = $4, - oidc_refresh_token = $5, - oidc_expiry = $6 -WHERE - id = $1; - --- name: UpdateProjectActiveVersionByID :exec -UPDATE - projects -SET - active_version_id = $2 -WHERE - id = $1; - --- name: UpdateProjectDeletedByID :exec -UPDATE - projects -SET - deleted = $2 -WHERE - id = $1; - --- name: UpdateProjectVersionByID :exec -UPDATE - project_versions -SET - project_id = $2, - updated_at = $3 -WHERE - id = $1; - --- name: UpdateProvisionerDaemonByID :exec -UPDATE - provisioner_daemons -SET - updated_at = $2, - provisioners = $3 -WHERE - id = $1; - --- name: UpdateProvisionerJobByID :exec -UPDATE - provisioner_jobs -SET - updated_at = $2 -WHERE - id = $1; - --- name: UpdateProvisionerJobWithCancelByID :exec -UPDATE - provisioner_jobs -SET - canceled_at = $2 -WHERE - id = $1; - --- name: UpdateProvisionerJobWithCompleteByID :exec -UPDATE - provisioner_jobs -SET - updated_at = $2, - completed_at = $3, - error = $4 -WHERE - id = $1; - --- name: UpdateWorkspaceDeletedByID :exec -UPDATE - workspaces -SET - deleted = $2 -WHERE - id = $1; - --- name: UpdateWorkspaceAgentConnectionByID :exec -UPDATE - workspace_agents -SET - first_connected_at = $2, - last_connected_at = $3, - disconnected_at = $4 -WHERE - id = $1; - --- name: UpdateWorkspaceBuildByID :exec -UPDATE - workspace_builds -SET - updated_at = $2, - after_id = $3, - provisioner_state = $4 -WHERE - id = $1; diff --git a/coderd/database/query.sql.go b/coderd/database/query.sql.go deleted file mode 100644 index f0572bc5610e6..0000000000000 --- a/coderd/database/query.sql.go +++ /dev/null @@ -1,2670 +0,0 @@ -// Code generated by sqlc. DO NOT EDIT. -// source: query.sql - -package database - -import ( - "context" - "database/sql" - "encoding/json" - "time" - - "github.com/google/uuid" - "github.com/lib/pq" - "github.com/tabbed/pqtype" -) - -const acquireProvisionerJob = `-- name: AcquireProvisionerJob :one -UPDATE - provisioner_jobs -SET - started_at = $1, - updated_at = $1, - worker_id = $2 -WHERE - id = ( - SELECT - id - FROM - provisioner_jobs AS nested - WHERE - nested.started_at IS NULL - AND nested.canceled_at IS NULL - AND nested.completed_at IS NULL - AND nested.provisioner = ANY($3 :: provisioner_type [ ]) - ORDER BY - nested.created_at FOR - UPDATE - SKIP LOCKED - LIMIT - 1 - ) RETURNING id, created_at, updated_at, started_at, canceled_at, completed_at, error, organization_id, initiator_id, provisioner, storage_method, storage_source, type, input, worker_id -` - -type AcquireProvisionerJobParams struct { - StartedAt sql.NullTime `db:"started_at" json:"started_at"` - WorkerID uuid.NullUUID `db:"worker_id" json:"worker_id"` - Types []ProvisionerType `db:"types" json:"types"` -} - -// Acquires the lock for a single job that isn't started, completed, -// canceled, and that matches an array of provisioner types. -// -// SKIP LOCKED is used to jump over locked rows. This prevents -// multiple provisioners from acquiring the same jobs. See: -// https://www.postgresql.org/docs/9.5/sql-select.html#SQL-FOR-UPDATE-SHARE -func (q *sqlQuerier) AcquireProvisionerJob(ctx context.Context, arg AcquireProvisionerJobParams) (ProvisionerJob, error) { - row := q.db.QueryRowContext(ctx, acquireProvisionerJob, arg.StartedAt, arg.WorkerID, pq.Array(arg.Types)) - var i ProvisionerJob - err := row.Scan( - &i.ID, - &i.CreatedAt, - &i.UpdatedAt, - &i.StartedAt, - &i.CanceledAt, - &i.CompletedAt, - &i.Error, - &i.OrganizationID, - &i.InitiatorID, - &i.Provisioner, - &i.StorageMethod, - &i.StorageSource, - &i.Type, - &i.Input, - &i.WorkerID, - ) - return i, err -} - -const deleteParameterValueByID = `-- name: DeleteParameterValueByID :exec -DELETE FROM - parameter_values -WHERE - id = $1 -` - -func (q *sqlQuerier) DeleteParameterValueByID(ctx context.Context, id uuid.UUID) error { - _, err := q.db.ExecContext(ctx, deleteParameterValueByID, id) - return err -} - -const getAPIKeyByID = `-- name: GetAPIKeyByID :one -SELECT - id, hashed_secret, user_id, application, name, last_used, expires_at, created_at, updated_at, login_type, oidc_access_token, oidc_refresh_token, oidc_id_token, oidc_expiry, devurl_token -FROM - api_keys -WHERE - id = $1 -LIMIT - 1 -` - -func (q *sqlQuerier) GetAPIKeyByID(ctx context.Context, id string) (APIKey, error) { - row := q.db.QueryRowContext(ctx, getAPIKeyByID, id) - var i APIKey - err := row.Scan( - &i.ID, - &i.HashedSecret, - &i.UserID, - &i.Application, - &i.Name, - &i.LastUsed, - &i.ExpiresAt, - &i.CreatedAt, - &i.UpdatedAt, - &i.LoginType, - &i.OIDCAccessToken, - &i.OIDCRefreshToken, - &i.OIDCIDToken, - &i.OIDCExpiry, - &i.DevurlToken, - ) - return i, err -} - -const getFileByHash = `-- name: GetFileByHash :one -SELECT - hash, created_at, created_by, mimetype, data -FROM - files -WHERE - hash = $1 -LIMIT - 1 -` - -func (q *sqlQuerier) GetFileByHash(ctx context.Context, hash string) (File, error) { - row := q.db.QueryRowContext(ctx, getFileByHash, hash) - var i File - err := row.Scan( - &i.Hash, - &i.CreatedAt, - &i.CreatedBy, - &i.Mimetype, - &i.Data, - ) - return i, err -} - -const getOrganizationByID = `-- name: GetOrganizationByID :one -SELECT - id, name, description, created_at, updated_at -FROM - organizations -WHERE - id = $1 -` - -func (q *sqlQuerier) GetOrganizationByID(ctx context.Context, id uuid.UUID) (Organization, error) { - row := q.db.QueryRowContext(ctx, getOrganizationByID, id) - var i Organization - err := row.Scan( - &i.ID, - &i.Name, - &i.Description, - &i.CreatedAt, - &i.UpdatedAt, - ) - return i, err -} - -const getOrganizationByName = `-- name: GetOrganizationByName :one -SELECT - id, name, description, created_at, updated_at -FROM - organizations -WHERE - LOWER(name) = LOWER($1) -LIMIT - 1 -` - -func (q *sqlQuerier) GetOrganizationByName(ctx context.Context, name string) (Organization, error) { - row := q.db.QueryRowContext(ctx, getOrganizationByName, name) - var i Organization - err := row.Scan( - &i.ID, - &i.Name, - &i.Description, - &i.CreatedAt, - &i.UpdatedAt, - ) - return i, err -} - -const getOrganizationMemberByUserID = `-- name: GetOrganizationMemberByUserID :one -SELECT - user_id, organization_id, created_at, updated_at, roles -FROM - organization_members -WHERE - organization_id = $1 - AND user_id = $2 -LIMIT - 1 -` - -type GetOrganizationMemberByUserIDParams struct { - OrganizationID uuid.UUID `db:"organization_id" json:"organization_id"` - UserID uuid.UUID `db:"user_id" json:"user_id"` -} - -func (q *sqlQuerier) GetOrganizationMemberByUserID(ctx context.Context, arg GetOrganizationMemberByUserIDParams) (OrganizationMember, error) { - row := q.db.QueryRowContext(ctx, getOrganizationMemberByUserID, arg.OrganizationID, arg.UserID) - var i OrganizationMember - err := row.Scan( - &i.UserID, - &i.OrganizationID, - &i.CreatedAt, - &i.UpdatedAt, - pq.Array(&i.Roles), - ) - return i, err -} - -const getOrganizationsByUserID = `-- name: GetOrganizationsByUserID :many -SELECT - id, name, description, created_at, updated_at -FROM - organizations -WHERE - id = ( - SELECT - organization_id - FROM - organization_members - WHERE - user_id = $1 - ) -` - -func (q *sqlQuerier) GetOrganizationsByUserID(ctx context.Context, userID uuid.UUID) ([]Organization, error) { - rows, err := q.db.QueryContext(ctx, getOrganizationsByUserID, userID) - if err != nil { - return nil, err - } - defer rows.Close() - var items []Organization - for rows.Next() { - var i Organization - if err := rows.Scan( - &i.ID, - &i.Name, - &i.Description, - &i.CreatedAt, - &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 getParameterSchemasByJobID = `-- name: GetParameterSchemasByJobID :many -SELECT - id, created_at, job_id, name, description, default_source_scheme, default_source_value, allow_override_source, default_destination_scheme, allow_override_destination, default_refresh, redisplay_value, validation_error, validation_condition, validation_type_system, validation_value_type -FROM - parameter_schemas -WHERE - job_id = $1 -` - -func (q *sqlQuerier) GetParameterSchemasByJobID(ctx context.Context, jobID uuid.UUID) ([]ParameterSchema, error) { - rows, err := q.db.QueryContext(ctx, getParameterSchemasByJobID, jobID) - if err != nil { - return nil, err - } - defer rows.Close() - var items []ParameterSchema - for rows.Next() { - var i ParameterSchema - if err := rows.Scan( - &i.ID, - &i.CreatedAt, - &i.JobID, - &i.Name, - &i.Description, - &i.DefaultSourceScheme, - &i.DefaultSourceValue, - &i.AllowOverrideSource, - &i.DefaultDestinationScheme, - &i.AllowOverrideDestination, - &i.DefaultRefresh, - &i.RedisplayValue, - &i.ValidationError, - &i.ValidationCondition, - &i.ValidationTypeSystem, - &i.ValidationValueType, - ); 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 getParameterValueByScopeAndName = `-- name: GetParameterValueByScopeAndName :one -SELECT - id, created_at, updated_at, scope, scope_id, name, source_scheme, source_value, destination_scheme -FROM - parameter_values -WHERE - scope = $1 - AND scope_id = $2 - AND name = $3 -LIMIT - 1 -` - -type GetParameterValueByScopeAndNameParams struct { - Scope ParameterScope `db:"scope" json:"scope"` - ScopeID uuid.UUID `db:"scope_id" json:"scope_id"` - Name string `db:"name" json:"name"` -} - -func (q *sqlQuerier) GetParameterValueByScopeAndName(ctx context.Context, arg GetParameterValueByScopeAndNameParams) (ParameterValue, error) { - row := q.db.QueryRowContext(ctx, getParameterValueByScopeAndName, arg.Scope, arg.ScopeID, arg.Name) - var i ParameterValue - err := row.Scan( - &i.ID, - &i.CreatedAt, - &i.UpdatedAt, - &i.Scope, - &i.ScopeID, - &i.Name, - &i.SourceScheme, - &i.SourceValue, - &i.DestinationScheme, - ) - return i, err -} - -const getParameterValuesByScope = `-- name: GetParameterValuesByScope :many -SELECT - id, created_at, updated_at, scope, scope_id, name, source_scheme, source_value, destination_scheme -FROM - parameter_values -WHERE - scope = $1 - AND scope_id = $2 -` - -type GetParameterValuesByScopeParams struct { - Scope ParameterScope `db:"scope" json:"scope"` - ScopeID uuid.UUID `db:"scope_id" json:"scope_id"` -} - -func (q *sqlQuerier) GetParameterValuesByScope(ctx context.Context, arg GetParameterValuesByScopeParams) ([]ParameterValue, error) { - rows, err := q.db.QueryContext(ctx, getParameterValuesByScope, arg.Scope, arg.ScopeID) - if err != nil { - return nil, err - } - defer rows.Close() - var items []ParameterValue - for rows.Next() { - var i ParameterValue - if err := rows.Scan( - &i.ID, - &i.CreatedAt, - &i.UpdatedAt, - &i.Scope, - &i.ScopeID, - &i.Name, - &i.SourceScheme, - &i.SourceValue, - &i.DestinationScheme, - ); 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 getProjectByID = `-- name: GetProjectByID :one -SELECT - id, created_at, updated_at, organization_id, deleted, name, provisioner, active_version_id -FROM - projects -WHERE - id = $1 -LIMIT - 1 -` - -func (q *sqlQuerier) GetProjectByID(ctx context.Context, id uuid.UUID) (Project, error) { - row := q.db.QueryRowContext(ctx, getProjectByID, id) - var i Project - err := row.Scan( - &i.ID, - &i.CreatedAt, - &i.UpdatedAt, - &i.OrganizationID, - &i.Deleted, - &i.Name, - &i.Provisioner, - &i.ActiveVersionID, - ) - return i, err -} - -const getProjectByOrganizationAndName = `-- name: GetProjectByOrganizationAndName :one -SELECT - id, created_at, updated_at, organization_id, deleted, name, provisioner, active_version_id -FROM - projects -WHERE - organization_id = $1 - AND deleted = $2 - AND LOWER(name) = LOWER($3) -LIMIT - 1 -` - -type GetProjectByOrganizationAndNameParams struct { - OrganizationID uuid.UUID `db:"organization_id" json:"organization_id"` - Deleted bool `db:"deleted" json:"deleted"` - Name string `db:"name" json:"name"` -} - -func (q *sqlQuerier) GetProjectByOrganizationAndName(ctx context.Context, arg GetProjectByOrganizationAndNameParams) (Project, error) { - row := q.db.QueryRowContext(ctx, getProjectByOrganizationAndName, arg.OrganizationID, arg.Deleted, arg.Name) - var i Project - err := row.Scan( - &i.ID, - &i.CreatedAt, - &i.UpdatedAt, - &i.OrganizationID, - &i.Deleted, - &i.Name, - &i.Provisioner, - &i.ActiveVersionID, - ) - return i, err -} - -const getProjectVersionByID = `-- name: GetProjectVersionByID :one -SELECT - id, project_id, organization_id, created_at, updated_at, name, description, job_id -FROM - project_versions -WHERE - id = $1 -` - -func (q *sqlQuerier) GetProjectVersionByID(ctx context.Context, id uuid.UUID) (ProjectVersion, error) { - row := q.db.QueryRowContext(ctx, getProjectVersionByID, id) - var i ProjectVersion - err := row.Scan( - &i.ID, - &i.ProjectID, - &i.OrganizationID, - &i.CreatedAt, - &i.UpdatedAt, - &i.Name, - &i.Description, - &i.JobID, - ) - return i, err -} - -const getProjectVersionByJobID = `-- name: GetProjectVersionByJobID :one -SELECT - id, project_id, organization_id, created_at, updated_at, name, description, job_id -FROM - project_versions -WHERE - job_id = $1 -` - -func (q *sqlQuerier) GetProjectVersionByJobID(ctx context.Context, jobID uuid.UUID) (ProjectVersion, error) { - row := q.db.QueryRowContext(ctx, getProjectVersionByJobID, jobID) - var i ProjectVersion - err := row.Scan( - &i.ID, - &i.ProjectID, - &i.OrganizationID, - &i.CreatedAt, - &i.UpdatedAt, - &i.Name, - &i.Description, - &i.JobID, - ) - return i, err -} - -const getProjectVersionByProjectIDAndName = `-- name: GetProjectVersionByProjectIDAndName :one -SELECT - id, project_id, organization_id, created_at, updated_at, name, description, job_id -FROM - project_versions -WHERE - project_id = $1 - AND name = $2 -` - -type GetProjectVersionByProjectIDAndNameParams struct { - ProjectID uuid.NullUUID `db:"project_id" json:"project_id"` - Name string `db:"name" json:"name"` -} - -func (q *sqlQuerier) GetProjectVersionByProjectIDAndName(ctx context.Context, arg GetProjectVersionByProjectIDAndNameParams) (ProjectVersion, error) { - row := q.db.QueryRowContext(ctx, getProjectVersionByProjectIDAndName, arg.ProjectID, arg.Name) - var i ProjectVersion - err := row.Scan( - &i.ID, - &i.ProjectID, - &i.OrganizationID, - &i.CreatedAt, - &i.UpdatedAt, - &i.Name, - &i.Description, - &i.JobID, - ) - return i, err -} - -const getProjectVersionsByProjectID = `-- name: GetProjectVersionsByProjectID :many -SELECT - id, project_id, organization_id, created_at, updated_at, name, description, job_id -FROM - project_versions -WHERE - project_id = $1 :: uuid -` - -func (q *sqlQuerier) GetProjectVersionsByProjectID(ctx context.Context, dollar_1 uuid.UUID) ([]ProjectVersion, error) { - rows, err := q.db.QueryContext(ctx, getProjectVersionsByProjectID, dollar_1) - if err != nil { - return nil, err - } - defer rows.Close() - var items []ProjectVersion - for rows.Next() { - var i ProjectVersion - if err := rows.Scan( - &i.ID, - &i.ProjectID, - &i.OrganizationID, - &i.CreatedAt, - &i.UpdatedAt, - &i.Name, - &i.Description, - &i.JobID, - ); 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 getProjectsByIDs = `-- name: GetProjectsByIDs :many -SELECT - id, created_at, updated_at, organization_id, deleted, name, provisioner, active_version_id -FROM - projects -WHERE - id = ANY($1 :: uuid [ ]) -` - -func (q *sqlQuerier) GetProjectsByIDs(ctx context.Context, ids []uuid.UUID) ([]Project, error) { - rows, err := q.db.QueryContext(ctx, getProjectsByIDs, pq.Array(ids)) - if err != nil { - return nil, err - } - defer rows.Close() - var items []Project - for rows.Next() { - var i Project - if err := rows.Scan( - &i.ID, - &i.CreatedAt, - &i.UpdatedAt, - &i.OrganizationID, - &i.Deleted, - &i.Name, - &i.Provisioner, - &i.ActiveVersionID, - ); 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 getProjectsByOrganization = `-- name: GetProjectsByOrganization :many -SELECT - id, created_at, updated_at, organization_id, deleted, name, provisioner, active_version_id -FROM - projects -WHERE - organization_id = $1 - AND deleted = $2 -` - -type GetProjectsByOrganizationParams struct { - OrganizationID uuid.UUID `db:"organization_id" json:"organization_id"` - Deleted bool `db:"deleted" json:"deleted"` -} - -func (q *sqlQuerier) GetProjectsByOrganization(ctx context.Context, arg GetProjectsByOrganizationParams) ([]Project, error) { - rows, err := q.db.QueryContext(ctx, getProjectsByOrganization, arg.OrganizationID, arg.Deleted) - if err != nil { - return nil, err - } - defer rows.Close() - var items []Project - for rows.Next() { - var i Project - if err := rows.Scan( - &i.ID, - &i.CreatedAt, - &i.UpdatedAt, - &i.OrganizationID, - &i.Deleted, - &i.Name, - &i.Provisioner, - &i.ActiveVersionID, - ); 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 getProvisionerDaemonByID = `-- name: GetProvisionerDaemonByID :one -SELECT - id, created_at, updated_at, organization_id, name, provisioners -FROM - provisioner_daemons -WHERE - id = $1 -` - -func (q *sqlQuerier) GetProvisionerDaemonByID(ctx context.Context, id uuid.UUID) (ProvisionerDaemon, error) { - row := q.db.QueryRowContext(ctx, getProvisionerDaemonByID, id) - var i ProvisionerDaemon - err := row.Scan( - &i.ID, - &i.CreatedAt, - &i.UpdatedAt, - &i.OrganizationID, - &i.Name, - pq.Array(&i.Provisioners), - ) - return i, err -} - -const getProvisionerDaemons = `-- name: GetProvisionerDaemons :many -SELECT - id, created_at, updated_at, organization_id, name, provisioners -FROM - provisioner_daemons -` - -func (q *sqlQuerier) GetProvisionerDaemons(ctx context.Context) ([]ProvisionerDaemon, error) { - rows, err := q.db.QueryContext(ctx, getProvisionerDaemons) - if err != nil { - return nil, err - } - defer rows.Close() - var items []ProvisionerDaemon - for rows.Next() { - var i ProvisionerDaemon - if err := rows.Scan( - &i.ID, - &i.CreatedAt, - &i.UpdatedAt, - &i.OrganizationID, - &i.Name, - pq.Array(&i.Provisioners), - ); 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 getProvisionerJobByID = `-- name: GetProvisionerJobByID :one -SELECT - id, created_at, updated_at, started_at, canceled_at, completed_at, error, organization_id, initiator_id, provisioner, storage_method, storage_source, type, input, worker_id -FROM - provisioner_jobs -WHERE - id = $1 -` - -func (q *sqlQuerier) GetProvisionerJobByID(ctx context.Context, id uuid.UUID) (ProvisionerJob, error) { - row := q.db.QueryRowContext(ctx, getProvisionerJobByID, id) - var i ProvisionerJob - err := row.Scan( - &i.ID, - &i.CreatedAt, - &i.UpdatedAt, - &i.StartedAt, - &i.CanceledAt, - &i.CompletedAt, - &i.Error, - &i.OrganizationID, - &i.InitiatorID, - &i.Provisioner, - &i.StorageMethod, - &i.StorageSource, - &i.Type, - &i.Input, - &i.WorkerID, - ) - return i, err -} - -const getProvisionerJobsByIDs = `-- name: GetProvisionerJobsByIDs :many -SELECT - id, created_at, updated_at, started_at, canceled_at, completed_at, error, organization_id, initiator_id, provisioner, storage_method, storage_source, type, input, worker_id -FROM - provisioner_jobs -WHERE - id = ANY($1 :: uuid [ ]) -` - -func (q *sqlQuerier) GetProvisionerJobsByIDs(ctx context.Context, ids []uuid.UUID) ([]ProvisionerJob, error) { - rows, err := q.db.QueryContext(ctx, getProvisionerJobsByIDs, pq.Array(ids)) - if err != nil { - return nil, err - } - defer rows.Close() - var items []ProvisionerJob - for rows.Next() { - var i ProvisionerJob - if err := rows.Scan( - &i.ID, - &i.CreatedAt, - &i.UpdatedAt, - &i.StartedAt, - &i.CanceledAt, - &i.CompletedAt, - &i.Error, - &i.OrganizationID, - &i.InitiatorID, - &i.Provisioner, - &i.StorageMethod, - &i.StorageSource, - &i.Type, - &i.Input, - &i.WorkerID, - ); 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 getProvisionerLogsByIDBetween = `-- name: GetProvisionerLogsByIDBetween :many -SELECT - id, job_id, created_at, source, level, stage, output -FROM - provisioner_job_logs -WHERE - job_id = $1 - AND ( - created_at >= $2 - OR created_at <= $3 - ) -ORDER BY - created_at -` - -type GetProvisionerLogsByIDBetweenParams struct { - JobID uuid.UUID `db:"job_id" json:"job_id"` - CreatedAfter time.Time `db:"created_after" json:"created_after"` - CreatedBefore time.Time `db:"created_before" json:"created_before"` -} - -func (q *sqlQuerier) GetProvisionerLogsByIDBetween(ctx context.Context, arg GetProvisionerLogsByIDBetweenParams) ([]ProvisionerJobLog, error) { - rows, err := q.db.QueryContext(ctx, getProvisionerLogsByIDBetween, arg.JobID, arg.CreatedAfter, arg.CreatedBefore) - if err != nil { - return nil, err - } - defer rows.Close() - var items []ProvisionerJobLog - for rows.Next() { - var i ProvisionerJobLog - if err := rows.Scan( - &i.ID, - &i.JobID, - &i.CreatedAt, - &i.Source, - &i.Level, - &i.Stage, - &i.Output, - ); 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 getUserByEmailOrUsername = `-- name: GetUserByEmailOrUsername :one -SELECT - id, email, name, revoked, login_type, hashed_password, created_at, updated_at, username -FROM - users -WHERE - LOWER(username) = LOWER($1) - OR email = $2 -LIMIT - 1 -` - -type GetUserByEmailOrUsernameParams struct { - Username string `db:"username" json:"username"` - Email string `db:"email" json:"email"` -} - -func (q *sqlQuerier) GetUserByEmailOrUsername(ctx context.Context, arg GetUserByEmailOrUsernameParams) (User, error) { - row := q.db.QueryRowContext(ctx, getUserByEmailOrUsername, arg.Username, arg.Email) - var i User - err := row.Scan( - &i.ID, - &i.Email, - &i.Name, - &i.Revoked, - &i.LoginType, - &i.HashedPassword, - &i.CreatedAt, - &i.UpdatedAt, - &i.Username, - ) - return i, err -} - -const getUserByID = `-- name: GetUserByID :one -SELECT - id, email, name, revoked, login_type, hashed_password, created_at, updated_at, username -FROM - users -WHERE - id = $1 -LIMIT - 1 -` - -func (q *sqlQuerier) GetUserByID(ctx context.Context, id uuid.UUID) (User, error) { - row := q.db.QueryRowContext(ctx, getUserByID, id) - var i User - err := row.Scan( - &i.ID, - &i.Email, - &i.Name, - &i.Revoked, - &i.LoginType, - &i.HashedPassword, - &i.CreatedAt, - &i.UpdatedAt, - &i.Username, - ) - return i, err -} - -const getUserCount = `-- name: GetUserCount :one -SELECT - COUNT(*) -FROM - users -` - -func (q *sqlQuerier) GetUserCount(ctx context.Context) (int64, error) { - row := q.db.QueryRowContext(ctx, getUserCount) - var count int64 - err := row.Scan(&count) - return count, err -} - -const getWorkspaceAgentByAuthToken = `-- name: GetWorkspaceAgentByAuthToken :one -SELECT - id, created_at, updated_at, first_connected_at, last_connected_at, disconnected_at, resource_id, auth_token, auth_instance_id, environment_variables, startup_script, instance_metadata, resource_metadata -FROM - workspace_agents -WHERE - auth_token = $1 -ORDER BY - created_at DESC -` - -func (q *sqlQuerier) GetWorkspaceAgentByAuthToken(ctx context.Context, authToken uuid.UUID) (WorkspaceAgent, error) { - row := q.db.QueryRowContext(ctx, getWorkspaceAgentByAuthToken, authToken) - var i WorkspaceAgent - err := row.Scan( - &i.ID, - &i.CreatedAt, - &i.UpdatedAt, - &i.FirstConnectedAt, - &i.LastConnectedAt, - &i.DisconnectedAt, - &i.ResourceID, - &i.AuthToken, - &i.AuthInstanceID, - &i.EnvironmentVariables, - &i.StartupScript, - &i.InstanceMetadata, - &i.ResourceMetadata, - ) - return i, err -} - -const getWorkspaceAgentByInstanceID = `-- name: GetWorkspaceAgentByInstanceID :one -SELECT - id, created_at, updated_at, first_connected_at, last_connected_at, disconnected_at, resource_id, auth_token, auth_instance_id, environment_variables, startup_script, instance_metadata, resource_metadata -FROM - workspace_agents -WHERE - auth_instance_id = $1 :: text -ORDER BY - created_at DESC -` - -func (q *sqlQuerier) GetWorkspaceAgentByInstanceID(ctx context.Context, authInstanceID string) (WorkspaceAgent, error) { - row := q.db.QueryRowContext(ctx, getWorkspaceAgentByInstanceID, authInstanceID) - var i WorkspaceAgent - err := row.Scan( - &i.ID, - &i.CreatedAt, - &i.UpdatedAt, - &i.FirstConnectedAt, - &i.LastConnectedAt, - &i.DisconnectedAt, - &i.ResourceID, - &i.AuthToken, - &i.AuthInstanceID, - &i.EnvironmentVariables, - &i.StartupScript, - &i.InstanceMetadata, - &i.ResourceMetadata, - ) - return i, err -} - -const getWorkspaceAgentByResourceID = `-- name: GetWorkspaceAgentByResourceID :one -SELECT - id, created_at, updated_at, first_connected_at, last_connected_at, disconnected_at, resource_id, auth_token, auth_instance_id, environment_variables, startup_script, instance_metadata, resource_metadata -FROM - workspace_agents -WHERE - resource_id = $1 -` - -func (q *sqlQuerier) GetWorkspaceAgentByResourceID(ctx context.Context, resourceID uuid.UUID) (WorkspaceAgent, error) { - row := q.db.QueryRowContext(ctx, getWorkspaceAgentByResourceID, resourceID) - var i WorkspaceAgent - err := row.Scan( - &i.ID, - &i.CreatedAt, - &i.UpdatedAt, - &i.FirstConnectedAt, - &i.LastConnectedAt, - &i.DisconnectedAt, - &i.ResourceID, - &i.AuthToken, - &i.AuthInstanceID, - &i.EnvironmentVariables, - &i.StartupScript, - &i.InstanceMetadata, - &i.ResourceMetadata, - ) - return i, err -} - -const getWorkspaceBuildByID = `-- name: GetWorkspaceBuildByID :one -SELECT - id, created_at, updated_at, workspace_id, project_version_id, name, before_id, after_id, transition, initiator_id, provisioner_state, job_id -FROM - workspace_builds -WHERE - id = $1 -LIMIT - 1 -` - -func (q *sqlQuerier) GetWorkspaceBuildByID(ctx context.Context, id uuid.UUID) (WorkspaceBuild, error) { - row := q.db.QueryRowContext(ctx, getWorkspaceBuildByID, id) - var i WorkspaceBuild - err := row.Scan( - &i.ID, - &i.CreatedAt, - &i.UpdatedAt, - &i.WorkspaceID, - &i.ProjectVersionID, - &i.Name, - &i.BeforeID, - &i.AfterID, - &i.Transition, - &i.InitiatorID, - &i.ProvisionerState, - &i.JobID, - ) - return i, err -} - -const getWorkspaceBuildByJobID = `-- name: GetWorkspaceBuildByJobID :one -SELECT - id, created_at, updated_at, workspace_id, project_version_id, name, before_id, after_id, transition, initiator_id, provisioner_state, job_id -FROM - workspace_builds -WHERE - job_id = $1 -LIMIT - 1 -` - -func (q *sqlQuerier) GetWorkspaceBuildByJobID(ctx context.Context, jobID uuid.UUID) (WorkspaceBuild, error) { - row := q.db.QueryRowContext(ctx, getWorkspaceBuildByJobID, jobID) - var i WorkspaceBuild - err := row.Scan( - &i.ID, - &i.CreatedAt, - &i.UpdatedAt, - &i.WorkspaceID, - &i.ProjectVersionID, - &i.Name, - &i.BeforeID, - &i.AfterID, - &i.Transition, - &i.InitiatorID, - &i.ProvisionerState, - &i.JobID, - ) - return i, err -} - -const getWorkspaceBuildByWorkspaceID = `-- name: GetWorkspaceBuildByWorkspaceID :many -SELECT - id, created_at, updated_at, workspace_id, project_version_id, name, before_id, after_id, transition, initiator_id, provisioner_state, job_id -FROM - workspace_builds -WHERE - workspace_id = $1 -` - -func (q *sqlQuerier) GetWorkspaceBuildByWorkspaceID(ctx context.Context, workspaceID uuid.UUID) ([]WorkspaceBuild, error) { - rows, err := q.db.QueryContext(ctx, getWorkspaceBuildByWorkspaceID, workspaceID) - if err != nil { - return nil, err - } - defer rows.Close() - var items []WorkspaceBuild - for rows.Next() { - var i WorkspaceBuild - if err := rows.Scan( - &i.ID, - &i.CreatedAt, - &i.UpdatedAt, - &i.WorkspaceID, - &i.ProjectVersionID, - &i.Name, - &i.BeforeID, - &i.AfterID, - &i.Transition, - &i.InitiatorID, - &i.ProvisionerState, - &i.JobID, - ); 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 getWorkspaceBuildByWorkspaceIDAndName = `-- name: GetWorkspaceBuildByWorkspaceIDAndName :one -SELECT - id, created_at, updated_at, workspace_id, project_version_id, name, before_id, after_id, transition, initiator_id, provisioner_state, job_id -FROM - workspace_builds -WHERE - workspace_id = $1 - AND name = $2 -` - -type GetWorkspaceBuildByWorkspaceIDAndNameParams struct { - WorkspaceID uuid.UUID `db:"workspace_id" json:"workspace_id"` - Name string `db:"name" json:"name"` -} - -func (q *sqlQuerier) GetWorkspaceBuildByWorkspaceIDAndName(ctx context.Context, arg GetWorkspaceBuildByWorkspaceIDAndNameParams) (WorkspaceBuild, error) { - row := q.db.QueryRowContext(ctx, getWorkspaceBuildByWorkspaceIDAndName, arg.WorkspaceID, arg.Name) - var i WorkspaceBuild - err := row.Scan( - &i.ID, - &i.CreatedAt, - &i.UpdatedAt, - &i.WorkspaceID, - &i.ProjectVersionID, - &i.Name, - &i.BeforeID, - &i.AfterID, - &i.Transition, - &i.InitiatorID, - &i.ProvisionerState, - &i.JobID, - ) - return i, err -} - -const getWorkspaceBuildByWorkspaceIDWithoutAfter = `-- name: GetWorkspaceBuildByWorkspaceIDWithoutAfter :one -SELECT - id, created_at, updated_at, workspace_id, project_version_id, name, before_id, after_id, transition, initiator_id, provisioner_state, job_id -FROM - workspace_builds -WHERE - workspace_id = $1 - AND after_id IS NULL -LIMIT - 1 -` - -func (q *sqlQuerier) GetWorkspaceBuildByWorkspaceIDWithoutAfter(ctx context.Context, workspaceID uuid.UUID) (WorkspaceBuild, error) { - row := q.db.QueryRowContext(ctx, getWorkspaceBuildByWorkspaceIDWithoutAfter, workspaceID) - var i WorkspaceBuild - err := row.Scan( - &i.ID, - &i.CreatedAt, - &i.UpdatedAt, - &i.WorkspaceID, - &i.ProjectVersionID, - &i.Name, - &i.BeforeID, - &i.AfterID, - &i.Transition, - &i.InitiatorID, - &i.ProvisionerState, - &i.JobID, - ) - return i, err -} - -const getWorkspaceBuildsByWorkspaceIDsWithoutAfter = `-- name: GetWorkspaceBuildsByWorkspaceIDsWithoutAfter :many -SELECT - id, created_at, updated_at, workspace_id, project_version_id, name, before_id, after_id, transition, initiator_id, provisioner_state, job_id -FROM - workspace_builds -WHERE - workspace_id = ANY($1 :: uuid [ ]) - AND after_id IS NULL -` - -func (q *sqlQuerier) GetWorkspaceBuildsByWorkspaceIDsWithoutAfter(ctx context.Context, ids []uuid.UUID) ([]WorkspaceBuild, error) { - rows, err := q.db.QueryContext(ctx, getWorkspaceBuildsByWorkspaceIDsWithoutAfter, pq.Array(ids)) - if err != nil { - return nil, err - } - defer rows.Close() - var items []WorkspaceBuild - for rows.Next() { - var i WorkspaceBuild - if err := rows.Scan( - &i.ID, - &i.CreatedAt, - &i.UpdatedAt, - &i.WorkspaceID, - &i.ProjectVersionID, - &i.Name, - &i.BeforeID, - &i.AfterID, - &i.Transition, - &i.InitiatorID, - &i.ProvisionerState, - &i.JobID, - ); 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 getWorkspaceByID = `-- name: GetWorkspaceByID :one -SELECT - id, created_at, updated_at, owner_id, project_id, deleted, name -FROM - workspaces -WHERE - id = $1 -LIMIT - 1 -` - -func (q *sqlQuerier) GetWorkspaceByID(ctx context.Context, id uuid.UUID) (Workspace, error) { - row := q.db.QueryRowContext(ctx, getWorkspaceByID, id) - var i Workspace - err := row.Scan( - &i.ID, - &i.CreatedAt, - &i.UpdatedAt, - &i.OwnerID, - &i.ProjectID, - &i.Deleted, - &i.Name, - ) - return i, err -} - -const getWorkspaceByUserIDAndName = `-- name: GetWorkspaceByUserIDAndName :one -SELECT - id, created_at, updated_at, owner_id, project_id, deleted, name -FROM - workspaces -WHERE - owner_id = $1 - AND deleted = $2 - AND LOWER(name) = LOWER($3) -` - -type GetWorkspaceByUserIDAndNameParams struct { - OwnerID uuid.UUID `db:"owner_id" json:"owner_id"` - Deleted bool `db:"deleted" json:"deleted"` - Name string `db:"name" json:"name"` -} - -func (q *sqlQuerier) GetWorkspaceByUserIDAndName(ctx context.Context, arg GetWorkspaceByUserIDAndNameParams) (Workspace, error) { - row := q.db.QueryRowContext(ctx, getWorkspaceByUserIDAndName, arg.OwnerID, arg.Deleted, arg.Name) - var i Workspace - err := row.Scan( - &i.ID, - &i.CreatedAt, - &i.UpdatedAt, - &i.OwnerID, - &i.ProjectID, - &i.Deleted, - &i.Name, - ) - return i, err -} - -const getWorkspaceOwnerCountsByProjectIDs = `-- name: GetWorkspaceOwnerCountsByProjectIDs :many -SELECT - project_id, - COUNT(DISTINCT owner_id) -FROM - workspaces -WHERE - project_id = ANY($1 :: uuid [ ]) -GROUP BY - project_id, - owner_id -` - -type GetWorkspaceOwnerCountsByProjectIDsRow struct { - ProjectID uuid.UUID `db:"project_id" json:"project_id"` - Count int64 `db:"count" json:"count"` -} - -func (q *sqlQuerier) GetWorkspaceOwnerCountsByProjectIDs(ctx context.Context, ids []uuid.UUID) ([]GetWorkspaceOwnerCountsByProjectIDsRow, error) { - rows, err := q.db.QueryContext(ctx, getWorkspaceOwnerCountsByProjectIDs, pq.Array(ids)) - if err != nil { - return nil, err - } - defer rows.Close() - var items []GetWorkspaceOwnerCountsByProjectIDsRow - for rows.Next() { - var i GetWorkspaceOwnerCountsByProjectIDsRow - if err := rows.Scan(&i.ProjectID, &i.Count); 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 getWorkspaceResourceByID = `-- name: GetWorkspaceResourceByID :one -SELECT - id, created_at, job_id, transition, address, type, name, agent_id -FROM - workspace_resources -WHERE - id = $1 -` - -func (q *sqlQuerier) GetWorkspaceResourceByID(ctx context.Context, id uuid.UUID) (WorkspaceResource, error) { - row := q.db.QueryRowContext(ctx, getWorkspaceResourceByID, id) - var i WorkspaceResource - err := row.Scan( - &i.ID, - &i.CreatedAt, - &i.JobID, - &i.Transition, - &i.Address, - &i.Type, - &i.Name, - &i.AgentID, - ) - return i, err -} - -const getWorkspaceResourcesByJobID = `-- name: GetWorkspaceResourcesByJobID :many -SELECT - id, created_at, job_id, transition, address, type, name, agent_id -FROM - workspace_resources -WHERE - job_id = $1 -` - -func (q *sqlQuerier) GetWorkspaceResourcesByJobID(ctx context.Context, jobID uuid.UUID) ([]WorkspaceResource, error) { - rows, err := q.db.QueryContext(ctx, getWorkspaceResourcesByJobID, jobID) - if err != nil { - return nil, err - } - defer rows.Close() - var items []WorkspaceResource - for rows.Next() { - var i WorkspaceResource - if err := rows.Scan( - &i.ID, - &i.CreatedAt, - &i.JobID, - &i.Transition, - &i.Address, - &i.Type, - &i.Name, - &i.AgentID, - ); 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 getWorkspacesByProjectID = `-- name: GetWorkspacesByProjectID :many -SELECT - id, created_at, updated_at, owner_id, project_id, deleted, name -FROM - workspaces -WHERE - project_id = $1 - AND deleted = $2 -` - -type GetWorkspacesByProjectIDParams struct { - ProjectID uuid.UUID `db:"project_id" json:"project_id"` - Deleted bool `db:"deleted" json:"deleted"` -} - -func (q *sqlQuerier) GetWorkspacesByProjectID(ctx context.Context, arg GetWorkspacesByProjectIDParams) ([]Workspace, error) { - rows, err := q.db.QueryContext(ctx, getWorkspacesByProjectID, arg.ProjectID, arg.Deleted) - if err != nil { - return nil, err - } - defer rows.Close() - var items []Workspace - for rows.Next() { - var i Workspace - if err := rows.Scan( - &i.ID, - &i.CreatedAt, - &i.UpdatedAt, - &i.OwnerID, - &i.ProjectID, - &i.Deleted, - &i.Name, - ); 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 getWorkspacesByUserID = `-- name: GetWorkspacesByUserID :many -SELECT - id, created_at, updated_at, owner_id, project_id, deleted, name -FROM - workspaces -WHERE - owner_id = $1 - AND deleted = $2 -` - -type GetWorkspacesByUserIDParams struct { - OwnerID uuid.UUID `db:"owner_id" json:"owner_id"` - Deleted bool `db:"deleted" json:"deleted"` -} - -func (q *sqlQuerier) GetWorkspacesByUserID(ctx context.Context, arg GetWorkspacesByUserIDParams) ([]Workspace, error) { - rows, err := q.db.QueryContext(ctx, getWorkspacesByUserID, arg.OwnerID, arg.Deleted) - if err != nil { - return nil, err - } - defer rows.Close() - var items []Workspace - for rows.Next() { - var i Workspace - if err := rows.Scan( - &i.ID, - &i.CreatedAt, - &i.UpdatedAt, - &i.OwnerID, - &i.ProjectID, - &i.Deleted, - &i.Name, - ); 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 insertAPIKey = `-- name: InsertAPIKey :one -INSERT INTO - api_keys ( - id, - hashed_secret, - user_id, - application, - name, - last_used, - expires_at, - created_at, - updated_at, - login_type, - oidc_access_token, - oidc_refresh_token, - oidc_id_token, - oidc_expiry, - devurl_token - ) -VALUES - ( - $1, - $2, - $3, - $4, - $5, - $6, - $7, - $8, - $9, - $10, - $11, - $12, - $13, - $14, - $15 - ) RETURNING id, hashed_secret, user_id, application, name, last_used, expires_at, created_at, updated_at, login_type, oidc_access_token, oidc_refresh_token, oidc_id_token, oidc_expiry, devurl_token -` - -type InsertAPIKeyParams struct { - ID string `db:"id" json:"id"` - HashedSecret []byte `db:"hashed_secret" json:"hashed_secret"` - UserID uuid.UUID `db:"user_id" json:"user_id"` - Application bool `db:"application" json:"application"` - Name string `db:"name" json:"name"` - LastUsed time.Time `db:"last_used" json:"last_used"` - ExpiresAt time.Time `db:"expires_at" json:"expires_at"` - CreatedAt time.Time `db:"created_at" json:"created_at"` - UpdatedAt time.Time `db:"updated_at" json:"updated_at"` - LoginType LoginType `db:"login_type" json:"login_type"` - OIDCAccessToken string `db:"oidc_access_token" json:"oidc_access_token"` - OIDCRefreshToken string `db:"oidc_refresh_token" json:"oidc_refresh_token"` - OIDCIDToken string `db:"oidc_id_token" json:"oidc_id_token"` - OIDCExpiry time.Time `db:"oidc_expiry" json:"oidc_expiry"` - DevurlToken bool `db:"devurl_token" json:"devurl_token"` -} - -func (q *sqlQuerier) InsertAPIKey(ctx context.Context, arg InsertAPIKeyParams) (APIKey, error) { - row := q.db.QueryRowContext(ctx, insertAPIKey, - arg.ID, - arg.HashedSecret, - arg.UserID, - arg.Application, - arg.Name, - arg.LastUsed, - arg.ExpiresAt, - arg.CreatedAt, - arg.UpdatedAt, - arg.LoginType, - arg.OIDCAccessToken, - arg.OIDCRefreshToken, - arg.OIDCIDToken, - arg.OIDCExpiry, - arg.DevurlToken, - ) - var i APIKey - err := row.Scan( - &i.ID, - &i.HashedSecret, - &i.UserID, - &i.Application, - &i.Name, - &i.LastUsed, - &i.ExpiresAt, - &i.CreatedAt, - &i.UpdatedAt, - &i.LoginType, - &i.OIDCAccessToken, - &i.OIDCRefreshToken, - &i.OIDCIDToken, - &i.OIDCExpiry, - &i.DevurlToken, - ) - return i, err -} - -const insertFile = `-- name: InsertFile :one -INSERT INTO - files (hash, created_at, created_by, mimetype, data) -VALUES - ($1, $2, $3, $4, $5) RETURNING hash, created_at, created_by, mimetype, data -` - -type InsertFileParams struct { - Hash string `db:"hash" json:"hash"` - CreatedAt time.Time `db:"created_at" json:"created_at"` - CreatedBy uuid.UUID `db:"created_by" json:"created_by"` - Mimetype string `db:"mimetype" json:"mimetype"` - Data []byte `db:"data" json:"data"` -} - -func (q *sqlQuerier) InsertFile(ctx context.Context, arg InsertFileParams) (File, error) { - row := q.db.QueryRowContext(ctx, insertFile, - arg.Hash, - arg.CreatedAt, - arg.CreatedBy, - arg.Mimetype, - arg.Data, - ) - var i File - err := row.Scan( - &i.Hash, - &i.CreatedAt, - &i.CreatedBy, - &i.Mimetype, - &i.Data, - ) - return i, err -} - -const insertOrganization = `-- name: InsertOrganization :one -INSERT INTO - organizations (id, name, description, created_at, updated_at) -VALUES - ($1, $2, $3, $4, $5) RETURNING id, name, description, created_at, updated_at -` - -type InsertOrganizationParams struct { - ID uuid.UUID `db:"id" json:"id"` - Name string `db:"name" json:"name"` - Description string `db:"description" json:"description"` - CreatedAt time.Time `db:"created_at" json:"created_at"` - UpdatedAt time.Time `db:"updated_at" json:"updated_at"` -} - -func (q *sqlQuerier) InsertOrganization(ctx context.Context, arg InsertOrganizationParams) (Organization, error) { - row := q.db.QueryRowContext(ctx, insertOrganization, - arg.ID, - arg.Name, - arg.Description, - arg.CreatedAt, - arg.UpdatedAt, - ) - var i Organization - err := row.Scan( - &i.ID, - &i.Name, - &i.Description, - &i.CreatedAt, - &i.UpdatedAt, - ) - return i, err -} - -const insertOrganizationMember = `-- name: InsertOrganizationMember :one -INSERT INTO - organization_members ( - organization_id, - user_id, - created_at, - updated_at, - roles - ) -VALUES - ($1, $2, $3, $4, $5) RETURNING user_id, organization_id, created_at, updated_at, roles -` - -type InsertOrganizationMemberParams struct { - OrganizationID uuid.UUID `db:"organization_id" json:"organization_id"` - UserID uuid.UUID `db:"user_id" json:"user_id"` - CreatedAt time.Time `db:"created_at" json:"created_at"` - UpdatedAt time.Time `db:"updated_at" json:"updated_at"` - Roles []string `db:"roles" json:"roles"` -} - -func (q *sqlQuerier) InsertOrganizationMember(ctx context.Context, arg InsertOrganizationMemberParams) (OrganizationMember, error) { - row := q.db.QueryRowContext(ctx, insertOrganizationMember, - arg.OrganizationID, - arg.UserID, - arg.CreatedAt, - arg.UpdatedAt, - pq.Array(arg.Roles), - ) - var i OrganizationMember - err := row.Scan( - &i.UserID, - &i.OrganizationID, - &i.CreatedAt, - &i.UpdatedAt, - pq.Array(&i.Roles), - ) - return i, err -} - -const insertParameterSchema = `-- name: InsertParameterSchema :one -INSERT INTO - parameter_schemas ( - id, - created_at, - job_id, - name, - description, - default_source_scheme, - default_source_value, - allow_override_source, - default_destination_scheme, - allow_override_destination, - default_refresh, - redisplay_value, - validation_error, - validation_condition, - validation_type_system, - validation_value_type - ) -VALUES - ( - $1, - $2, - $3, - $4, - $5, - $6, - $7, - $8, - $9, - $10, - $11, - $12, - $13, - $14, - $15, - $16 - ) RETURNING id, created_at, job_id, name, description, default_source_scheme, default_source_value, allow_override_source, default_destination_scheme, allow_override_destination, default_refresh, redisplay_value, validation_error, validation_condition, validation_type_system, validation_value_type -` - -type InsertParameterSchemaParams struct { - ID uuid.UUID `db:"id" json:"id"` - CreatedAt time.Time `db:"created_at" json:"created_at"` - JobID uuid.UUID `db:"job_id" json:"job_id"` - Name string `db:"name" json:"name"` - Description string `db:"description" json:"description"` - DefaultSourceScheme ParameterSourceScheme `db:"default_source_scheme" json:"default_source_scheme"` - DefaultSourceValue string `db:"default_source_value" json:"default_source_value"` - AllowOverrideSource bool `db:"allow_override_source" json:"allow_override_source"` - DefaultDestinationScheme ParameterDestinationScheme `db:"default_destination_scheme" json:"default_destination_scheme"` - AllowOverrideDestination bool `db:"allow_override_destination" json:"allow_override_destination"` - DefaultRefresh string `db:"default_refresh" json:"default_refresh"` - RedisplayValue bool `db:"redisplay_value" json:"redisplay_value"` - ValidationError string `db:"validation_error" json:"validation_error"` - ValidationCondition string `db:"validation_condition" json:"validation_condition"` - ValidationTypeSystem ParameterTypeSystem `db:"validation_type_system" json:"validation_type_system"` - ValidationValueType string `db:"validation_value_type" json:"validation_value_type"` -} - -func (q *sqlQuerier) InsertParameterSchema(ctx context.Context, arg InsertParameterSchemaParams) (ParameterSchema, error) { - row := q.db.QueryRowContext(ctx, insertParameterSchema, - arg.ID, - arg.CreatedAt, - arg.JobID, - arg.Name, - arg.Description, - arg.DefaultSourceScheme, - arg.DefaultSourceValue, - arg.AllowOverrideSource, - arg.DefaultDestinationScheme, - arg.AllowOverrideDestination, - arg.DefaultRefresh, - arg.RedisplayValue, - arg.ValidationError, - arg.ValidationCondition, - arg.ValidationTypeSystem, - arg.ValidationValueType, - ) - var i ParameterSchema - err := row.Scan( - &i.ID, - &i.CreatedAt, - &i.JobID, - &i.Name, - &i.Description, - &i.DefaultSourceScheme, - &i.DefaultSourceValue, - &i.AllowOverrideSource, - &i.DefaultDestinationScheme, - &i.AllowOverrideDestination, - &i.DefaultRefresh, - &i.RedisplayValue, - &i.ValidationError, - &i.ValidationCondition, - &i.ValidationTypeSystem, - &i.ValidationValueType, - ) - return i, err -} - -const insertParameterValue = `-- name: InsertParameterValue :one -INSERT INTO - parameter_values ( - id, - name, - created_at, - updated_at, - scope, - scope_id, - source_scheme, - source_value, - destination_scheme - ) -VALUES - ($1, $2, $3, $4, $5, $6, $7, $8, $9) RETURNING id, created_at, updated_at, scope, scope_id, name, source_scheme, source_value, destination_scheme -` - -type InsertParameterValueParams struct { - ID uuid.UUID `db:"id" json:"id"` - Name string `db:"name" json:"name"` - CreatedAt time.Time `db:"created_at" json:"created_at"` - UpdatedAt time.Time `db:"updated_at" json:"updated_at"` - Scope ParameterScope `db:"scope" json:"scope"` - ScopeID uuid.UUID `db:"scope_id" json:"scope_id"` - SourceScheme ParameterSourceScheme `db:"source_scheme" json:"source_scheme"` - SourceValue string `db:"source_value" json:"source_value"` - DestinationScheme ParameterDestinationScheme `db:"destination_scheme" json:"destination_scheme"` -} - -func (q *sqlQuerier) InsertParameterValue(ctx context.Context, arg InsertParameterValueParams) (ParameterValue, error) { - row := q.db.QueryRowContext(ctx, insertParameterValue, - arg.ID, - arg.Name, - arg.CreatedAt, - arg.UpdatedAt, - arg.Scope, - arg.ScopeID, - arg.SourceScheme, - arg.SourceValue, - arg.DestinationScheme, - ) - var i ParameterValue - err := row.Scan( - &i.ID, - &i.CreatedAt, - &i.UpdatedAt, - &i.Scope, - &i.ScopeID, - &i.Name, - &i.SourceScheme, - &i.SourceValue, - &i.DestinationScheme, - ) - return i, err -} - -const insertProject = `-- name: InsertProject :one -INSERT INTO - projects ( - id, - created_at, - updated_at, - organization_id, - name, - provisioner, - active_version_id - ) -VALUES - ($1, $2, $3, $4, $5, $6, $7) RETURNING id, created_at, updated_at, organization_id, deleted, name, provisioner, active_version_id -` - -type InsertProjectParams struct { - ID uuid.UUID `db:"id" json:"id"` - CreatedAt time.Time `db:"created_at" json:"created_at"` - UpdatedAt time.Time `db:"updated_at" json:"updated_at"` - OrganizationID uuid.UUID `db:"organization_id" json:"organization_id"` - Name string `db:"name" json:"name"` - Provisioner ProvisionerType `db:"provisioner" json:"provisioner"` - ActiveVersionID uuid.UUID `db:"active_version_id" json:"active_version_id"` -} - -func (q *sqlQuerier) InsertProject(ctx context.Context, arg InsertProjectParams) (Project, error) { - row := q.db.QueryRowContext(ctx, insertProject, - arg.ID, - arg.CreatedAt, - arg.UpdatedAt, - arg.OrganizationID, - arg.Name, - arg.Provisioner, - arg.ActiveVersionID, - ) - var i Project - err := row.Scan( - &i.ID, - &i.CreatedAt, - &i.UpdatedAt, - &i.OrganizationID, - &i.Deleted, - &i.Name, - &i.Provisioner, - &i.ActiveVersionID, - ) - return i, err -} - -const insertProjectVersion = `-- name: InsertProjectVersion :one -INSERT INTO - project_versions ( - id, - project_id, - organization_id, - created_at, - updated_at, - name, - description, - job_id - ) -VALUES - ($1, $2, $3, $4, $5, $6, $7, $8) RETURNING id, project_id, organization_id, created_at, updated_at, name, description, job_id -` - -type InsertProjectVersionParams struct { - ID uuid.UUID `db:"id" json:"id"` - ProjectID uuid.NullUUID `db:"project_id" json:"project_id"` - OrganizationID uuid.UUID `db:"organization_id" json:"organization_id"` - CreatedAt time.Time `db:"created_at" json:"created_at"` - UpdatedAt time.Time `db:"updated_at" json:"updated_at"` - Name string `db:"name" json:"name"` - Description string `db:"description" json:"description"` - JobID uuid.UUID `db:"job_id" json:"job_id"` -} - -func (q *sqlQuerier) InsertProjectVersion(ctx context.Context, arg InsertProjectVersionParams) (ProjectVersion, error) { - row := q.db.QueryRowContext(ctx, insertProjectVersion, - arg.ID, - arg.ProjectID, - arg.OrganizationID, - arg.CreatedAt, - arg.UpdatedAt, - arg.Name, - arg.Description, - arg.JobID, - ) - var i ProjectVersion - err := row.Scan( - &i.ID, - &i.ProjectID, - &i.OrganizationID, - &i.CreatedAt, - &i.UpdatedAt, - &i.Name, - &i.Description, - &i.JobID, - ) - return i, err -} - -const insertProvisionerDaemon = `-- name: InsertProvisionerDaemon :one -INSERT INTO - provisioner_daemons (id, created_at, organization_id, name, provisioners) -VALUES - ($1, $2, $3, $4, $5) RETURNING id, created_at, updated_at, organization_id, name, provisioners -` - -type InsertProvisionerDaemonParams struct { - ID uuid.UUID `db:"id" json:"id"` - CreatedAt time.Time `db:"created_at" json:"created_at"` - OrganizationID uuid.NullUUID `db:"organization_id" json:"organization_id"` - Name string `db:"name" json:"name"` - Provisioners []ProvisionerType `db:"provisioners" json:"provisioners"` -} - -func (q *sqlQuerier) InsertProvisionerDaemon(ctx context.Context, arg InsertProvisionerDaemonParams) (ProvisionerDaemon, error) { - row := q.db.QueryRowContext(ctx, insertProvisionerDaemon, - arg.ID, - arg.CreatedAt, - arg.OrganizationID, - arg.Name, - pq.Array(arg.Provisioners), - ) - var i ProvisionerDaemon - err := row.Scan( - &i.ID, - &i.CreatedAt, - &i.UpdatedAt, - &i.OrganizationID, - &i.Name, - pq.Array(&i.Provisioners), - ) - return i, err -} - -const insertProvisionerJob = `-- name: InsertProvisionerJob :one -INSERT INTO - provisioner_jobs ( - id, - created_at, - updated_at, - organization_id, - initiator_id, - provisioner, - storage_method, - storage_source, - type, - input - ) -VALUES - ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10) RETURNING id, created_at, updated_at, started_at, canceled_at, completed_at, error, organization_id, initiator_id, provisioner, storage_method, storage_source, type, input, worker_id -` - -type InsertProvisionerJobParams struct { - ID uuid.UUID `db:"id" json:"id"` - CreatedAt time.Time `db:"created_at" json:"created_at"` - UpdatedAt time.Time `db:"updated_at" json:"updated_at"` - OrganizationID uuid.UUID `db:"organization_id" json:"organization_id"` - InitiatorID uuid.UUID `db:"initiator_id" json:"initiator_id"` - Provisioner ProvisionerType `db:"provisioner" json:"provisioner"` - StorageMethod ProvisionerStorageMethod `db:"storage_method" json:"storage_method"` - StorageSource string `db:"storage_source" json:"storage_source"` - Type ProvisionerJobType `db:"type" json:"type"` - Input json.RawMessage `db:"input" json:"input"` -} - -func (q *sqlQuerier) InsertProvisionerJob(ctx context.Context, arg InsertProvisionerJobParams) (ProvisionerJob, error) { - row := q.db.QueryRowContext(ctx, insertProvisionerJob, - arg.ID, - arg.CreatedAt, - arg.UpdatedAt, - arg.OrganizationID, - arg.InitiatorID, - arg.Provisioner, - arg.StorageMethod, - arg.StorageSource, - arg.Type, - arg.Input, - ) - var i ProvisionerJob - err := row.Scan( - &i.ID, - &i.CreatedAt, - &i.UpdatedAt, - &i.StartedAt, - &i.CanceledAt, - &i.CompletedAt, - &i.Error, - &i.OrganizationID, - &i.InitiatorID, - &i.Provisioner, - &i.StorageMethod, - &i.StorageSource, - &i.Type, - &i.Input, - &i.WorkerID, - ) - return i, err -} - -const insertProvisionerJobLogs = `-- name: InsertProvisionerJobLogs :many -INSERT INTO - provisioner_job_logs -SELECT - unnest($1 :: uuid [ ]) AS id, - $2 :: uuid AS job_id, - unnest($3 :: timestamptz [ ]) AS created_at, - unnest($4 :: log_source [ ]) as source, - unnest($5 :: log_level [ ]) as level, - unnest($6 :: varchar(128) [ ]) as stage, - unnest($7 :: varchar(1024) [ ]) as output RETURNING id, job_id, created_at, source, level, stage, output -` - -type InsertProvisionerJobLogsParams struct { - ID []uuid.UUID `db:"id" json:"id"` - JobID uuid.UUID `db:"job_id" json:"job_id"` - CreatedAt []time.Time `db:"created_at" json:"created_at"` - Source []LogSource `db:"source" json:"source"` - Level []LogLevel `db:"level" json:"level"` - Stage []string `db:"stage" json:"stage"` - Output []string `db:"output" json:"output"` -} - -func (q *sqlQuerier) InsertProvisionerJobLogs(ctx context.Context, arg InsertProvisionerJobLogsParams) ([]ProvisionerJobLog, error) { - rows, err := q.db.QueryContext(ctx, insertProvisionerJobLogs, - pq.Array(arg.ID), - arg.JobID, - pq.Array(arg.CreatedAt), - pq.Array(arg.Source), - pq.Array(arg.Level), - pq.Array(arg.Stage), - pq.Array(arg.Output), - ) - if err != nil { - return nil, err - } - defer rows.Close() - var items []ProvisionerJobLog - for rows.Next() { - var i ProvisionerJobLog - if err := rows.Scan( - &i.ID, - &i.JobID, - &i.CreatedAt, - &i.Source, - &i.Level, - &i.Stage, - &i.Output, - ); 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 insertUser = `-- name: InsertUser :one -INSERT INTO - users ( - id, - email, - name, - login_type, - revoked, - hashed_password, - created_at, - updated_at, - username - ) -VALUES - ($1, $2, $3, $4, false, $5, $6, $7, $8) RETURNING id, email, name, revoked, login_type, hashed_password, created_at, updated_at, username -` - -type InsertUserParams struct { - ID uuid.UUID `db:"id" json:"id"` - Email string `db:"email" json:"email"` - Name string `db:"name" json:"name"` - LoginType LoginType `db:"login_type" json:"login_type"` - HashedPassword []byte `db:"hashed_password" json:"hashed_password"` - CreatedAt time.Time `db:"created_at" json:"created_at"` - UpdatedAt time.Time `db:"updated_at" json:"updated_at"` - Username string `db:"username" json:"username"` -} - -func (q *sqlQuerier) InsertUser(ctx context.Context, arg InsertUserParams) (User, error) { - row := q.db.QueryRowContext(ctx, insertUser, - arg.ID, - arg.Email, - arg.Name, - arg.LoginType, - arg.HashedPassword, - arg.CreatedAt, - arg.UpdatedAt, - arg.Username, - ) - var i User - err := row.Scan( - &i.ID, - &i.Email, - &i.Name, - &i.Revoked, - &i.LoginType, - &i.HashedPassword, - &i.CreatedAt, - &i.UpdatedAt, - &i.Username, - ) - return i, err -} - -const insertWorkspace = `-- name: InsertWorkspace :one -INSERT INTO - workspaces ( - id, - created_at, - updated_at, - owner_id, - project_id, - name - ) -VALUES - ($1, $2, $3, $4, $5, $6) RETURNING id, created_at, updated_at, owner_id, project_id, deleted, name -` - -type InsertWorkspaceParams struct { - ID uuid.UUID `db:"id" json:"id"` - CreatedAt time.Time `db:"created_at" json:"created_at"` - UpdatedAt time.Time `db:"updated_at" json:"updated_at"` - OwnerID uuid.UUID `db:"owner_id" json:"owner_id"` - ProjectID uuid.UUID `db:"project_id" json:"project_id"` - Name string `db:"name" json:"name"` -} - -func (q *sqlQuerier) InsertWorkspace(ctx context.Context, arg InsertWorkspaceParams) (Workspace, error) { - row := q.db.QueryRowContext(ctx, insertWorkspace, - arg.ID, - arg.CreatedAt, - arg.UpdatedAt, - arg.OwnerID, - arg.ProjectID, - arg.Name, - ) - var i Workspace - err := row.Scan( - &i.ID, - &i.CreatedAt, - &i.UpdatedAt, - &i.OwnerID, - &i.ProjectID, - &i.Deleted, - &i.Name, - ) - return i, err -} - -const insertWorkspaceAgent = `-- name: InsertWorkspaceAgent :one -INSERT INTO - workspace_agents ( - id, - created_at, - updated_at, - resource_id, - auth_token, - auth_instance_id, - environment_variables, - startup_script, - instance_metadata, - resource_metadata - ) -VALUES - ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10) RETURNING id, created_at, updated_at, first_connected_at, last_connected_at, disconnected_at, resource_id, auth_token, auth_instance_id, environment_variables, startup_script, instance_metadata, resource_metadata -` - -type InsertWorkspaceAgentParams struct { - ID uuid.UUID `db:"id" json:"id"` - CreatedAt time.Time `db:"created_at" json:"created_at"` - UpdatedAt time.Time `db:"updated_at" json:"updated_at"` - ResourceID uuid.UUID `db:"resource_id" json:"resource_id"` - AuthToken uuid.UUID `db:"auth_token" json:"auth_token"` - AuthInstanceID sql.NullString `db:"auth_instance_id" json:"auth_instance_id"` - EnvironmentVariables pqtype.NullRawMessage `db:"environment_variables" json:"environment_variables"` - StartupScript sql.NullString `db:"startup_script" json:"startup_script"` - InstanceMetadata pqtype.NullRawMessage `db:"instance_metadata" json:"instance_metadata"` - ResourceMetadata pqtype.NullRawMessage `db:"resource_metadata" json:"resource_metadata"` -} - -func (q *sqlQuerier) InsertWorkspaceAgent(ctx context.Context, arg InsertWorkspaceAgentParams) (WorkspaceAgent, error) { - row := q.db.QueryRowContext(ctx, insertWorkspaceAgent, - arg.ID, - arg.CreatedAt, - arg.UpdatedAt, - arg.ResourceID, - arg.AuthToken, - arg.AuthInstanceID, - arg.EnvironmentVariables, - arg.StartupScript, - arg.InstanceMetadata, - arg.ResourceMetadata, - ) - var i WorkspaceAgent - err := row.Scan( - &i.ID, - &i.CreatedAt, - &i.UpdatedAt, - &i.FirstConnectedAt, - &i.LastConnectedAt, - &i.DisconnectedAt, - &i.ResourceID, - &i.AuthToken, - &i.AuthInstanceID, - &i.EnvironmentVariables, - &i.StartupScript, - &i.InstanceMetadata, - &i.ResourceMetadata, - ) - return i, err -} - -const insertWorkspaceBuild = `-- name: InsertWorkspaceBuild :one -INSERT INTO - workspace_builds ( - id, - created_at, - updated_at, - workspace_id, - project_version_id, - before_id, - name, - transition, - initiator_id, - job_id, - provisioner_state - ) -VALUES - ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11) RETURNING id, created_at, updated_at, workspace_id, project_version_id, name, before_id, after_id, transition, initiator_id, provisioner_state, job_id -` - -type InsertWorkspaceBuildParams struct { - ID uuid.UUID `db:"id" json:"id"` - CreatedAt time.Time `db:"created_at" json:"created_at"` - UpdatedAt time.Time `db:"updated_at" json:"updated_at"` - WorkspaceID uuid.UUID `db:"workspace_id" json:"workspace_id"` - ProjectVersionID uuid.UUID `db:"project_version_id" json:"project_version_id"` - BeforeID uuid.NullUUID `db:"before_id" json:"before_id"` - Name string `db:"name" json:"name"` - Transition WorkspaceTransition `db:"transition" json:"transition"` - InitiatorID uuid.UUID `db:"initiator_id" json:"initiator_id"` - JobID uuid.UUID `db:"job_id" json:"job_id"` - ProvisionerState []byte `db:"provisioner_state" json:"provisioner_state"` -} - -func (q *sqlQuerier) InsertWorkspaceBuild(ctx context.Context, arg InsertWorkspaceBuildParams) (WorkspaceBuild, error) { - row := q.db.QueryRowContext(ctx, insertWorkspaceBuild, - arg.ID, - arg.CreatedAt, - arg.UpdatedAt, - arg.WorkspaceID, - arg.ProjectVersionID, - arg.BeforeID, - arg.Name, - arg.Transition, - arg.InitiatorID, - arg.JobID, - arg.ProvisionerState, - ) - var i WorkspaceBuild - err := row.Scan( - &i.ID, - &i.CreatedAt, - &i.UpdatedAt, - &i.WorkspaceID, - &i.ProjectVersionID, - &i.Name, - &i.BeforeID, - &i.AfterID, - &i.Transition, - &i.InitiatorID, - &i.ProvisionerState, - &i.JobID, - ) - return i, err -} - -const insertWorkspaceResource = `-- name: InsertWorkspaceResource :one -INSERT INTO - workspace_resources ( - id, - created_at, - job_id, - transition, - address, - type, - name, - agent_id - ) -VALUES - ($1, $2, $3, $4, $5, $6, $7, $8) RETURNING id, created_at, job_id, transition, address, type, name, agent_id -` - -type InsertWorkspaceResourceParams struct { - ID uuid.UUID `db:"id" json:"id"` - CreatedAt time.Time `db:"created_at" json:"created_at"` - JobID uuid.UUID `db:"job_id" json:"job_id"` - Transition WorkspaceTransition `db:"transition" json:"transition"` - Address string `db:"address" json:"address"` - Type string `db:"type" json:"type"` - Name string `db:"name" json:"name"` - AgentID uuid.NullUUID `db:"agent_id" json:"agent_id"` -} - -func (q *sqlQuerier) InsertWorkspaceResource(ctx context.Context, arg InsertWorkspaceResourceParams) (WorkspaceResource, error) { - row := q.db.QueryRowContext(ctx, insertWorkspaceResource, - arg.ID, - arg.CreatedAt, - arg.JobID, - arg.Transition, - arg.Address, - arg.Type, - arg.Name, - arg.AgentID, - ) - var i WorkspaceResource - err := row.Scan( - &i.ID, - &i.CreatedAt, - &i.JobID, - &i.Transition, - &i.Address, - &i.Type, - &i.Name, - &i.AgentID, - ) - return i, err -} - -const updateAPIKeyByID = `-- name: UpdateAPIKeyByID :exec -UPDATE - api_keys -SET - last_used = $2, - expires_at = $3, - oidc_access_token = $4, - oidc_refresh_token = $5, - oidc_expiry = $6 -WHERE - id = $1 -` - -type UpdateAPIKeyByIDParams struct { - ID string `db:"id" json:"id"` - LastUsed time.Time `db:"last_used" json:"last_used"` - ExpiresAt time.Time `db:"expires_at" json:"expires_at"` - OIDCAccessToken string `db:"oidc_access_token" json:"oidc_access_token"` - OIDCRefreshToken string `db:"oidc_refresh_token" json:"oidc_refresh_token"` - OIDCExpiry time.Time `db:"oidc_expiry" json:"oidc_expiry"` -} - -func (q *sqlQuerier) UpdateAPIKeyByID(ctx context.Context, arg UpdateAPIKeyByIDParams) error { - _, err := q.db.ExecContext(ctx, updateAPIKeyByID, - arg.ID, - arg.LastUsed, - arg.ExpiresAt, - arg.OIDCAccessToken, - arg.OIDCRefreshToken, - arg.OIDCExpiry, - ) - return err -} - -const updateProjectActiveVersionByID = `-- name: UpdateProjectActiveVersionByID :exec -UPDATE - projects -SET - active_version_id = $2 -WHERE - id = $1 -` - -type UpdateProjectActiveVersionByIDParams struct { - ID uuid.UUID `db:"id" json:"id"` - ActiveVersionID uuid.UUID `db:"active_version_id" json:"active_version_id"` -} - -func (q *sqlQuerier) UpdateProjectActiveVersionByID(ctx context.Context, arg UpdateProjectActiveVersionByIDParams) error { - _, err := q.db.ExecContext(ctx, updateProjectActiveVersionByID, arg.ID, arg.ActiveVersionID) - return err -} - -const updateProjectDeletedByID = `-- name: UpdateProjectDeletedByID :exec -UPDATE - projects -SET - deleted = $2 -WHERE - id = $1 -` - -type UpdateProjectDeletedByIDParams struct { - ID uuid.UUID `db:"id" json:"id"` - Deleted bool `db:"deleted" json:"deleted"` -} - -func (q *sqlQuerier) UpdateProjectDeletedByID(ctx context.Context, arg UpdateProjectDeletedByIDParams) error { - _, err := q.db.ExecContext(ctx, updateProjectDeletedByID, arg.ID, arg.Deleted) - return err -} - -const updateProjectVersionByID = `-- name: UpdateProjectVersionByID :exec -UPDATE - project_versions -SET - project_id = $2, - updated_at = $3 -WHERE - id = $1 -` - -type UpdateProjectVersionByIDParams struct { - ID uuid.UUID `db:"id" json:"id"` - ProjectID uuid.NullUUID `db:"project_id" json:"project_id"` - UpdatedAt time.Time `db:"updated_at" json:"updated_at"` -} - -func (q *sqlQuerier) UpdateProjectVersionByID(ctx context.Context, arg UpdateProjectVersionByIDParams) error { - _, err := q.db.ExecContext(ctx, updateProjectVersionByID, arg.ID, arg.ProjectID, arg.UpdatedAt) - return err -} - -const updateProvisionerDaemonByID = `-- name: UpdateProvisionerDaemonByID :exec -UPDATE - provisioner_daemons -SET - updated_at = $2, - provisioners = $3 -WHERE - id = $1 -` - -type UpdateProvisionerDaemonByIDParams struct { - ID uuid.UUID `db:"id" json:"id"` - UpdatedAt sql.NullTime `db:"updated_at" json:"updated_at"` - Provisioners []ProvisionerType `db:"provisioners" json:"provisioners"` -} - -func (q *sqlQuerier) UpdateProvisionerDaemonByID(ctx context.Context, arg UpdateProvisionerDaemonByIDParams) error { - _, err := q.db.ExecContext(ctx, updateProvisionerDaemonByID, arg.ID, arg.UpdatedAt, pq.Array(arg.Provisioners)) - return err -} - -const updateProvisionerJobByID = `-- name: UpdateProvisionerJobByID :exec -UPDATE - provisioner_jobs -SET - updated_at = $2 -WHERE - id = $1 -` - -type UpdateProvisionerJobByIDParams struct { - ID uuid.UUID `db:"id" json:"id"` - UpdatedAt time.Time `db:"updated_at" json:"updated_at"` -} - -func (q *sqlQuerier) UpdateProvisionerJobByID(ctx context.Context, arg UpdateProvisionerJobByIDParams) error { - _, err := q.db.ExecContext(ctx, updateProvisionerJobByID, arg.ID, arg.UpdatedAt) - return err -} - -const updateProvisionerJobWithCancelByID = `-- name: UpdateProvisionerJobWithCancelByID :exec -UPDATE - provisioner_jobs -SET - canceled_at = $2 -WHERE - id = $1 -` - -type UpdateProvisionerJobWithCancelByIDParams struct { - ID uuid.UUID `db:"id" json:"id"` - CanceledAt sql.NullTime `db:"canceled_at" json:"canceled_at"` -} - -func (q *sqlQuerier) UpdateProvisionerJobWithCancelByID(ctx context.Context, arg UpdateProvisionerJobWithCancelByIDParams) error { - _, err := q.db.ExecContext(ctx, updateProvisionerJobWithCancelByID, arg.ID, arg.CanceledAt) - return err -} - -const updateProvisionerJobWithCompleteByID = `-- name: UpdateProvisionerJobWithCompleteByID :exec -UPDATE - provisioner_jobs -SET - updated_at = $2, - completed_at = $3, - error = $4 -WHERE - id = $1 -` - -type UpdateProvisionerJobWithCompleteByIDParams struct { - ID uuid.UUID `db:"id" json:"id"` - UpdatedAt time.Time `db:"updated_at" json:"updated_at"` - CompletedAt sql.NullTime `db:"completed_at" json:"completed_at"` - Error sql.NullString `db:"error" json:"error"` -} - -func (q *sqlQuerier) UpdateProvisionerJobWithCompleteByID(ctx context.Context, arg UpdateProvisionerJobWithCompleteByIDParams) error { - _, err := q.db.ExecContext(ctx, updateProvisionerJobWithCompleteByID, - arg.ID, - arg.UpdatedAt, - arg.CompletedAt, - arg.Error, - ) - return err -} - -const updateWorkspaceAgentConnectionByID = `-- name: UpdateWorkspaceAgentConnectionByID :exec -UPDATE - workspace_agents -SET - first_connected_at = $2, - last_connected_at = $3, - disconnected_at = $4 -WHERE - id = $1 -` - -type UpdateWorkspaceAgentConnectionByIDParams struct { - ID uuid.UUID `db:"id" json:"id"` - FirstConnectedAt sql.NullTime `db:"first_connected_at" json:"first_connected_at"` - LastConnectedAt sql.NullTime `db:"last_connected_at" json:"last_connected_at"` - DisconnectedAt sql.NullTime `db:"disconnected_at" json:"disconnected_at"` -} - -func (q *sqlQuerier) UpdateWorkspaceAgentConnectionByID(ctx context.Context, arg UpdateWorkspaceAgentConnectionByIDParams) error { - _, err := q.db.ExecContext(ctx, updateWorkspaceAgentConnectionByID, - arg.ID, - arg.FirstConnectedAt, - arg.LastConnectedAt, - arg.DisconnectedAt, - ) - return err -} - -const updateWorkspaceBuildByID = `-- name: UpdateWorkspaceBuildByID :exec -UPDATE - workspace_builds -SET - updated_at = $2, - after_id = $3, - provisioner_state = $4 -WHERE - id = $1 -` - -type UpdateWorkspaceBuildByIDParams struct { - ID uuid.UUID `db:"id" json:"id"` - UpdatedAt time.Time `db:"updated_at" json:"updated_at"` - AfterID uuid.NullUUID `db:"after_id" json:"after_id"` - ProvisionerState []byte `db:"provisioner_state" json:"provisioner_state"` -} - -func (q *sqlQuerier) UpdateWorkspaceBuildByID(ctx context.Context, arg UpdateWorkspaceBuildByIDParams) error { - _, err := q.db.ExecContext(ctx, updateWorkspaceBuildByID, - arg.ID, - arg.UpdatedAt, - arg.AfterID, - arg.ProvisionerState, - ) - return err -} - -const updateWorkspaceDeletedByID = `-- name: UpdateWorkspaceDeletedByID :exec -UPDATE - workspaces -SET - deleted = $2 -WHERE - id = $1 -` - -type UpdateWorkspaceDeletedByIDParams struct { - ID uuid.UUID `db:"id" json:"id"` - Deleted bool `db:"deleted" json:"deleted"` -} - -func (q *sqlQuerier) UpdateWorkspaceDeletedByID(ctx context.Context, arg UpdateWorkspaceDeletedByIDParams) error { - _, err := q.db.ExecContext(ctx, updateWorkspaceDeletedByID, arg.ID, arg.Deleted) - return err -} diff --git a/coderd/database/sqlc.yaml b/coderd/database/sqlc.yaml index 01ad9dc733882..0319ccf47c1d3 100644 --- a/coderd/database/sqlc.yaml +++ b/coderd/database/sqlc.yaml @@ -5,7 +5,7 @@ version: "1" packages: - name: "database" path: "." - queries: "./query.sql" + queries: "./queries/" schema: "./dump.sql" engine: "postgresql" emit_interface: true diff --git a/coderd/database/users.sql.go b/coderd/database/users.sql.go new file mode 100644 index 0000000000000..c56aabecca8bf --- /dev/null +++ b/coderd/database/users.sql.go @@ -0,0 +1,171 @@ +// Code generated by sqlc. DO NOT EDIT. +// source: users.sql + +package database + +import ( + "context" + "time" + + "github.com/lib/pq" +) + +const getUserByEmailOrUsername = `-- name: GetUserByEmailOrUsername :one +SELECT + id, email, name, revoked, login_type, hashed_password, created_at, updated_at, temporary_password, avatar_hash, ssh_key_regenerated_at, username, dotfiles_git_uri, roles, status, relatime, gpg_key_regenerated_at, _decomissioned, shell +FROM + users +WHERE + LOWER(username) = LOWER($1) + OR email = $2 +LIMIT + 1 +` + +type GetUserByEmailOrUsernameParams struct { + Username string `db:"username" json:"username"` + Email string `db:"email" json:"email"` +} + +func (q *sqlQuerier) GetUserByEmailOrUsername(ctx context.Context, arg GetUserByEmailOrUsernameParams) (User, error) { + row := q.db.QueryRowContext(ctx, getUserByEmailOrUsername, arg.Username, arg.Email) + var i User + err := row.Scan( + &i.ID, + &i.Email, + &i.Name, + &i.Revoked, + &i.LoginType, + &i.HashedPassword, + &i.CreatedAt, + &i.UpdatedAt, + &i.TemporaryPassword, + &i.AvatarHash, + &i.SshKeyRegeneratedAt, + &i.Username, + &i.DotfilesGitUri, + pq.Array(&i.Roles), + &i.Status, + &i.Relatime, + &i.GpgKeyRegeneratedAt, + &i.Decomissioned, + &i.Shell, + ) + return i, err +} + +const getUserByID = `-- name: GetUserByID :one +SELECT + id, email, name, revoked, login_type, hashed_password, created_at, updated_at, temporary_password, avatar_hash, ssh_key_regenerated_at, username, dotfiles_git_uri, roles, status, relatime, gpg_key_regenerated_at, _decomissioned, shell +FROM + users +WHERE + id = $1 +LIMIT + 1 +` + +func (q *sqlQuerier) GetUserByID(ctx context.Context, id string) (User, error) { + row := q.db.QueryRowContext(ctx, getUserByID, id) + var i User + err := row.Scan( + &i.ID, + &i.Email, + &i.Name, + &i.Revoked, + &i.LoginType, + &i.HashedPassword, + &i.CreatedAt, + &i.UpdatedAt, + &i.TemporaryPassword, + &i.AvatarHash, + &i.SshKeyRegeneratedAt, + &i.Username, + &i.DotfilesGitUri, + pq.Array(&i.Roles), + &i.Status, + &i.Relatime, + &i.GpgKeyRegeneratedAt, + &i.Decomissioned, + &i.Shell, + ) + return i, err +} + +const getUserCount = `-- name: GetUserCount :one +SELECT + COUNT(*) +FROM + users +` + +func (q *sqlQuerier) GetUserCount(ctx context.Context) (int64, error) { + row := q.db.QueryRowContext(ctx, getUserCount) + var count int64 + err := row.Scan(&count) + return count, err +} + +const insertUser = `-- name: InsertUser :one +INSERT INTO + users ( + id, + email, + "name", + login_type, + revoked, + hashed_password, + created_at, + updated_at, + username + ) +VALUES + ($1, $2, $3, $4, FALSE, $5, $6, $7, $8) RETURNING id, email, name, revoked, login_type, hashed_password, created_at, updated_at, temporary_password, avatar_hash, ssh_key_regenerated_at, username, dotfiles_git_uri, roles, status, relatime, gpg_key_regenerated_at, _decomissioned, shell +` + +type InsertUserParams struct { + ID string `db:"id" json:"id"` + Email string `db:"email" json:"email"` + Name string `db:"name" json:"name"` + LoginType LoginType `db:"login_type" json:"login_type"` + HashedPassword []byte `db:"hashed_password" json:"hashed_password"` + CreatedAt time.Time `db:"created_at" json:"created_at"` + UpdatedAt time.Time `db:"updated_at" json:"updated_at"` + Username string `db:"username" json:"username"` +} + +func (q *sqlQuerier) InsertUser(ctx context.Context, arg InsertUserParams) (User, error) { + row := q.db.QueryRowContext(ctx, insertUser, + arg.ID, + arg.Email, + arg.Name, + arg.LoginType, + arg.HashedPassword, + arg.CreatedAt, + arg.UpdatedAt, + arg.Username, + ) + var i User + err := row.Scan( + &i.ID, + &i.Email, + &i.Name, + &i.Revoked, + &i.LoginType, + &i.HashedPassword, + &i.CreatedAt, + &i.UpdatedAt, + &i.TemporaryPassword, + &i.AvatarHash, + &i.SshKeyRegeneratedAt, + &i.Username, + &i.DotfilesGitUri, + pq.Array(&i.Roles), + &i.Status, + &i.Relatime, + &i.GpgKeyRegeneratedAt, + &i.Decomissioned, + &i.Shell, + ) + return i, err +} diff --git a/coderd/database/workspace_agents.sql.go b/coderd/database/workspace_agents.sql.go new file mode 100644 index 0000000000000..951fcc4b57cb6 --- /dev/null +++ b/coderd/database/workspace_agents.sql.go @@ -0,0 +1,198 @@ +// Code generated by sqlc. DO NOT EDIT. +// source: workspace_agents.sql + +package database + +import ( + "context" + "database/sql" + "time" + + "github.com/google/uuid" + "github.com/tabbed/pqtype" +) + +const getWorkspaceAgentByAuthToken = `-- name: GetWorkspaceAgentByAuthToken :one +SELECT + id, created_at, updated_at, first_connected_at, last_connected_at, disconnected_at, resource_id, auth_token, auth_instance_id, environment_variables, startup_script, instance_metadata, resource_metadata +FROM + workspace_agents +WHERE + auth_token = $1 +ORDER BY + created_at DESC +` + +func (q *sqlQuerier) GetWorkspaceAgentByAuthToken(ctx context.Context, authToken uuid.UUID) (WorkspaceAgent, error) { + row := q.db.QueryRowContext(ctx, getWorkspaceAgentByAuthToken, authToken) + var i WorkspaceAgent + err := row.Scan( + &i.ID, + &i.CreatedAt, + &i.UpdatedAt, + &i.FirstConnectedAt, + &i.LastConnectedAt, + &i.DisconnectedAt, + &i.ResourceID, + &i.AuthToken, + &i.AuthInstanceID, + &i.EnvironmentVariables, + &i.StartupScript, + &i.InstanceMetadata, + &i.ResourceMetadata, + ) + return i, err +} + +const getWorkspaceAgentByInstanceID = `-- name: GetWorkspaceAgentByInstanceID :one +SELECT + id, created_at, updated_at, first_connected_at, last_connected_at, disconnected_at, resource_id, auth_token, auth_instance_id, environment_variables, startup_script, instance_metadata, resource_metadata +FROM + workspace_agents +WHERE + auth_instance_id = $1 :: TEXT +ORDER BY + created_at DESC +` + +func (q *sqlQuerier) GetWorkspaceAgentByInstanceID(ctx context.Context, authInstanceID string) (WorkspaceAgent, error) { + row := q.db.QueryRowContext(ctx, getWorkspaceAgentByInstanceID, authInstanceID) + var i WorkspaceAgent + err := row.Scan( + &i.ID, + &i.CreatedAt, + &i.UpdatedAt, + &i.FirstConnectedAt, + &i.LastConnectedAt, + &i.DisconnectedAt, + &i.ResourceID, + &i.AuthToken, + &i.AuthInstanceID, + &i.EnvironmentVariables, + &i.StartupScript, + &i.InstanceMetadata, + &i.ResourceMetadata, + ) + return i, err +} + +const getWorkspaceAgentByResourceID = `-- name: GetWorkspaceAgentByResourceID :one +SELECT + id, created_at, updated_at, first_connected_at, last_connected_at, disconnected_at, resource_id, auth_token, auth_instance_id, environment_variables, startup_script, instance_metadata, resource_metadata +FROM + workspace_agents +WHERE + resource_id = $1 +` + +func (q *sqlQuerier) GetWorkspaceAgentByResourceID(ctx context.Context, resourceID uuid.UUID) (WorkspaceAgent, error) { + row := q.db.QueryRowContext(ctx, getWorkspaceAgentByResourceID, resourceID) + var i WorkspaceAgent + err := row.Scan( + &i.ID, + &i.CreatedAt, + &i.UpdatedAt, + &i.FirstConnectedAt, + &i.LastConnectedAt, + &i.DisconnectedAt, + &i.ResourceID, + &i.AuthToken, + &i.AuthInstanceID, + &i.EnvironmentVariables, + &i.StartupScript, + &i.InstanceMetadata, + &i.ResourceMetadata, + ) + return i, err +} + +const insertWorkspaceAgent = `-- name: InsertWorkspaceAgent :one +INSERT INTO + workspace_agents ( + id, + created_at, + updated_at, + resource_id, + auth_token, + auth_instance_id, + environment_variables, + startup_script, + instance_metadata, + resource_metadata + ) +VALUES + ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10) RETURNING id, created_at, updated_at, first_connected_at, last_connected_at, disconnected_at, resource_id, auth_token, auth_instance_id, environment_variables, startup_script, instance_metadata, resource_metadata +` + +type InsertWorkspaceAgentParams struct { + ID uuid.UUID `db:"id" json:"id"` + CreatedAt time.Time `db:"created_at" json:"created_at"` + UpdatedAt time.Time `db:"updated_at" json:"updated_at"` + ResourceID uuid.UUID `db:"resource_id" json:"resource_id"` + AuthToken uuid.UUID `db:"auth_token" json:"auth_token"` + AuthInstanceID sql.NullString `db:"auth_instance_id" json:"auth_instance_id"` + EnvironmentVariables pqtype.NullRawMessage `db:"environment_variables" json:"environment_variables"` + StartupScript sql.NullString `db:"startup_script" json:"startup_script"` + InstanceMetadata pqtype.NullRawMessage `db:"instance_metadata" json:"instance_metadata"` + ResourceMetadata pqtype.NullRawMessage `db:"resource_metadata" json:"resource_metadata"` +} + +func (q *sqlQuerier) InsertWorkspaceAgent(ctx context.Context, arg InsertWorkspaceAgentParams) (WorkspaceAgent, error) { + row := q.db.QueryRowContext(ctx, insertWorkspaceAgent, + arg.ID, + arg.CreatedAt, + arg.UpdatedAt, + arg.ResourceID, + arg.AuthToken, + arg.AuthInstanceID, + arg.EnvironmentVariables, + arg.StartupScript, + arg.InstanceMetadata, + arg.ResourceMetadata, + ) + var i WorkspaceAgent + err := row.Scan( + &i.ID, + &i.CreatedAt, + &i.UpdatedAt, + &i.FirstConnectedAt, + &i.LastConnectedAt, + &i.DisconnectedAt, + &i.ResourceID, + &i.AuthToken, + &i.AuthInstanceID, + &i.EnvironmentVariables, + &i.StartupScript, + &i.InstanceMetadata, + &i.ResourceMetadata, + ) + return i, err +} + +const updateWorkspaceAgentConnectionByID = `-- name: UpdateWorkspaceAgentConnectionByID :exec +UPDATE + workspace_agents +SET + first_connected_at = $2, + last_connected_at = $3, + disconnected_at = $4 +WHERE + id = $1 +` + +type UpdateWorkspaceAgentConnectionByIDParams struct { + ID uuid.UUID `db:"id" json:"id"` + FirstConnectedAt sql.NullTime `db:"first_connected_at" json:"first_connected_at"` + LastConnectedAt sql.NullTime `db:"last_connected_at" json:"last_connected_at"` + DisconnectedAt sql.NullTime `db:"disconnected_at" json:"disconnected_at"` +} + +func (q *sqlQuerier) UpdateWorkspaceAgentConnectionByID(ctx context.Context, arg UpdateWorkspaceAgentConnectionByIDParams) error { + _, err := q.db.ExecContext(ctx, updateWorkspaceAgentConnectionByID, + arg.ID, + arg.FirstConnectedAt, + arg.LastConnectedAt, + arg.DisconnectedAt, + ) + return err +} diff --git a/coderd/database/workspace_builds.sql.go b/coderd/database/workspace_builds.sql.go new file mode 100644 index 0000000000000..f0309c72775a5 --- /dev/null +++ b/coderd/database/workspace_builds.sql.go @@ -0,0 +1,325 @@ +// Code generated by sqlc. DO NOT EDIT. +// source: workspace_builds.sql + +package database + +import ( + "context" + "time" + + "github.com/google/uuid" + "github.com/lib/pq" +) + +const getWorkspaceBuildByID = `-- name: GetWorkspaceBuildByID :one +SELECT + id, created_at, updated_at, workspace_id, project_version_id, name, before_id, after_id, transition, initiator, provisioner_state, job_id +FROM + workspace_builds +WHERE + id = $1 +LIMIT + 1 +` + +func (q *sqlQuerier) GetWorkspaceBuildByID(ctx context.Context, id uuid.UUID) (WorkspaceBuild, error) { + row := q.db.QueryRowContext(ctx, getWorkspaceBuildByID, id) + var i WorkspaceBuild + err := row.Scan( + &i.ID, + &i.CreatedAt, + &i.UpdatedAt, + &i.WorkspaceID, + &i.ProjectVersionID, + &i.Name, + &i.BeforeID, + &i.AfterID, + &i.Transition, + &i.Initiator, + &i.ProvisionerState, + &i.JobID, + ) + return i, err +} + +const getWorkspaceBuildByJobID = `-- name: GetWorkspaceBuildByJobID :one +SELECT + id, created_at, updated_at, workspace_id, project_version_id, name, before_id, after_id, transition, initiator, provisioner_state, job_id +FROM + workspace_builds +WHERE + job_id = $1 +LIMIT + 1 +` + +func (q *sqlQuerier) GetWorkspaceBuildByJobID(ctx context.Context, jobID uuid.UUID) (WorkspaceBuild, error) { + row := q.db.QueryRowContext(ctx, getWorkspaceBuildByJobID, jobID) + var i WorkspaceBuild + err := row.Scan( + &i.ID, + &i.CreatedAt, + &i.UpdatedAt, + &i.WorkspaceID, + &i.ProjectVersionID, + &i.Name, + &i.BeforeID, + &i.AfterID, + &i.Transition, + &i.Initiator, + &i.ProvisionerState, + &i.JobID, + ) + return i, err +} + +const getWorkspaceBuildByWorkspaceID = `-- name: GetWorkspaceBuildByWorkspaceID :many +SELECT + id, created_at, updated_at, workspace_id, project_version_id, name, before_id, after_id, transition, initiator, provisioner_state, job_id +FROM + workspace_builds +WHERE + workspace_id = $1 +` + +func (q *sqlQuerier) GetWorkspaceBuildByWorkspaceID(ctx context.Context, workspaceID uuid.UUID) ([]WorkspaceBuild, error) { + rows, err := q.db.QueryContext(ctx, getWorkspaceBuildByWorkspaceID, workspaceID) + if err != nil { + return nil, err + } + defer rows.Close() + var items []WorkspaceBuild + for rows.Next() { + var i WorkspaceBuild + if err := rows.Scan( + &i.ID, + &i.CreatedAt, + &i.UpdatedAt, + &i.WorkspaceID, + &i.ProjectVersionID, + &i.Name, + &i.BeforeID, + &i.AfterID, + &i.Transition, + &i.Initiator, + &i.ProvisionerState, + &i.JobID, + ); 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 getWorkspaceBuildByWorkspaceIDAndName = `-- name: GetWorkspaceBuildByWorkspaceIDAndName :one +SELECT + id, created_at, updated_at, workspace_id, project_version_id, name, before_id, after_id, transition, initiator, provisioner_state, job_id +FROM + workspace_builds +WHERE + workspace_id = $1 + AND "name" = $2 +` + +type GetWorkspaceBuildByWorkspaceIDAndNameParams struct { + WorkspaceID uuid.UUID `db:"workspace_id" json:"workspace_id"` + Name string `db:"name" json:"name"` +} + +func (q *sqlQuerier) GetWorkspaceBuildByWorkspaceIDAndName(ctx context.Context, arg GetWorkspaceBuildByWorkspaceIDAndNameParams) (WorkspaceBuild, error) { + row := q.db.QueryRowContext(ctx, getWorkspaceBuildByWorkspaceIDAndName, arg.WorkspaceID, arg.Name) + var i WorkspaceBuild + err := row.Scan( + &i.ID, + &i.CreatedAt, + &i.UpdatedAt, + &i.WorkspaceID, + &i.ProjectVersionID, + &i.Name, + &i.BeforeID, + &i.AfterID, + &i.Transition, + &i.Initiator, + &i.ProvisionerState, + &i.JobID, + ) + return i, err +} + +const getWorkspaceBuildByWorkspaceIDWithoutAfter = `-- name: GetWorkspaceBuildByWorkspaceIDWithoutAfter :one +SELECT + id, created_at, updated_at, workspace_id, project_version_id, name, before_id, after_id, transition, initiator, provisioner_state, job_id +FROM + workspace_builds +WHERE + workspace_id = $1 + AND after_id IS NULL +LIMIT + 1 +` + +func (q *sqlQuerier) GetWorkspaceBuildByWorkspaceIDWithoutAfter(ctx context.Context, workspaceID uuid.UUID) (WorkspaceBuild, error) { + row := q.db.QueryRowContext(ctx, getWorkspaceBuildByWorkspaceIDWithoutAfter, workspaceID) + var i WorkspaceBuild + err := row.Scan( + &i.ID, + &i.CreatedAt, + &i.UpdatedAt, + &i.WorkspaceID, + &i.ProjectVersionID, + &i.Name, + &i.BeforeID, + &i.AfterID, + &i.Transition, + &i.Initiator, + &i.ProvisionerState, + &i.JobID, + ) + return i, err +} + +const getWorkspaceBuildsByWorkspaceIDsWithoutAfter = `-- name: GetWorkspaceBuildsByWorkspaceIDsWithoutAfter :many +SELECT + id, created_at, updated_at, workspace_id, project_version_id, name, before_id, after_id, transition, initiator, provisioner_state, job_id +FROM + workspace_builds +WHERE + workspace_id = ANY($1 :: uuid [ ]) + AND after_id IS NULL +` + +func (q *sqlQuerier) GetWorkspaceBuildsByWorkspaceIDsWithoutAfter(ctx context.Context, ids []uuid.UUID) ([]WorkspaceBuild, error) { + rows, err := q.db.QueryContext(ctx, getWorkspaceBuildsByWorkspaceIDsWithoutAfter, pq.Array(ids)) + if err != nil { + return nil, err + } + defer rows.Close() + var items []WorkspaceBuild + for rows.Next() { + var i WorkspaceBuild + if err := rows.Scan( + &i.ID, + &i.CreatedAt, + &i.UpdatedAt, + &i.WorkspaceID, + &i.ProjectVersionID, + &i.Name, + &i.BeforeID, + &i.AfterID, + &i.Transition, + &i.Initiator, + &i.ProvisionerState, + &i.JobID, + ); 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 insertWorkspaceBuild = `-- name: InsertWorkspaceBuild :one +INSERT INTO + workspace_builds ( + id, + created_at, + updated_at, + workspace_id, + project_version_id, + before_id, + "name", + transition, + initiator, + job_id, + provisioner_state + ) +VALUES + ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11) RETURNING id, created_at, updated_at, workspace_id, project_version_id, name, before_id, after_id, transition, initiator, provisioner_state, job_id +` + +type InsertWorkspaceBuildParams struct { + ID uuid.UUID `db:"id" json:"id"` + CreatedAt time.Time `db:"created_at" json:"created_at"` + UpdatedAt time.Time `db:"updated_at" json:"updated_at"` + WorkspaceID uuid.UUID `db:"workspace_id" json:"workspace_id"` + ProjectVersionID uuid.UUID `db:"project_version_id" json:"project_version_id"` + BeforeID uuid.NullUUID `db:"before_id" json:"before_id"` + Name string `db:"name" json:"name"` + Transition WorkspaceTransition `db:"transition" json:"transition"` + Initiator string `db:"initiator" json:"initiator"` + JobID uuid.UUID `db:"job_id" json:"job_id"` + ProvisionerState []byte `db:"provisioner_state" json:"provisioner_state"` +} + +func (q *sqlQuerier) InsertWorkspaceBuild(ctx context.Context, arg InsertWorkspaceBuildParams) (WorkspaceBuild, error) { + row := q.db.QueryRowContext(ctx, insertWorkspaceBuild, + arg.ID, + arg.CreatedAt, + arg.UpdatedAt, + arg.WorkspaceID, + arg.ProjectVersionID, + arg.BeforeID, + arg.Name, + arg.Transition, + arg.Initiator, + arg.JobID, + arg.ProvisionerState, + ) + var i WorkspaceBuild + err := row.Scan( + &i.ID, + &i.CreatedAt, + &i.UpdatedAt, + &i.WorkspaceID, + &i.ProjectVersionID, + &i.Name, + &i.BeforeID, + &i.AfterID, + &i.Transition, + &i.Initiator, + &i.ProvisionerState, + &i.JobID, + ) + return i, err +} + +const updateWorkspaceBuildByID = `-- name: UpdateWorkspaceBuildByID :exec +UPDATE + workspace_builds +SET + updated_at = $2, + after_id = $3, + provisioner_state = $4 +WHERE + id = $1 +` + +type UpdateWorkspaceBuildByIDParams struct { + ID uuid.UUID `db:"id" json:"id"` + UpdatedAt time.Time `db:"updated_at" json:"updated_at"` + AfterID uuid.NullUUID `db:"after_id" json:"after_id"` + ProvisionerState []byte `db:"provisioner_state" json:"provisioner_state"` +} + +func (q *sqlQuerier) UpdateWorkspaceBuildByID(ctx context.Context, arg UpdateWorkspaceBuildByIDParams) error { + _, err := q.db.ExecContext(ctx, updateWorkspaceBuildByID, + arg.ID, + arg.UpdatedAt, + arg.AfterID, + arg.ProvisionerState, + ) + return err +} diff --git a/coderd/database/workspace_resources.sql.go b/coderd/database/workspace_resources.sql.go new file mode 100644 index 0000000000000..874253e8c6831 --- /dev/null +++ b/coderd/database/workspace_resources.sql.go @@ -0,0 +1,129 @@ +// Code generated by sqlc. DO NOT EDIT. +// source: workspace_resources.sql + +package database + +import ( + "context" + "time" + + "github.com/google/uuid" +) + +const getWorkspaceResourceByID = `-- name: GetWorkspaceResourceByID :one +SELECT + id, created_at, job_id, transition, address, type, name, agent_id +FROM + workspace_resources +WHERE + id = $1 +` + +func (q *sqlQuerier) GetWorkspaceResourceByID(ctx context.Context, id uuid.UUID) (WorkspaceResource, error) { + row := q.db.QueryRowContext(ctx, getWorkspaceResourceByID, id) + var i WorkspaceResource + err := row.Scan( + &i.ID, + &i.CreatedAt, + &i.JobID, + &i.Transition, + &i.Address, + &i.Type, + &i.Name, + &i.AgentID, + ) + return i, err +} + +const getWorkspaceResourcesByJobID = `-- name: GetWorkspaceResourcesByJobID :many +SELECT + id, created_at, job_id, transition, address, type, name, agent_id +FROM + workspace_resources +WHERE + job_id = $1 +` + +func (q *sqlQuerier) GetWorkspaceResourcesByJobID(ctx context.Context, jobID uuid.UUID) ([]WorkspaceResource, error) { + rows, err := q.db.QueryContext(ctx, getWorkspaceResourcesByJobID, jobID) + if err != nil { + return nil, err + } + defer rows.Close() + var items []WorkspaceResource + for rows.Next() { + var i WorkspaceResource + if err := rows.Scan( + &i.ID, + &i.CreatedAt, + &i.JobID, + &i.Transition, + &i.Address, + &i.Type, + &i.Name, + &i.AgentID, + ); 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 insertWorkspaceResource = `-- name: InsertWorkspaceResource :one +INSERT INTO + workspace_resources ( + id, + created_at, + job_id, + transition, + address, + type, + name, + agent_id + ) +VALUES + ($1, $2, $3, $4, $5, $6, $7, $8) RETURNING id, created_at, job_id, transition, address, type, name, agent_id +` + +type InsertWorkspaceResourceParams struct { + ID uuid.UUID `db:"id" json:"id"` + CreatedAt time.Time `db:"created_at" json:"created_at"` + JobID uuid.UUID `db:"job_id" json:"job_id"` + Transition WorkspaceTransition `db:"transition" json:"transition"` + Address string `db:"address" json:"address"` + Type string `db:"type" json:"type"` + Name string `db:"name" json:"name"` + AgentID uuid.NullUUID `db:"agent_id" json:"agent_id"` +} + +func (q *sqlQuerier) InsertWorkspaceResource(ctx context.Context, arg InsertWorkspaceResourceParams) (WorkspaceResource, error) { + row := q.db.QueryRowContext(ctx, insertWorkspaceResource, + arg.ID, + arg.CreatedAt, + arg.JobID, + arg.Transition, + arg.Address, + arg.Type, + arg.Name, + arg.AgentID, + ) + var i WorkspaceResource + err := row.Scan( + &i.ID, + &i.CreatedAt, + &i.JobID, + &i.Transition, + &i.Address, + &i.Type, + &i.Name, + &i.AgentID, + ) + return i, err +} diff --git a/coderd/database/workspaces.sql.go b/coderd/database/workspaces.sql.go new file mode 100644 index 0000000000000..38584e4cdd308 --- /dev/null +++ b/coderd/database/workspaces.sql.go @@ -0,0 +1,267 @@ +// Code generated by sqlc. DO NOT EDIT. +// source: workspaces.sql + +package database + +import ( + "context" + "time" + + "github.com/google/uuid" + "github.com/lib/pq" +) + +const getWorkspaceByID = `-- name: GetWorkspaceByID :one +SELECT + id, created_at, updated_at, owner_id, project_id, deleted, name +FROM + workspaces +WHERE + id = $1 +LIMIT + 1 +` + +func (q *sqlQuerier) GetWorkspaceByID(ctx context.Context, id uuid.UUID) (Workspace, error) { + row := q.db.QueryRowContext(ctx, getWorkspaceByID, id) + var i Workspace + err := row.Scan( + &i.ID, + &i.CreatedAt, + &i.UpdatedAt, + &i.OwnerID, + &i.ProjectID, + &i.Deleted, + &i.Name, + ) + return i, err +} + +const getWorkspaceByUserIDAndName = `-- name: GetWorkspaceByUserIDAndName :one +SELECT + id, created_at, updated_at, owner_id, project_id, deleted, name +FROM + workspaces +WHERE + owner_id = $1 + AND deleted = $2 + AND LOWER("name") = LOWER($3) +` + +type GetWorkspaceByUserIDAndNameParams struct { + OwnerID string `db:"owner_id" json:"owner_id"` + Deleted bool `db:"deleted" json:"deleted"` + Name string `db:"name" json:"name"` +} + +func (q *sqlQuerier) GetWorkspaceByUserIDAndName(ctx context.Context, arg GetWorkspaceByUserIDAndNameParams) (Workspace, error) { + row := q.db.QueryRowContext(ctx, getWorkspaceByUserIDAndName, arg.OwnerID, arg.Deleted, arg.Name) + var i Workspace + err := row.Scan( + &i.ID, + &i.CreatedAt, + &i.UpdatedAt, + &i.OwnerID, + &i.ProjectID, + &i.Deleted, + &i.Name, + ) + return i, err +} + +const getWorkspaceOwnerCountsByProjectIDs = `-- name: GetWorkspaceOwnerCountsByProjectIDs :many +SELECT + project_id, + COUNT(DISTINCT owner_id) +FROM + workspaces +WHERE + project_id = ANY($1 :: uuid [ ]) +GROUP BY + project_id, + owner_id +` + +type GetWorkspaceOwnerCountsByProjectIDsRow struct { + ProjectID uuid.UUID `db:"project_id" json:"project_id"` + Count int64 `db:"count" json:"count"` +} + +func (q *sqlQuerier) GetWorkspaceOwnerCountsByProjectIDs(ctx context.Context, ids []uuid.UUID) ([]GetWorkspaceOwnerCountsByProjectIDsRow, error) { + rows, err := q.db.QueryContext(ctx, getWorkspaceOwnerCountsByProjectIDs, pq.Array(ids)) + if err != nil { + return nil, err + } + defer rows.Close() + var items []GetWorkspaceOwnerCountsByProjectIDsRow + for rows.Next() { + var i GetWorkspaceOwnerCountsByProjectIDsRow + if err := rows.Scan(&i.ProjectID, &i.Count); 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 getWorkspacesByProjectID = `-- name: GetWorkspacesByProjectID :many +SELECT + id, created_at, updated_at, owner_id, project_id, deleted, name +FROM + workspaces +WHERE + project_id = $1 + AND deleted = $2 +` + +type GetWorkspacesByProjectIDParams struct { + ProjectID uuid.UUID `db:"project_id" json:"project_id"` + Deleted bool `db:"deleted" json:"deleted"` +} + +func (q *sqlQuerier) GetWorkspacesByProjectID(ctx context.Context, arg GetWorkspacesByProjectIDParams) ([]Workspace, error) { + rows, err := q.db.QueryContext(ctx, getWorkspacesByProjectID, arg.ProjectID, arg.Deleted) + if err != nil { + return nil, err + } + defer rows.Close() + var items []Workspace + for rows.Next() { + var i Workspace + if err := rows.Scan( + &i.ID, + &i.CreatedAt, + &i.UpdatedAt, + &i.OwnerID, + &i.ProjectID, + &i.Deleted, + &i.Name, + ); 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 getWorkspacesByUserID = `-- name: GetWorkspacesByUserID :many +SELECT + id, created_at, updated_at, owner_id, project_id, deleted, name +FROM + workspaces +WHERE + owner_id = $1 + AND deleted = $2 +` + +type GetWorkspacesByUserIDParams struct { + OwnerID string `db:"owner_id" json:"owner_id"` + Deleted bool `db:"deleted" json:"deleted"` +} + +func (q *sqlQuerier) GetWorkspacesByUserID(ctx context.Context, arg GetWorkspacesByUserIDParams) ([]Workspace, error) { + rows, err := q.db.QueryContext(ctx, getWorkspacesByUserID, arg.OwnerID, arg.Deleted) + if err != nil { + return nil, err + } + defer rows.Close() + var items []Workspace + for rows.Next() { + var i Workspace + if err := rows.Scan( + &i.ID, + &i.CreatedAt, + &i.UpdatedAt, + &i.OwnerID, + &i.ProjectID, + &i.Deleted, + &i.Name, + ); 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 insertWorkspace = `-- name: InsertWorkspace :one +INSERT INTO + workspaces ( + id, + created_at, + updated_at, + owner_id, + project_id, + name + ) +VALUES + ($1, $2, $3, $4, $5, $6) RETURNING id, created_at, updated_at, owner_id, project_id, deleted, name +` + +type InsertWorkspaceParams struct { + ID uuid.UUID `db:"id" json:"id"` + CreatedAt time.Time `db:"created_at" json:"created_at"` + UpdatedAt time.Time `db:"updated_at" json:"updated_at"` + OwnerID string `db:"owner_id" json:"owner_id"` + ProjectID uuid.UUID `db:"project_id" json:"project_id"` + Name string `db:"name" json:"name"` +} + +func (q *sqlQuerier) InsertWorkspace(ctx context.Context, arg InsertWorkspaceParams) (Workspace, error) { + row := q.db.QueryRowContext(ctx, insertWorkspace, + arg.ID, + arg.CreatedAt, + arg.UpdatedAt, + arg.OwnerID, + arg.ProjectID, + arg.Name, + ) + var i Workspace + err := row.Scan( + &i.ID, + &i.CreatedAt, + &i.UpdatedAt, + &i.OwnerID, + &i.ProjectID, + &i.Deleted, + &i.Name, + ) + return i, err +} + +const updateWorkspaceDeletedByID = `-- name: UpdateWorkspaceDeletedByID :exec +UPDATE + workspaces +SET + deleted = $2 +WHERE + id = $1 +` + +type UpdateWorkspaceDeletedByIDParams struct { + ID uuid.UUID `db:"id" json:"id"` + Deleted bool `db:"deleted" json:"deleted"` +} + +func (q *sqlQuerier) UpdateWorkspaceDeletedByID(ctx context.Context, arg UpdateWorkspaceDeletedByIDParams) error { + _, err := q.db.ExecContext(ctx, updateWorkspaceDeletedByID, arg.ID, arg.Deleted) + return err +} From b479668f34bda71d357c7cde6c95009f0106dcc4 Mon Sep 17 00:00:00 2001 From: Colin Adler Date: Thu, 31 Mar 2022 13:34:04 -0500 Subject: [PATCH 2/9] remove underscores from go filenames --- coderd/database/{api_keys.sql.go => apikeys.sql.go} | 2 +- .../{organization_members.sql.go => organizationmembers.sql.go} | 2 +- .../{parameter_schemas.sql.go => parameterschemas.sql.go} | 2 +- .../{parameter_values.sql.go => parametervalues.sql.go} | 2 +- .../{project_versions.sql.go => projectversions.sql.go} | 2 +- .../{provisioner_daemons.sql.go => provisionerdaemons.sql.go} | 2 +- .../{provisioner_job_logs.sql.go => provisionerjoblogs.sql.go} | 2 +- .../{provisioner_jobs.sql.go => provisionerjobs.sql.go} | 2 +- coderd/database/queries/{api_keys.sql => apikeys.sql} | 0 .../{organization_members.sql => organizationmembers.sql} | 0 .../queries/{parameter_schemas.sql => parameterschemas.sql} | 0 .../queries/{parameter_values.sql => parametervalues.sql} | 0 .../queries/{project_versions.sql => projectversions.sql} | 0 .../queries/{provisioner_daemons.sql => provisionerdaemons.sql} | 0 .../{provisioner_job_logs.sql => provisionerjoblogs.sql} | 0 .../queries/{provisioner_jobs.sql => provisionerjobs.sql} | 0 .../queries/{workspace_agents.sql => workspaceagents.sql} | 0 .../queries/{workspace_builds.sql => workspacebuilds.sql} | 0 .../queries/{workspace_resources.sql => workspaceresources.sql} | 0 .../{workspace_agents.sql.go => workspaceagents.sql.go} | 2 +- .../{workspace_builds.sql.go => workspacebuilds.sql.go} | 2 +- .../{workspace_resources.sql.go => workspaceresources.sql.go} | 2 +- 22 files changed, 11 insertions(+), 11 deletions(-) rename coderd/database/{api_keys.sql.go => apikeys.sql.go} (99%) rename coderd/database/{organization_members.sql.go => organizationmembers.sql.go} (98%) rename coderd/database/{parameter_schemas.sql.go => parameterschemas.sql.go} (99%) rename coderd/database/{parameter_values.sql.go => parametervalues.sql.go} (99%) rename coderd/database/{project_versions.sql.go => projectversions.sql.go} (99%) rename coderd/database/{provisioner_daemons.sql.go => provisionerdaemons.sql.go} (98%) rename coderd/database/{provisioner_job_logs.sql.go => provisionerjoblogs.sql.go} (98%) rename coderd/database/{provisioner_jobs.sql.go => provisionerjobs.sql.go} (99%) rename coderd/database/queries/{api_keys.sql => apikeys.sql} (100%) rename coderd/database/queries/{organization_members.sql => organizationmembers.sql} (100%) rename coderd/database/queries/{parameter_schemas.sql => parameterschemas.sql} (100%) rename coderd/database/queries/{parameter_values.sql => parametervalues.sql} (100%) rename coderd/database/queries/{project_versions.sql => projectversions.sql} (100%) rename coderd/database/queries/{provisioner_daemons.sql => provisionerdaemons.sql} (100%) rename coderd/database/queries/{provisioner_job_logs.sql => provisionerjoblogs.sql} (100%) rename coderd/database/queries/{provisioner_jobs.sql => provisionerjobs.sql} (100%) rename coderd/database/queries/{workspace_agents.sql => workspaceagents.sql} (100%) rename coderd/database/queries/{workspace_builds.sql => workspacebuilds.sql} (100%) rename coderd/database/queries/{workspace_resources.sql => workspaceresources.sql} (100%) rename coderd/database/{workspace_agents.sql.go => workspaceagents.sql.go} (99%) rename coderd/database/{workspace_builds.sql.go => workspacebuilds.sql.go} (99%) rename coderd/database/{workspace_resources.sql.go => workspaceresources.sql.go} (98%) diff --git a/coderd/database/api_keys.sql.go b/coderd/database/apikeys.sql.go similarity index 99% rename from coderd/database/api_keys.sql.go rename to coderd/database/apikeys.sql.go index 7384167d5ca59..c4afe88b4ca78 100644 --- a/coderd/database/api_keys.sql.go +++ b/coderd/database/apikeys.sql.go @@ -1,5 +1,5 @@ // Code generated by sqlc. DO NOT EDIT. -// source: api_keys.sql +// source: apikeys.sql package database diff --git a/coderd/database/organization_members.sql.go b/coderd/database/organizationmembers.sql.go similarity index 98% rename from coderd/database/organization_members.sql.go rename to coderd/database/organizationmembers.sql.go index 374c49aea145e..2284c714ec23e 100644 --- a/coderd/database/organization_members.sql.go +++ b/coderd/database/organizationmembers.sql.go @@ -1,5 +1,5 @@ // Code generated by sqlc. DO NOT EDIT. -// source: organization_members.sql +// source: organizationmembers.sql package database diff --git a/coderd/database/parameter_schemas.sql.go b/coderd/database/parameterschemas.sql.go similarity index 99% rename from coderd/database/parameter_schemas.sql.go rename to coderd/database/parameterschemas.sql.go index fbcfe1ac96f96..4928478a5f242 100644 --- a/coderd/database/parameter_schemas.sql.go +++ b/coderd/database/parameterschemas.sql.go @@ -1,5 +1,5 @@ // Code generated by sqlc. DO NOT EDIT. -// source: parameter_schemas.sql +// source: parameterschemas.sql package database diff --git a/coderd/database/parameter_values.sql.go b/coderd/database/parametervalues.sql.go similarity index 99% rename from coderd/database/parameter_values.sql.go rename to coderd/database/parametervalues.sql.go index ca9b7a2d7ebc4..f7d2f9d720b28 100644 --- a/coderd/database/parameter_values.sql.go +++ b/coderd/database/parametervalues.sql.go @@ -1,5 +1,5 @@ // Code generated by sqlc. DO NOT EDIT. -// source: parameter_values.sql +// source: parametervalues.sql package database diff --git a/coderd/database/project_versions.sql.go b/coderd/database/projectversions.sql.go similarity index 99% rename from coderd/database/project_versions.sql.go rename to coderd/database/projectversions.sql.go index f1ed9fe7bb67e..528236bcdfc6d 100644 --- a/coderd/database/project_versions.sql.go +++ b/coderd/database/projectversions.sql.go @@ -1,5 +1,5 @@ // Code generated by sqlc. DO NOT EDIT. -// source: project_versions.sql +// source: projectversions.sql package database diff --git a/coderd/database/provisioner_daemons.sql.go b/coderd/database/provisionerdaemons.sql.go similarity index 98% rename from coderd/database/provisioner_daemons.sql.go rename to coderd/database/provisionerdaemons.sql.go index eef7dc5d6f0fc..40da1db177741 100644 --- a/coderd/database/provisioner_daemons.sql.go +++ b/coderd/database/provisionerdaemons.sql.go @@ -1,5 +1,5 @@ // Code generated by sqlc. DO NOT EDIT. -// source: provisioner_daemons.sql +// source: provisionerdaemons.sql package database diff --git a/coderd/database/provisioner_job_logs.sql.go b/coderd/database/provisionerjoblogs.sql.go similarity index 98% rename from coderd/database/provisioner_job_logs.sql.go rename to coderd/database/provisionerjoblogs.sql.go index a7f25aa0c8b19..9762c160f9cef 100644 --- a/coderd/database/provisioner_job_logs.sql.go +++ b/coderd/database/provisionerjoblogs.sql.go @@ -1,5 +1,5 @@ // Code generated by sqlc. DO NOT EDIT. -// source: provisioner_job_logs.sql +// source: provisionerjoblogs.sql package database diff --git a/coderd/database/provisioner_jobs.sql.go b/coderd/database/provisionerjobs.sql.go similarity index 99% rename from coderd/database/provisioner_jobs.sql.go rename to coderd/database/provisionerjobs.sql.go index 683e5adddbb1b..ac1340a7de899 100644 --- a/coderd/database/provisioner_jobs.sql.go +++ b/coderd/database/provisionerjobs.sql.go @@ -1,5 +1,5 @@ // Code generated by sqlc. DO NOT EDIT. -// source: provisioner_jobs.sql +// source: provisionerjobs.sql package database diff --git a/coderd/database/queries/api_keys.sql b/coderd/database/queries/apikeys.sql similarity index 100% rename from coderd/database/queries/api_keys.sql rename to coderd/database/queries/apikeys.sql diff --git a/coderd/database/queries/organization_members.sql b/coderd/database/queries/organizationmembers.sql similarity index 100% rename from coderd/database/queries/organization_members.sql rename to coderd/database/queries/organizationmembers.sql diff --git a/coderd/database/queries/parameter_schemas.sql b/coderd/database/queries/parameterschemas.sql similarity index 100% rename from coderd/database/queries/parameter_schemas.sql rename to coderd/database/queries/parameterschemas.sql diff --git a/coderd/database/queries/parameter_values.sql b/coderd/database/queries/parametervalues.sql similarity index 100% rename from coderd/database/queries/parameter_values.sql rename to coderd/database/queries/parametervalues.sql diff --git a/coderd/database/queries/project_versions.sql b/coderd/database/queries/projectversions.sql similarity index 100% rename from coderd/database/queries/project_versions.sql rename to coderd/database/queries/projectversions.sql diff --git a/coderd/database/queries/provisioner_daemons.sql b/coderd/database/queries/provisionerdaemons.sql similarity index 100% rename from coderd/database/queries/provisioner_daemons.sql rename to coderd/database/queries/provisionerdaemons.sql diff --git a/coderd/database/queries/provisioner_job_logs.sql b/coderd/database/queries/provisionerjoblogs.sql similarity index 100% rename from coderd/database/queries/provisioner_job_logs.sql rename to coderd/database/queries/provisionerjoblogs.sql diff --git a/coderd/database/queries/provisioner_jobs.sql b/coderd/database/queries/provisionerjobs.sql similarity index 100% rename from coderd/database/queries/provisioner_jobs.sql rename to coderd/database/queries/provisionerjobs.sql diff --git a/coderd/database/queries/workspace_agents.sql b/coderd/database/queries/workspaceagents.sql similarity index 100% rename from coderd/database/queries/workspace_agents.sql rename to coderd/database/queries/workspaceagents.sql diff --git a/coderd/database/queries/workspace_builds.sql b/coderd/database/queries/workspacebuilds.sql similarity index 100% rename from coderd/database/queries/workspace_builds.sql rename to coderd/database/queries/workspacebuilds.sql diff --git a/coderd/database/queries/workspace_resources.sql b/coderd/database/queries/workspaceresources.sql similarity index 100% rename from coderd/database/queries/workspace_resources.sql rename to coderd/database/queries/workspaceresources.sql diff --git a/coderd/database/workspace_agents.sql.go b/coderd/database/workspaceagents.sql.go similarity index 99% rename from coderd/database/workspace_agents.sql.go rename to coderd/database/workspaceagents.sql.go index 951fcc4b57cb6..e0d61981792da 100644 --- a/coderd/database/workspace_agents.sql.go +++ b/coderd/database/workspaceagents.sql.go @@ -1,5 +1,5 @@ // Code generated by sqlc. DO NOT EDIT. -// source: workspace_agents.sql +// source: workspaceagents.sql package database diff --git a/coderd/database/workspace_builds.sql.go b/coderd/database/workspacebuilds.sql.go similarity index 99% rename from coderd/database/workspace_builds.sql.go rename to coderd/database/workspacebuilds.sql.go index f0309c72775a5..2752db26d43d9 100644 --- a/coderd/database/workspace_builds.sql.go +++ b/coderd/database/workspacebuilds.sql.go @@ -1,5 +1,5 @@ // Code generated by sqlc. DO NOT EDIT. -// source: workspace_builds.sql +// source: workspacebuilds.sql package database diff --git a/coderd/database/workspace_resources.sql.go b/coderd/database/workspaceresources.sql.go similarity index 98% rename from coderd/database/workspace_resources.sql.go rename to coderd/database/workspaceresources.sql.go index 874253e8c6831..78c11570d4737 100644 --- a/coderd/database/workspace_resources.sql.go +++ b/coderd/database/workspaceresources.sql.go @@ -1,5 +1,5 @@ // Code generated by sqlc. DO NOT EDIT. -// source: workspace_resources.sql +// source: workspaceresources.sql package database From 03b80051bbe3ecae17cc4fa5702dec558ddf53ba Mon Sep 17 00:00:00 2001 From: Colin Adler Date: Thu, 31 Mar 2022 16:45:19 -0500 Subject: [PATCH 3/9] queries in one file --- Makefile | 5 +- coderd/database/apikeys.sql.go | 173 -- coderd/database/files.sql.go | 67 - coderd/database/generate.sh | 26 + coderd/database/organizationmembers.sql.go | 81 - coderd/database/organizations.sql.go | 154 -- coderd/database/parameterschemas.sql.go | 161 -- coderd/database/parametervalues.sql.go | 163 -- coderd/database/projects.sql.go | 249 -- coderd/database/projectversions.sql.go | 206 -- coderd/database/provisionerdaemons.sql.go | 135 - coderd/database/provisionerjoblogs.sql.go | 126 - coderd/database/provisionerjobs.sql.go | 287 --- coderd/database/queries.sql.go | 2725 ++++++++++++++++++++ coderd/database/sqlc.yaml | 4 +- coderd/database/users.sql.go | 171 -- coderd/database/workspaceagents.sql.go | 198 -- coderd/database/workspacebuilds.sql.go | 325 --- coderd/database/workspaceresources.sql.go | 129 - coderd/database/workspaces.sql.go | 267 -- go.mod | 3 +- 21 files changed, 2756 insertions(+), 2899 deletions(-) delete mode 100644 coderd/database/apikeys.sql.go delete mode 100644 coderd/database/files.sql.go create mode 100755 coderd/database/generate.sh delete mode 100644 coderd/database/organizationmembers.sql.go delete mode 100644 coderd/database/organizations.sql.go delete mode 100644 coderd/database/parameterschemas.sql.go delete mode 100644 coderd/database/parametervalues.sql.go delete mode 100644 coderd/database/projects.sql.go delete mode 100644 coderd/database/projectversions.sql.go delete mode 100644 coderd/database/provisionerdaemons.sql.go delete mode 100644 coderd/database/provisionerjoblogs.sql.go delete mode 100644 coderd/database/provisionerjobs.sql.go create mode 100644 coderd/database/queries.sql.go delete mode 100644 coderd/database/users.sql.go delete mode 100644 coderd/database/workspaceagents.sql.go delete mode 100644 coderd/database/workspacebuilds.sql.go delete mode 100644 coderd/database/workspaceresources.sql.go delete mode 100644 coderd/database/workspaces.sql.go diff --git a/Makefile b/Makefile index eed7bd896e10b..91baebe6cc1ee 100644 --- a/Makefile +++ b/Makefile @@ -16,9 +16,7 @@ coderd/database/dump.sql: $(wildcard coderd/database/migrations/*.sql) # Generates Go code for querying the database. coderd/database/generate: fmt/sql coderd/database/dump.sql $(wildcard coderd/database/queries/*.sql) - cd coderd/database && sqlc generate && rm db_tmp.go - cd coderd/database && gofmt -w -r 'Querier -> querier' *.go - cd coderd/database && gofmt -w -r 'Queries -> sqlQuerier' *.go + coderd/database/generate.sh .PHONY: coderd/database/generate fmt/prettier: @@ -32,6 +30,7 @@ endif .PHONY: fmt/prettier fmt/sql: $(wildcard coderd/database/queries/*.sql) + # TODO: this is slightly slow for fi in coderd/database/queries/*.sql; do \ npx sql-formatter \ --language postgresql \ diff --git a/coderd/database/apikeys.sql.go b/coderd/database/apikeys.sql.go deleted file mode 100644 index c4afe88b4ca78..0000000000000 --- a/coderd/database/apikeys.sql.go +++ /dev/null @@ -1,173 +0,0 @@ -// Code generated by sqlc. DO NOT EDIT. -// source: apikeys.sql - -package database - -import ( - "context" - "time" -) - -const getAPIKeyByID = `-- name: GetAPIKeyByID :one -SELECT - id, hashed_secret, user_id, application, name, last_used, expires_at, created_at, updated_at, login_type, oidc_access_token, oidc_refresh_token, oidc_id_token, oidc_expiry, devurl_token -FROM - api_keys -WHERE - id = $1 -LIMIT - 1 -` - -func (q *sqlQuerier) GetAPIKeyByID(ctx context.Context, id string) (APIKey, error) { - row := q.db.QueryRowContext(ctx, getAPIKeyByID, id) - var i APIKey - err := row.Scan( - &i.ID, - &i.HashedSecret, - &i.UserID, - &i.Application, - &i.Name, - &i.LastUsed, - &i.ExpiresAt, - &i.CreatedAt, - &i.UpdatedAt, - &i.LoginType, - &i.OIDCAccessToken, - &i.OIDCRefreshToken, - &i.OIDCIDToken, - &i.OIDCExpiry, - &i.DevurlToken, - ) - return i, err -} - -const insertAPIKey = `-- name: InsertAPIKey :one -INSERT INTO - api_keys ( - id, - hashed_secret, - user_id, - application, - "name", - last_used, - expires_at, - created_at, - updated_at, - login_type, - oidc_access_token, - oidc_refresh_token, - oidc_id_token, - oidc_expiry, - devurl_token - ) -VALUES - ( - $1, - $2, - $3, - $4, - $5, - $6, - $7, - $8, - $9, - $10, - $11, - $12, - $13, - $14, - $15 - ) RETURNING id, hashed_secret, user_id, application, name, last_used, expires_at, created_at, updated_at, login_type, oidc_access_token, oidc_refresh_token, oidc_id_token, oidc_expiry, devurl_token -` - -type InsertAPIKeyParams struct { - ID string `db:"id" json:"id"` - HashedSecret []byte `db:"hashed_secret" json:"hashed_secret"` - UserID string `db:"user_id" json:"user_id"` - Application bool `db:"application" json:"application"` - Name string `db:"name" json:"name"` - LastUsed time.Time `db:"last_used" json:"last_used"` - ExpiresAt time.Time `db:"expires_at" json:"expires_at"` - CreatedAt time.Time `db:"created_at" json:"created_at"` - UpdatedAt time.Time `db:"updated_at" json:"updated_at"` - LoginType LoginType `db:"login_type" json:"login_type"` - OIDCAccessToken string `db:"oidc_access_token" json:"oidc_access_token"` - OIDCRefreshToken string `db:"oidc_refresh_token" json:"oidc_refresh_token"` - OIDCIDToken string `db:"oidc_id_token" json:"oidc_id_token"` - OIDCExpiry time.Time `db:"oidc_expiry" json:"oidc_expiry"` - DevurlToken bool `db:"devurl_token" json:"devurl_token"` -} - -func (q *sqlQuerier) InsertAPIKey(ctx context.Context, arg InsertAPIKeyParams) (APIKey, error) { - row := q.db.QueryRowContext(ctx, insertAPIKey, - arg.ID, - arg.HashedSecret, - arg.UserID, - arg.Application, - arg.Name, - arg.LastUsed, - arg.ExpiresAt, - arg.CreatedAt, - arg.UpdatedAt, - arg.LoginType, - arg.OIDCAccessToken, - arg.OIDCRefreshToken, - arg.OIDCIDToken, - arg.OIDCExpiry, - arg.DevurlToken, - ) - var i APIKey - err := row.Scan( - &i.ID, - &i.HashedSecret, - &i.UserID, - &i.Application, - &i.Name, - &i.LastUsed, - &i.ExpiresAt, - &i.CreatedAt, - &i.UpdatedAt, - &i.LoginType, - &i.OIDCAccessToken, - &i.OIDCRefreshToken, - &i.OIDCIDToken, - &i.OIDCExpiry, - &i.DevurlToken, - ) - return i, err -} - -const updateAPIKeyByID = `-- name: UpdateAPIKeyByID :exec -UPDATE - api_keys -SET - last_used = $2, - expires_at = $3, - oidc_access_token = $4, - oidc_refresh_token = $5, - oidc_expiry = $6 -WHERE - id = $1 -` - -type UpdateAPIKeyByIDParams struct { - ID string `db:"id" json:"id"` - LastUsed time.Time `db:"last_used" json:"last_used"` - ExpiresAt time.Time `db:"expires_at" json:"expires_at"` - OIDCAccessToken string `db:"oidc_access_token" json:"oidc_access_token"` - OIDCRefreshToken string `db:"oidc_refresh_token" json:"oidc_refresh_token"` - OIDCExpiry time.Time `db:"oidc_expiry" json:"oidc_expiry"` -} - -func (q *sqlQuerier) UpdateAPIKeyByID(ctx context.Context, arg UpdateAPIKeyByIDParams) error { - _, err := q.db.ExecContext(ctx, updateAPIKeyByID, - arg.ID, - arg.LastUsed, - arg.ExpiresAt, - arg.OIDCAccessToken, - arg.OIDCRefreshToken, - arg.OIDCExpiry, - ) - return err -} diff --git a/coderd/database/files.sql.go b/coderd/database/files.sql.go deleted file mode 100644 index d77126bea2237..0000000000000 --- a/coderd/database/files.sql.go +++ /dev/null @@ -1,67 +0,0 @@ -// Code generated by sqlc. DO NOT EDIT. -// source: files.sql - -package database - -import ( - "context" - "time" -) - -const getFileByHash = `-- name: GetFileByHash :one -SELECT - hash, created_at, created_by, mimetype, data -FROM - files -WHERE - hash = $1 -LIMIT - 1 -` - -func (q *sqlQuerier) GetFileByHash(ctx context.Context, hash string) (File, error) { - row := q.db.QueryRowContext(ctx, getFileByHash, hash) - var i File - err := row.Scan( - &i.Hash, - &i.CreatedAt, - &i.CreatedBy, - &i.Mimetype, - &i.Data, - ) - return i, err -} - -const insertFile = `-- name: InsertFile :one -INSERT INTO - files (hash, created_at, created_by, mimetype, "data") -VALUES - ($1, $2, $3, $4, $5) RETURNING hash, created_at, created_by, mimetype, data -` - -type InsertFileParams struct { - Hash string `db:"hash" json:"hash"` - CreatedAt time.Time `db:"created_at" json:"created_at"` - CreatedBy string `db:"created_by" json:"created_by"` - Mimetype string `db:"mimetype" json:"mimetype"` - Data []byte `db:"data" json:"data"` -} - -func (q *sqlQuerier) InsertFile(ctx context.Context, arg InsertFileParams) (File, error) { - row := q.db.QueryRowContext(ctx, insertFile, - arg.Hash, - arg.CreatedAt, - arg.CreatedBy, - arg.Mimetype, - arg.Data, - ) - var i File - err := row.Scan( - &i.Hash, - &i.CreatedAt, - &i.CreatedBy, - &i.Mimetype, - &i.Data, - ) - return i, err -} diff --git a/coderd/database/generate.sh b/coderd/database/generate.sh new file mode 100755 index 0000000000000..20268098cb3de --- /dev/null +++ b/coderd/database/generate.sh @@ -0,0 +1,26 @@ +#!/usr/bin/env bash + +set -euo pipefail + +cd "$(dirname "$0")" + +sqlc generate + +first=true +for fi in queries/*.sql.go; do + cut=$(grep -n ')' "$fi" | head -n 1 | cut -d: -f1) + cut=$((cut + 1)) + + if $first; then + head -n 4 < "$fi" | grep -v "source" > queries.sql.go + first=false + fi + + tail -n "+$cut" < "$fi" >> queries.sql.go +done + +rm -f queries/*.go + +goimports -w queries.sql.go +gofmt -w -r 'Querier -> querier' -- *.go +gofmt -w -r 'Queries -> sqlQuerier' -- *.go diff --git a/coderd/database/organizationmembers.sql.go b/coderd/database/organizationmembers.sql.go deleted file mode 100644 index 2284c714ec23e..0000000000000 --- a/coderd/database/organizationmembers.sql.go +++ /dev/null @@ -1,81 +0,0 @@ -// Code generated by sqlc. DO NOT EDIT. -// source: organizationmembers.sql - -package database - -import ( - "context" - "time" - - "github.com/lib/pq" -) - -const getOrganizationMemberByUserID = `-- name: GetOrganizationMemberByUserID :one -SELECT - organization_id, user_id, created_at, updated_at, roles -FROM - organization_members -WHERE - organization_id = $1 - AND user_id = $2 -LIMIT - 1 -` - -type GetOrganizationMemberByUserIDParams struct { - OrganizationID string `db:"organization_id" json:"organization_id"` - UserID string `db:"user_id" json:"user_id"` -} - -func (q *sqlQuerier) GetOrganizationMemberByUserID(ctx context.Context, arg GetOrganizationMemberByUserIDParams) (OrganizationMember, error) { - row := q.db.QueryRowContext(ctx, getOrganizationMemberByUserID, arg.OrganizationID, arg.UserID) - var i OrganizationMember - err := row.Scan( - &i.OrganizationID, - &i.UserID, - &i.CreatedAt, - &i.UpdatedAt, - pq.Array(&i.Roles), - ) - return i, err -} - -const insertOrganizationMember = `-- name: InsertOrganizationMember :one -INSERT INTO - organization_members ( - organization_id, - user_id, - created_at, - updated_at, - roles - ) -VALUES - ($1, $2, $3, $4, $5) RETURNING organization_id, user_id, created_at, updated_at, roles -` - -type InsertOrganizationMemberParams struct { - OrganizationID string `db:"organization_id" json:"organization_id"` - UserID string `db:"user_id" json:"user_id"` - CreatedAt time.Time `db:"created_at" json:"created_at"` - UpdatedAt time.Time `db:"updated_at" json:"updated_at"` - Roles []string `db:"roles" json:"roles"` -} - -func (q *sqlQuerier) InsertOrganizationMember(ctx context.Context, arg InsertOrganizationMemberParams) (OrganizationMember, error) { - row := q.db.QueryRowContext(ctx, insertOrganizationMember, - arg.OrganizationID, - arg.UserID, - arg.CreatedAt, - arg.UpdatedAt, - pq.Array(arg.Roles), - ) - var i OrganizationMember - err := row.Scan( - &i.OrganizationID, - &i.UserID, - &i.CreatedAt, - &i.UpdatedAt, - pq.Array(&i.Roles), - ) - return i, err -} diff --git a/coderd/database/organizations.sql.go b/coderd/database/organizations.sql.go deleted file mode 100644 index 4552a5922ca4d..0000000000000 --- a/coderd/database/organizations.sql.go +++ /dev/null @@ -1,154 +0,0 @@ -// Code generated by sqlc. DO NOT EDIT. -// source: organizations.sql - -package database - -import ( - "context" - "time" -) - -const getOrganizationByID = `-- name: GetOrganizationByID :one -SELECT - id, name, description, created_at, updated_at, "default", auto_off_threshold, cpu_provisioning_rate, memory_provisioning_rate, workspace_auto_off -FROM - organizations -WHERE - id = $1 -` - -func (q *sqlQuerier) GetOrganizationByID(ctx context.Context, id string) (Organization, error) { - row := q.db.QueryRowContext(ctx, getOrganizationByID, id) - var i Organization - err := row.Scan( - &i.ID, - &i.Name, - &i.Description, - &i.CreatedAt, - &i.UpdatedAt, - &i.Default, - &i.AutoOffThreshold, - &i.CpuProvisioningRate, - &i.MemoryProvisioningRate, - &i.WorkspaceAutoOff, - ) - return i, err -} - -const getOrganizationByName = `-- name: GetOrganizationByName :one -SELECT - id, name, description, created_at, updated_at, "default", auto_off_threshold, cpu_provisioning_rate, memory_provisioning_rate, workspace_auto_off -FROM - organizations -WHERE - LOWER("name") = LOWER($1) -LIMIT - 1 -` - -func (q *sqlQuerier) GetOrganizationByName(ctx context.Context, name string) (Organization, error) { - row := q.db.QueryRowContext(ctx, getOrganizationByName, name) - var i Organization - err := row.Scan( - &i.ID, - &i.Name, - &i.Description, - &i.CreatedAt, - &i.UpdatedAt, - &i.Default, - &i.AutoOffThreshold, - &i.CpuProvisioningRate, - &i.MemoryProvisioningRate, - &i.WorkspaceAutoOff, - ) - return i, err -} - -const getOrganizationsByUserID = `-- name: GetOrganizationsByUserID :many -SELECT - id, name, description, created_at, updated_at, "default", auto_off_threshold, cpu_provisioning_rate, memory_provisioning_rate, workspace_auto_off -FROM - organizations -WHERE - id = ( - SELECT - organization_id - FROM - organization_members - WHERE - user_id = $1 - ) -` - -func (q *sqlQuerier) GetOrganizationsByUserID(ctx context.Context, userID string) ([]Organization, error) { - rows, err := q.db.QueryContext(ctx, getOrganizationsByUserID, userID) - if err != nil { - return nil, err - } - defer rows.Close() - var items []Organization - for rows.Next() { - var i Organization - if err := rows.Scan( - &i.ID, - &i.Name, - &i.Description, - &i.CreatedAt, - &i.UpdatedAt, - &i.Default, - &i.AutoOffThreshold, - &i.CpuProvisioningRate, - &i.MemoryProvisioningRate, - &i.WorkspaceAutoOff, - ); 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 insertOrganization = `-- name: InsertOrganization :one -INSERT INTO - organizations (id, "name", description, created_at, updated_at) -VALUES - ($1, $2, $3, $4, $5) RETURNING id, name, description, created_at, updated_at, "default", auto_off_threshold, cpu_provisioning_rate, memory_provisioning_rate, workspace_auto_off -` - -type InsertOrganizationParams struct { - ID string `db:"id" json:"id"` - Name string `db:"name" json:"name"` - Description string `db:"description" json:"description"` - CreatedAt time.Time `db:"created_at" json:"created_at"` - UpdatedAt time.Time `db:"updated_at" json:"updated_at"` -} - -func (q *sqlQuerier) InsertOrganization(ctx context.Context, arg InsertOrganizationParams) (Organization, error) { - row := q.db.QueryRowContext(ctx, insertOrganization, - arg.ID, - arg.Name, - arg.Description, - arg.CreatedAt, - arg.UpdatedAt, - ) - var i Organization - err := row.Scan( - &i.ID, - &i.Name, - &i.Description, - &i.CreatedAt, - &i.UpdatedAt, - &i.Default, - &i.AutoOffThreshold, - &i.CpuProvisioningRate, - &i.MemoryProvisioningRate, - &i.WorkspaceAutoOff, - ) - return i, err -} diff --git a/coderd/database/parameterschemas.sql.go b/coderd/database/parameterschemas.sql.go deleted file mode 100644 index 4928478a5f242..0000000000000 --- a/coderd/database/parameterschemas.sql.go +++ /dev/null @@ -1,161 +0,0 @@ -// Code generated by sqlc. DO NOT EDIT. -// source: parameterschemas.sql - -package database - -import ( - "context" - "time" - - "github.com/google/uuid" -) - -const getParameterSchemasByJobID = `-- name: GetParameterSchemasByJobID :many -SELECT - id, created_at, job_id, name, description, default_source_scheme, default_source_value, allow_override_source, default_destination_scheme, allow_override_destination, default_refresh, redisplay_value, validation_error, validation_condition, validation_type_system, validation_value_type -FROM - parameter_schemas -WHERE - job_id = $1 -` - -func (q *sqlQuerier) GetParameterSchemasByJobID(ctx context.Context, jobID uuid.UUID) ([]ParameterSchema, error) { - rows, err := q.db.QueryContext(ctx, getParameterSchemasByJobID, jobID) - if err != nil { - return nil, err - } - defer rows.Close() - var items []ParameterSchema - for rows.Next() { - var i ParameterSchema - if err := rows.Scan( - &i.ID, - &i.CreatedAt, - &i.JobID, - &i.Name, - &i.Description, - &i.DefaultSourceScheme, - &i.DefaultSourceValue, - &i.AllowOverrideSource, - &i.DefaultDestinationScheme, - &i.AllowOverrideDestination, - &i.DefaultRefresh, - &i.RedisplayValue, - &i.ValidationError, - &i.ValidationCondition, - &i.ValidationTypeSystem, - &i.ValidationValueType, - ); 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 insertParameterSchema = `-- name: InsertParameterSchema :one -INSERT INTO - parameter_schemas ( - id, - created_at, - job_id, - "name", - description, - default_source_scheme, - default_source_value, - allow_override_source, - default_destination_scheme, - allow_override_destination, - default_refresh, - redisplay_value, - validation_error, - validation_condition, - validation_type_system, - validation_value_type - ) -VALUES - ( - $1, - $2, - $3, - $4, - $5, - $6, - $7, - $8, - $9, - $10, - $11, - $12, - $13, - $14, - $15, - $16 - ) RETURNING id, created_at, job_id, name, description, default_source_scheme, default_source_value, allow_override_source, default_destination_scheme, allow_override_destination, default_refresh, redisplay_value, validation_error, validation_condition, validation_type_system, validation_value_type -` - -type InsertParameterSchemaParams struct { - ID uuid.UUID `db:"id" json:"id"` - CreatedAt time.Time `db:"created_at" json:"created_at"` - JobID uuid.UUID `db:"job_id" json:"job_id"` - Name string `db:"name" json:"name"` - Description string `db:"description" json:"description"` - DefaultSourceScheme ParameterSourceScheme `db:"default_source_scheme" json:"default_source_scheme"` - DefaultSourceValue string `db:"default_source_value" json:"default_source_value"` - AllowOverrideSource bool `db:"allow_override_source" json:"allow_override_source"` - DefaultDestinationScheme ParameterDestinationScheme `db:"default_destination_scheme" json:"default_destination_scheme"` - AllowOverrideDestination bool `db:"allow_override_destination" json:"allow_override_destination"` - DefaultRefresh string `db:"default_refresh" json:"default_refresh"` - RedisplayValue bool `db:"redisplay_value" json:"redisplay_value"` - ValidationError string `db:"validation_error" json:"validation_error"` - ValidationCondition string `db:"validation_condition" json:"validation_condition"` - ValidationTypeSystem ParameterTypeSystem `db:"validation_type_system" json:"validation_type_system"` - ValidationValueType string `db:"validation_value_type" json:"validation_value_type"` -} - -func (q *sqlQuerier) InsertParameterSchema(ctx context.Context, arg InsertParameterSchemaParams) (ParameterSchema, error) { - row := q.db.QueryRowContext(ctx, insertParameterSchema, - arg.ID, - arg.CreatedAt, - arg.JobID, - arg.Name, - arg.Description, - arg.DefaultSourceScheme, - arg.DefaultSourceValue, - arg.AllowOverrideSource, - arg.DefaultDestinationScheme, - arg.AllowOverrideDestination, - arg.DefaultRefresh, - arg.RedisplayValue, - arg.ValidationError, - arg.ValidationCondition, - arg.ValidationTypeSystem, - arg.ValidationValueType, - ) - var i ParameterSchema - err := row.Scan( - &i.ID, - &i.CreatedAt, - &i.JobID, - &i.Name, - &i.Description, - &i.DefaultSourceScheme, - &i.DefaultSourceValue, - &i.AllowOverrideSource, - &i.DefaultDestinationScheme, - &i.AllowOverrideDestination, - &i.DefaultRefresh, - &i.RedisplayValue, - &i.ValidationError, - &i.ValidationCondition, - &i.ValidationTypeSystem, - &i.ValidationValueType, - ) - return i, err -} diff --git a/coderd/database/parametervalues.sql.go b/coderd/database/parametervalues.sql.go deleted file mode 100644 index f7d2f9d720b28..0000000000000 --- a/coderd/database/parametervalues.sql.go +++ /dev/null @@ -1,163 +0,0 @@ -// Code generated by sqlc. DO NOT EDIT. -// source: parametervalues.sql - -package database - -import ( - "context" - "time" - - "github.com/google/uuid" -) - -const deleteParameterValueByID = `-- name: DeleteParameterValueByID :exec -DELETE FROM - parameter_values -WHERE - id = $1 -` - -func (q *sqlQuerier) DeleteParameterValueByID(ctx context.Context, id uuid.UUID) error { - _, err := q.db.ExecContext(ctx, deleteParameterValueByID, id) - return err -} - -const getParameterValueByScopeAndName = `-- name: GetParameterValueByScopeAndName :one -SELECT - id, created_at, updated_at, scope, scope_id, name, source_scheme, source_value, destination_scheme -FROM - parameter_values -WHERE - scope = $1 - AND scope_id = $2 - AND NAME = $3 -LIMIT - 1 -` - -type GetParameterValueByScopeAndNameParams struct { - Scope ParameterScope `db:"scope" json:"scope"` - ScopeID string `db:"scope_id" json:"scope_id"` - Name string `db:"name" json:"name"` -} - -func (q *sqlQuerier) GetParameterValueByScopeAndName(ctx context.Context, arg GetParameterValueByScopeAndNameParams) (ParameterValue, error) { - row := q.db.QueryRowContext(ctx, getParameterValueByScopeAndName, arg.Scope, arg.ScopeID, arg.Name) - var i ParameterValue - err := row.Scan( - &i.ID, - &i.CreatedAt, - &i.UpdatedAt, - &i.Scope, - &i.ScopeID, - &i.Name, - &i.SourceScheme, - &i.SourceValue, - &i.DestinationScheme, - ) - return i, err -} - -const getParameterValuesByScope = `-- name: GetParameterValuesByScope :many -SELECT - id, created_at, updated_at, scope, scope_id, name, source_scheme, source_value, destination_scheme -FROM - parameter_values -WHERE - scope = $1 - AND scope_id = $2 -` - -type GetParameterValuesByScopeParams struct { - Scope ParameterScope `db:"scope" json:"scope"` - ScopeID string `db:"scope_id" json:"scope_id"` -} - -func (q *sqlQuerier) GetParameterValuesByScope(ctx context.Context, arg GetParameterValuesByScopeParams) ([]ParameterValue, error) { - rows, err := q.db.QueryContext(ctx, getParameterValuesByScope, arg.Scope, arg.ScopeID) - if err != nil { - return nil, err - } - defer rows.Close() - var items []ParameterValue - for rows.Next() { - var i ParameterValue - if err := rows.Scan( - &i.ID, - &i.CreatedAt, - &i.UpdatedAt, - &i.Scope, - &i.ScopeID, - &i.Name, - &i.SourceScheme, - &i.SourceValue, - &i.DestinationScheme, - ); 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 insertParameterValue = `-- name: InsertParameterValue :one -INSERT INTO - parameter_values ( - id, - "name", - created_at, - updated_at, - scope, - scope_id, - source_scheme, - source_value, - destination_scheme - ) -VALUES - ($1, $2, $3, $4, $5, $6, $7, $8, $9) RETURNING id, created_at, updated_at, scope, scope_id, name, source_scheme, source_value, destination_scheme -` - -type InsertParameterValueParams struct { - ID uuid.UUID `db:"id" json:"id"` - Name string `db:"name" json:"name"` - CreatedAt time.Time `db:"created_at" json:"created_at"` - UpdatedAt time.Time `db:"updated_at" json:"updated_at"` - Scope ParameterScope `db:"scope" json:"scope"` - ScopeID string `db:"scope_id" json:"scope_id"` - SourceScheme ParameterSourceScheme `db:"source_scheme" json:"source_scheme"` - SourceValue string `db:"source_value" json:"source_value"` - DestinationScheme ParameterDestinationScheme `db:"destination_scheme" json:"destination_scheme"` -} - -func (q *sqlQuerier) InsertParameterValue(ctx context.Context, arg InsertParameterValueParams) (ParameterValue, error) { - row := q.db.QueryRowContext(ctx, insertParameterValue, - arg.ID, - arg.Name, - arg.CreatedAt, - arg.UpdatedAt, - arg.Scope, - arg.ScopeID, - arg.SourceScheme, - arg.SourceValue, - arg.DestinationScheme, - ) - var i ParameterValue - err := row.Scan( - &i.ID, - &i.CreatedAt, - &i.UpdatedAt, - &i.Scope, - &i.ScopeID, - &i.Name, - &i.SourceScheme, - &i.SourceValue, - &i.DestinationScheme, - ) - return i, err -} diff --git a/coderd/database/projects.sql.go b/coderd/database/projects.sql.go deleted file mode 100644 index 6ec60b95894ea..0000000000000 --- a/coderd/database/projects.sql.go +++ /dev/null @@ -1,249 +0,0 @@ -// Code generated by sqlc. DO NOT EDIT. -// source: projects.sql - -package database - -import ( - "context" - "time" - - "github.com/google/uuid" - "github.com/lib/pq" -) - -const getProjectByID = `-- name: GetProjectByID :one -SELECT - id, created_at, updated_at, organization_id, deleted, name, provisioner, active_version_id -FROM - projects -WHERE - id = $1 -LIMIT - 1 -` - -func (q *sqlQuerier) GetProjectByID(ctx context.Context, id uuid.UUID) (Project, error) { - row := q.db.QueryRowContext(ctx, getProjectByID, id) - var i Project - err := row.Scan( - &i.ID, - &i.CreatedAt, - &i.UpdatedAt, - &i.OrganizationID, - &i.Deleted, - &i.Name, - &i.Provisioner, - &i.ActiveVersionID, - ) - return i, err -} - -const getProjectByOrganizationAndName = `-- name: GetProjectByOrganizationAndName :one -SELECT - id, created_at, updated_at, organization_id, deleted, name, provisioner, active_version_id -FROM - projects -WHERE - organization_id = $1 - AND deleted = $2 - AND LOWER("name") = LOWER($3) -LIMIT - 1 -` - -type GetProjectByOrganizationAndNameParams struct { - OrganizationID string `db:"organization_id" json:"organization_id"` - Deleted bool `db:"deleted" json:"deleted"` - Name string `db:"name" json:"name"` -} - -func (q *sqlQuerier) GetProjectByOrganizationAndName(ctx context.Context, arg GetProjectByOrganizationAndNameParams) (Project, error) { - row := q.db.QueryRowContext(ctx, getProjectByOrganizationAndName, arg.OrganizationID, arg.Deleted, arg.Name) - var i Project - err := row.Scan( - &i.ID, - &i.CreatedAt, - &i.UpdatedAt, - &i.OrganizationID, - &i.Deleted, - &i.Name, - &i.Provisioner, - &i.ActiveVersionID, - ) - return i, err -} - -const getProjectsByIDs = `-- name: GetProjectsByIDs :many -SELECT - id, created_at, updated_at, organization_id, deleted, name, provisioner, active_version_id -FROM - projects -WHERE - id = ANY($1 :: uuid [ ]) -` - -func (q *sqlQuerier) GetProjectsByIDs(ctx context.Context, ids []uuid.UUID) ([]Project, error) { - rows, err := q.db.QueryContext(ctx, getProjectsByIDs, pq.Array(ids)) - if err != nil { - return nil, err - } - defer rows.Close() - var items []Project - for rows.Next() { - var i Project - if err := rows.Scan( - &i.ID, - &i.CreatedAt, - &i.UpdatedAt, - &i.OrganizationID, - &i.Deleted, - &i.Name, - &i.Provisioner, - &i.ActiveVersionID, - ); 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 getProjectsByOrganization = `-- name: GetProjectsByOrganization :many -SELECT - id, created_at, updated_at, organization_id, deleted, name, provisioner, active_version_id -FROM - projects -WHERE - organization_id = $1 - AND deleted = $2 -` - -type GetProjectsByOrganizationParams struct { - OrganizationID string `db:"organization_id" json:"organization_id"` - Deleted bool `db:"deleted" json:"deleted"` -} - -func (q *sqlQuerier) GetProjectsByOrganization(ctx context.Context, arg GetProjectsByOrganizationParams) ([]Project, error) { - rows, err := q.db.QueryContext(ctx, getProjectsByOrganization, arg.OrganizationID, arg.Deleted) - if err != nil { - return nil, err - } - defer rows.Close() - var items []Project - for rows.Next() { - var i Project - if err := rows.Scan( - &i.ID, - &i.CreatedAt, - &i.UpdatedAt, - &i.OrganizationID, - &i.Deleted, - &i.Name, - &i.Provisioner, - &i.ActiveVersionID, - ); 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 insertProject = `-- name: InsertProject :one -INSERT INTO - projects ( - id, - created_at, - updated_at, - organization_id, - "name", - provisioner, - active_version_id - ) -VALUES - ($1, $2, $3, $4, $5, $6, $7) RETURNING id, created_at, updated_at, organization_id, deleted, name, provisioner, active_version_id -` - -type InsertProjectParams struct { - ID uuid.UUID `db:"id" json:"id"` - CreatedAt time.Time `db:"created_at" json:"created_at"` - UpdatedAt time.Time `db:"updated_at" json:"updated_at"` - OrganizationID string `db:"organization_id" json:"organization_id"` - Name string `db:"name" json:"name"` - Provisioner ProvisionerType `db:"provisioner" json:"provisioner"` - ActiveVersionID uuid.UUID `db:"active_version_id" json:"active_version_id"` -} - -func (q *sqlQuerier) InsertProject(ctx context.Context, arg InsertProjectParams) (Project, error) { - row := q.db.QueryRowContext(ctx, insertProject, - arg.ID, - arg.CreatedAt, - arg.UpdatedAt, - arg.OrganizationID, - arg.Name, - arg.Provisioner, - arg.ActiveVersionID, - ) - var i Project - err := row.Scan( - &i.ID, - &i.CreatedAt, - &i.UpdatedAt, - &i.OrganizationID, - &i.Deleted, - &i.Name, - &i.Provisioner, - &i.ActiveVersionID, - ) - return i, err -} - -const updateProjectActiveVersionByID = `-- name: UpdateProjectActiveVersionByID :exec -UPDATE - projects -SET - active_version_id = $2 -WHERE - id = $1 -` - -type UpdateProjectActiveVersionByIDParams struct { - ID uuid.UUID `db:"id" json:"id"` - ActiveVersionID uuid.UUID `db:"active_version_id" json:"active_version_id"` -} - -func (q *sqlQuerier) UpdateProjectActiveVersionByID(ctx context.Context, arg UpdateProjectActiveVersionByIDParams) error { - _, err := q.db.ExecContext(ctx, updateProjectActiveVersionByID, arg.ID, arg.ActiveVersionID) - return err -} - -const updateProjectDeletedByID = `-- name: UpdateProjectDeletedByID :exec -UPDATE - projects -SET - deleted = $2 -WHERE - id = $1 -` - -type UpdateProjectDeletedByIDParams struct { - ID uuid.UUID `db:"id" json:"id"` - Deleted bool `db:"deleted" json:"deleted"` -} - -func (q *sqlQuerier) UpdateProjectDeletedByID(ctx context.Context, arg UpdateProjectDeletedByIDParams) error { - _, err := q.db.ExecContext(ctx, updateProjectDeletedByID, arg.ID, arg.Deleted) - return err -} diff --git a/coderd/database/projectversions.sql.go b/coderd/database/projectversions.sql.go deleted file mode 100644 index 528236bcdfc6d..0000000000000 --- a/coderd/database/projectversions.sql.go +++ /dev/null @@ -1,206 +0,0 @@ -// Code generated by sqlc. DO NOT EDIT. -// source: projectversions.sql - -package database - -import ( - "context" - "time" - - "github.com/google/uuid" -) - -const getProjectVersionByID = `-- name: GetProjectVersionByID :one -SELECT - id, project_id, organization_id, created_at, updated_at, name, description, job_id -FROM - project_versions -WHERE - id = $1 -` - -func (q *sqlQuerier) GetProjectVersionByID(ctx context.Context, id uuid.UUID) (ProjectVersion, error) { - row := q.db.QueryRowContext(ctx, getProjectVersionByID, id) - var i ProjectVersion - err := row.Scan( - &i.ID, - &i.ProjectID, - &i.OrganizationID, - &i.CreatedAt, - &i.UpdatedAt, - &i.Name, - &i.Description, - &i.JobID, - ) - return i, err -} - -const getProjectVersionByJobID = `-- name: GetProjectVersionByJobID :one -SELECT - id, project_id, organization_id, created_at, updated_at, name, description, job_id -FROM - project_versions -WHERE - job_id = $1 -` - -func (q *sqlQuerier) GetProjectVersionByJobID(ctx context.Context, jobID uuid.UUID) (ProjectVersion, error) { - row := q.db.QueryRowContext(ctx, getProjectVersionByJobID, jobID) - var i ProjectVersion - err := row.Scan( - &i.ID, - &i.ProjectID, - &i.OrganizationID, - &i.CreatedAt, - &i.UpdatedAt, - &i.Name, - &i.Description, - &i.JobID, - ) - return i, err -} - -const getProjectVersionByProjectIDAndName = `-- name: GetProjectVersionByProjectIDAndName :one -SELECT - id, project_id, organization_id, created_at, updated_at, name, description, job_id -FROM - project_versions -WHERE - project_id = $1 - AND "name" = $2 -` - -type GetProjectVersionByProjectIDAndNameParams struct { - ProjectID uuid.NullUUID `db:"project_id" json:"project_id"` - Name string `db:"name" json:"name"` -} - -func (q *sqlQuerier) GetProjectVersionByProjectIDAndName(ctx context.Context, arg GetProjectVersionByProjectIDAndNameParams) (ProjectVersion, error) { - row := q.db.QueryRowContext(ctx, getProjectVersionByProjectIDAndName, arg.ProjectID, arg.Name) - var i ProjectVersion - err := row.Scan( - &i.ID, - &i.ProjectID, - &i.OrganizationID, - &i.CreatedAt, - &i.UpdatedAt, - &i.Name, - &i.Description, - &i.JobID, - ) - return i, err -} - -const getProjectVersionsByProjectID = `-- name: GetProjectVersionsByProjectID :many -SELECT - id, project_id, organization_id, created_at, updated_at, name, description, job_id -FROM - project_versions -WHERE - project_id = $1 :: uuid -` - -func (q *sqlQuerier) GetProjectVersionsByProjectID(ctx context.Context, dollar_1 uuid.UUID) ([]ProjectVersion, error) { - rows, err := q.db.QueryContext(ctx, getProjectVersionsByProjectID, dollar_1) - if err != nil { - return nil, err - } - defer rows.Close() - var items []ProjectVersion - for rows.Next() { - var i ProjectVersion - if err := rows.Scan( - &i.ID, - &i.ProjectID, - &i.OrganizationID, - &i.CreatedAt, - &i.UpdatedAt, - &i.Name, - &i.Description, - &i.JobID, - ); 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 insertProjectVersion = `-- name: InsertProjectVersion :one -INSERT INTO - project_versions ( - id, - project_id, - organization_id, - created_at, - updated_at, - "name", - description, - job_id - ) -VALUES - ($1, $2, $3, $4, $5, $6, $7, $8) RETURNING id, project_id, organization_id, created_at, updated_at, name, description, job_id -` - -type InsertProjectVersionParams struct { - ID uuid.UUID `db:"id" json:"id"` - ProjectID uuid.NullUUID `db:"project_id" json:"project_id"` - OrganizationID string `db:"organization_id" json:"organization_id"` - CreatedAt time.Time `db:"created_at" json:"created_at"` - UpdatedAt time.Time `db:"updated_at" json:"updated_at"` - Name string `db:"name" json:"name"` - Description string `db:"description" json:"description"` - JobID uuid.UUID `db:"job_id" json:"job_id"` -} - -func (q *sqlQuerier) InsertProjectVersion(ctx context.Context, arg InsertProjectVersionParams) (ProjectVersion, error) { - row := q.db.QueryRowContext(ctx, insertProjectVersion, - arg.ID, - arg.ProjectID, - arg.OrganizationID, - arg.CreatedAt, - arg.UpdatedAt, - arg.Name, - arg.Description, - arg.JobID, - ) - var i ProjectVersion - err := row.Scan( - &i.ID, - &i.ProjectID, - &i.OrganizationID, - &i.CreatedAt, - &i.UpdatedAt, - &i.Name, - &i.Description, - &i.JobID, - ) - return i, err -} - -const updateProjectVersionByID = `-- name: UpdateProjectVersionByID :exec -UPDATE - project_versions -SET - project_id = $2, - updated_at = $3 -WHERE - id = $1 -` - -type UpdateProjectVersionByIDParams struct { - ID uuid.UUID `db:"id" json:"id"` - ProjectID uuid.NullUUID `db:"project_id" json:"project_id"` - UpdatedAt time.Time `db:"updated_at" json:"updated_at"` -} - -func (q *sqlQuerier) UpdateProjectVersionByID(ctx context.Context, arg UpdateProjectVersionByIDParams) error { - _, err := q.db.ExecContext(ctx, updateProjectVersionByID, arg.ID, arg.ProjectID, arg.UpdatedAt) - return err -} diff --git a/coderd/database/provisionerdaemons.sql.go b/coderd/database/provisionerdaemons.sql.go deleted file mode 100644 index 40da1db177741..0000000000000 --- a/coderd/database/provisionerdaemons.sql.go +++ /dev/null @@ -1,135 +0,0 @@ -// Code generated by sqlc. DO NOT EDIT. -// source: provisionerdaemons.sql - -package database - -import ( - "context" - "database/sql" - "time" - - "github.com/google/uuid" - "github.com/lib/pq" -) - -const getProvisionerDaemonByID = `-- name: GetProvisionerDaemonByID :one -SELECT - id, created_at, updated_at, organization_id, name, provisioners -FROM - provisioner_daemons -WHERE - id = $1 -` - -func (q *sqlQuerier) GetProvisionerDaemonByID(ctx context.Context, id uuid.UUID) (ProvisionerDaemon, error) { - row := q.db.QueryRowContext(ctx, getProvisionerDaemonByID, id) - var i ProvisionerDaemon - err := row.Scan( - &i.ID, - &i.CreatedAt, - &i.UpdatedAt, - &i.OrganizationID, - &i.Name, - pq.Array(&i.Provisioners), - ) - return i, err -} - -const getProvisionerDaemons = `-- name: GetProvisionerDaemons :many -SELECT - id, created_at, updated_at, organization_id, name, provisioners -FROM - provisioner_daemons -` - -func (q *sqlQuerier) GetProvisionerDaemons(ctx context.Context) ([]ProvisionerDaemon, error) { - rows, err := q.db.QueryContext(ctx, getProvisionerDaemons) - if err != nil { - return nil, err - } - defer rows.Close() - var items []ProvisionerDaemon - for rows.Next() { - var i ProvisionerDaemon - if err := rows.Scan( - &i.ID, - &i.CreatedAt, - &i.UpdatedAt, - &i.OrganizationID, - &i.Name, - pq.Array(&i.Provisioners), - ); 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 insertProvisionerDaemon = `-- name: InsertProvisionerDaemon :one -INSERT INTO - provisioner_daemons ( - id, - created_at, - organization_id, - "name", - provisioners - ) -VALUES - ($1, $2, $3, $4, $5) RETURNING id, created_at, updated_at, organization_id, name, provisioners -` - -type InsertProvisionerDaemonParams struct { - ID uuid.UUID `db:"id" json:"id"` - CreatedAt time.Time `db:"created_at" json:"created_at"` - OrganizationID sql.NullString `db:"organization_id" json:"organization_id"` - Name string `db:"name" json:"name"` - Provisioners []ProvisionerType `db:"provisioners" json:"provisioners"` -} - -func (q *sqlQuerier) InsertProvisionerDaemon(ctx context.Context, arg InsertProvisionerDaemonParams) (ProvisionerDaemon, error) { - row := q.db.QueryRowContext(ctx, insertProvisionerDaemon, - arg.ID, - arg.CreatedAt, - arg.OrganizationID, - arg.Name, - pq.Array(arg.Provisioners), - ) - var i ProvisionerDaemon - err := row.Scan( - &i.ID, - &i.CreatedAt, - &i.UpdatedAt, - &i.OrganizationID, - &i.Name, - pq.Array(&i.Provisioners), - ) - return i, err -} - -const updateProvisionerDaemonByID = `-- name: UpdateProvisionerDaemonByID :exec -UPDATE - provisioner_daemons -SET - updated_at = $2, - provisioners = $3 -WHERE - id = $1 -` - -type UpdateProvisionerDaemonByIDParams struct { - ID uuid.UUID `db:"id" json:"id"` - UpdatedAt sql.NullTime `db:"updated_at" json:"updated_at"` - Provisioners []ProvisionerType `db:"provisioners" json:"provisioners"` -} - -func (q *sqlQuerier) UpdateProvisionerDaemonByID(ctx context.Context, arg UpdateProvisionerDaemonByIDParams) error { - _, err := q.db.ExecContext(ctx, updateProvisionerDaemonByID, arg.ID, arg.UpdatedAt, pq.Array(arg.Provisioners)) - return err -} diff --git a/coderd/database/provisionerjoblogs.sql.go b/coderd/database/provisionerjoblogs.sql.go deleted file mode 100644 index 9762c160f9cef..0000000000000 --- a/coderd/database/provisionerjoblogs.sql.go +++ /dev/null @@ -1,126 +0,0 @@ -// Code generated by sqlc. DO NOT EDIT. -// source: provisionerjoblogs.sql - -package database - -import ( - "context" - "time" - - "github.com/google/uuid" - "github.com/lib/pq" -) - -const getProvisionerLogsByIDBetween = `-- name: GetProvisionerLogsByIDBetween :many -SELECT - id, job_id, created_at, source, level, stage, output -FROM - provisioner_job_logs -WHERE - job_id = $1 - AND ( - created_at >= $2 - OR created_at <= $3 - ) -ORDER BY - created_at DESC -` - -type GetProvisionerLogsByIDBetweenParams struct { - JobID uuid.UUID `db:"job_id" json:"job_id"` - CreatedAfter time.Time `db:"created_after" json:"created_after"` - CreatedBefore time.Time `db:"created_before" json:"created_before"` -} - -func (q *sqlQuerier) GetProvisionerLogsByIDBetween(ctx context.Context, arg GetProvisionerLogsByIDBetweenParams) ([]ProvisionerJobLog, error) { - rows, err := q.db.QueryContext(ctx, getProvisionerLogsByIDBetween, arg.JobID, arg.CreatedAfter, arg.CreatedBefore) - if err != nil { - return nil, err - } - defer rows.Close() - var items []ProvisionerJobLog - for rows.Next() { - var i ProvisionerJobLog - if err := rows.Scan( - &i.ID, - &i.JobID, - &i.CreatedAt, - &i.Source, - &i.Level, - &i.Stage, - &i.Output, - ); 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 insertProvisionerJobLogs = `-- name: InsertProvisionerJobLogs :many -INSERT INTO - provisioner_job_logs -SELECT - unnest($1 :: uuid [ ]) AS id, - $2 :: uuid AS job_id, - unnest($3 :: timestamptz [ ]) AS created_at, - unnest($4 :: log_source [ ]) AS source, - unnest($5 :: log_level [ ]) AS LEVEL, - unnest($6 :: VARCHAR(128) [ ]) AS stage, - unnest($7 :: VARCHAR(1024) [ ]) AS output RETURNING id, job_id, created_at, source, level, stage, output -` - -type InsertProvisionerJobLogsParams struct { - ID []uuid.UUID `db:"id" json:"id"` - JobID uuid.UUID `db:"job_id" json:"job_id"` - CreatedAt []time.Time `db:"created_at" json:"created_at"` - Source []LogSource `db:"source" json:"source"` - Level []LogLevel `db:"level" json:"level"` - Stage []string `db:"stage" json:"stage"` - Output []string `db:"output" json:"output"` -} - -func (q *sqlQuerier) InsertProvisionerJobLogs(ctx context.Context, arg InsertProvisionerJobLogsParams) ([]ProvisionerJobLog, error) { - rows, err := q.db.QueryContext(ctx, insertProvisionerJobLogs, - pq.Array(arg.ID), - arg.JobID, - pq.Array(arg.CreatedAt), - pq.Array(arg.Source), - pq.Array(arg.Level), - pq.Array(arg.Stage), - pq.Array(arg.Output), - ) - if err != nil { - return nil, err - } - defer rows.Close() - var items []ProvisionerJobLog - for rows.Next() { - var i ProvisionerJobLog - if err := rows.Scan( - &i.ID, - &i.JobID, - &i.CreatedAt, - &i.Source, - &i.Level, - &i.Stage, - &i.Output, - ); 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 -} diff --git a/coderd/database/provisionerjobs.sql.go b/coderd/database/provisionerjobs.sql.go deleted file mode 100644 index ac1340a7de899..0000000000000 --- a/coderd/database/provisionerjobs.sql.go +++ /dev/null @@ -1,287 +0,0 @@ -// Code generated by sqlc. DO NOT EDIT. -// source: provisionerjobs.sql - -package database - -import ( - "context" - "database/sql" - "encoding/json" - "time" - - "github.com/google/uuid" - "github.com/lib/pq" -) - -const acquireProvisionerJob = `-- name: AcquireProvisionerJob :one -UPDATE - provisioner_jobs -SET - started_at = $1, - updated_at = $1, - worker_id = $2 -WHERE - id = ( - SELECT - id - FROM - provisioner_jobs AS nested - WHERE - nested.started_at IS NULL - AND nested.canceled_at IS NULL - AND nested.completed_at IS NULL - AND nested.provisioner = ANY($3 :: provisioner_type [ ]) - ORDER BY - nested.created_at FOR - UPDATE - SKIP LOCKED - LIMIT - 1 - ) RETURNING id, created_at, updated_at, started_at, canceled_at, completed_at, error, organization_id, initiator_id, provisioner, storage_method, storage_source, type, input, worker_id -` - -type AcquireProvisionerJobParams struct { - StartedAt sql.NullTime `db:"started_at" json:"started_at"` - WorkerID uuid.NullUUID `db:"worker_id" json:"worker_id"` - Types []ProvisionerType `db:"types" json:"types"` -} - -// Acquires the lock for a single job that isn't started, completed, -// canceled, and that matches an array of provisioner types. -// -// SKIP LOCKED is used to jump over locked rows. This prevents -// multiple provisioners from acquiring the same jobs. See: -// https://www.postgresql.org/docs/9.5/sql-select.html#SQL-FOR-UPDATE-SHARE -func (q *sqlQuerier) AcquireProvisionerJob(ctx context.Context, arg AcquireProvisionerJobParams) (ProvisionerJob, error) { - row := q.db.QueryRowContext(ctx, acquireProvisionerJob, arg.StartedAt, arg.WorkerID, pq.Array(arg.Types)) - var i ProvisionerJob - err := row.Scan( - &i.ID, - &i.CreatedAt, - &i.UpdatedAt, - &i.StartedAt, - &i.CanceledAt, - &i.CompletedAt, - &i.Error, - &i.OrganizationID, - &i.InitiatorID, - &i.Provisioner, - &i.StorageMethod, - &i.StorageSource, - &i.Type, - &i.Input, - &i.WorkerID, - ) - return i, err -} - -const getProvisionerJobByID = `-- name: GetProvisionerJobByID :one -SELECT - id, created_at, updated_at, started_at, canceled_at, completed_at, error, organization_id, initiator_id, provisioner, storage_method, storage_source, type, input, worker_id -FROM - provisioner_jobs -WHERE - id = $1 -` - -func (q *sqlQuerier) GetProvisionerJobByID(ctx context.Context, id uuid.UUID) (ProvisionerJob, error) { - row := q.db.QueryRowContext(ctx, getProvisionerJobByID, id) - var i ProvisionerJob - err := row.Scan( - &i.ID, - &i.CreatedAt, - &i.UpdatedAt, - &i.StartedAt, - &i.CanceledAt, - &i.CompletedAt, - &i.Error, - &i.OrganizationID, - &i.InitiatorID, - &i.Provisioner, - &i.StorageMethod, - &i.StorageSource, - &i.Type, - &i.Input, - &i.WorkerID, - ) - return i, err -} - -const getProvisionerJobsByIDs = `-- name: GetProvisionerJobsByIDs :many -SELECT - id, created_at, updated_at, started_at, canceled_at, completed_at, error, organization_id, initiator_id, provisioner, storage_method, storage_source, type, input, worker_id -FROM - provisioner_jobs -WHERE - id = ANY($1 :: uuid [ ]) -` - -func (q *sqlQuerier) GetProvisionerJobsByIDs(ctx context.Context, ids []uuid.UUID) ([]ProvisionerJob, error) { - rows, err := q.db.QueryContext(ctx, getProvisionerJobsByIDs, pq.Array(ids)) - if err != nil { - return nil, err - } - defer rows.Close() - var items []ProvisionerJob - for rows.Next() { - var i ProvisionerJob - if err := rows.Scan( - &i.ID, - &i.CreatedAt, - &i.UpdatedAt, - &i.StartedAt, - &i.CanceledAt, - &i.CompletedAt, - &i.Error, - &i.OrganizationID, - &i.InitiatorID, - &i.Provisioner, - &i.StorageMethod, - &i.StorageSource, - &i.Type, - &i.Input, - &i.WorkerID, - ); 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 insertProvisionerJob = `-- name: InsertProvisionerJob :one -INSERT INTO - provisioner_jobs ( - id, - created_at, - updated_at, - organization_id, - initiator_id, - provisioner, - storage_method, - storage_source, - "type", - "input" - ) -VALUES - ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10) RETURNING id, created_at, updated_at, started_at, canceled_at, completed_at, error, organization_id, initiator_id, provisioner, storage_method, storage_source, type, input, worker_id -` - -type InsertProvisionerJobParams struct { - ID uuid.UUID `db:"id" json:"id"` - CreatedAt time.Time `db:"created_at" json:"created_at"` - UpdatedAt time.Time `db:"updated_at" json:"updated_at"` - OrganizationID string `db:"organization_id" json:"organization_id"` - InitiatorID string `db:"initiator_id" json:"initiator_id"` - Provisioner ProvisionerType `db:"provisioner" json:"provisioner"` - StorageMethod ProvisionerStorageMethod `db:"storage_method" json:"storage_method"` - StorageSource string `db:"storage_source" json:"storage_source"` - Type ProvisionerJobType `db:"type" json:"type"` - Input json.RawMessage `db:"input" json:"input"` -} - -func (q *sqlQuerier) InsertProvisionerJob(ctx context.Context, arg InsertProvisionerJobParams) (ProvisionerJob, error) { - row := q.db.QueryRowContext(ctx, insertProvisionerJob, - arg.ID, - arg.CreatedAt, - arg.UpdatedAt, - arg.OrganizationID, - arg.InitiatorID, - arg.Provisioner, - arg.StorageMethod, - arg.StorageSource, - arg.Type, - arg.Input, - ) - var i ProvisionerJob - err := row.Scan( - &i.ID, - &i.CreatedAt, - &i.UpdatedAt, - &i.StartedAt, - &i.CanceledAt, - &i.CompletedAt, - &i.Error, - &i.OrganizationID, - &i.InitiatorID, - &i.Provisioner, - &i.StorageMethod, - &i.StorageSource, - &i.Type, - &i.Input, - &i.WorkerID, - ) - return i, err -} - -const updateProvisionerJobByID = `-- name: UpdateProvisionerJobByID :exec -UPDATE - provisioner_jobs -SET - updated_at = $2 -WHERE - id = $1 -` - -type UpdateProvisionerJobByIDParams struct { - ID uuid.UUID `db:"id" json:"id"` - UpdatedAt time.Time `db:"updated_at" json:"updated_at"` -} - -func (q *sqlQuerier) UpdateProvisionerJobByID(ctx context.Context, arg UpdateProvisionerJobByIDParams) error { - _, err := q.db.ExecContext(ctx, updateProvisionerJobByID, arg.ID, arg.UpdatedAt) - return err -} - -const updateProvisionerJobWithCancelByID = `-- name: UpdateProvisionerJobWithCancelByID :exec -UPDATE - provisioner_jobs -SET - canceled_at = $2 -WHERE - id = $1 -` - -type UpdateProvisionerJobWithCancelByIDParams struct { - ID uuid.UUID `db:"id" json:"id"` - CanceledAt sql.NullTime `db:"canceled_at" json:"canceled_at"` -} - -func (q *sqlQuerier) UpdateProvisionerJobWithCancelByID(ctx context.Context, arg UpdateProvisionerJobWithCancelByIDParams) error { - _, err := q.db.ExecContext(ctx, updateProvisionerJobWithCancelByID, arg.ID, arg.CanceledAt) - return err -} - -const updateProvisionerJobWithCompleteByID = `-- name: UpdateProvisionerJobWithCompleteByID :exec -UPDATE - provisioner_jobs -SET - updated_at = $2, - completed_at = $3, - error = $4 -WHERE - id = $1 -` - -type UpdateProvisionerJobWithCompleteByIDParams struct { - ID uuid.UUID `db:"id" json:"id"` - UpdatedAt time.Time `db:"updated_at" json:"updated_at"` - CompletedAt sql.NullTime `db:"completed_at" json:"completed_at"` - Error sql.NullString `db:"error" json:"error"` -} - -func (q *sqlQuerier) UpdateProvisionerJobWithCompleteByID(ctx context.Context, arg UpdateProvisionerJobWithCompleteByIDParams) error { - _, err := q.db.ExecContext(ctx, updateProvisionerJobWithCompleteByID, - arg.ID, - arg.UpdatedAt, - arg.CompletedAt, - arg.Error, - ) - return err -} diff --git a/coderd/database/queries.sql.go b/coderd/database/queries.sql.go new file mode 100644 index 0000000000000..5bd2d11aae83c --- /dev/null +++ b/coderd/database/queries.sql.go @@ -0,0 +1,2725 @@ +// Code generated by sqlc. DO NOT EDIT. + +package database + +import ( + "context" + "database/sql" + "encoding/json" + "time" + + "github.com/google/uuid" + "github.com/lib/pq" + "github.com/tabbed/pqtype" +) + +const getAPIKeyByID = `-- name: GetAPIKeyByID :one +SELECT + id, hashed_secret, user_id, application, name, last_used, expires_at, created_at, updated_at, login_type, oidc_access_token, oidc_refresh_token, oidc_id_token, oidc_expiry, devurl_token +FROM + api_keys +WHERE + id = $1 +LIMIT + 1 +` + +func (q *sqlQuerier) GetAPIKeyByID(ctx context.Context, id string) (APIKey, error) { + row := q.db.QueryRowContext(ctx, getAPIKeyByID, id) + var i APIKey + err := row.Scan( + &i.ID, + &i.HashedSecret, + &i.UserID, + &i.Application, + &i.Name, + &i.LastUsed, + &i.ExpiresAt, + &i.CreatedAt, + &i.UpdatedAt, + &i.LoginType, + &i.OIDCAccessToken, + &i.OIDCRefreshToken, + &i.OIDCIDToken, + &i.OIDCExpiry, + &i.DevurlToken, + ) + return i, err +} + +const insertAPIKey = `-- name: InsertAPIKey :one +INSERT INTO + api_keys ( + id, + hashed_secret, + user_id, + application, + "name", + last_used, + expires_at, + created_at, + updated_at, + login_type, + oidc_access_token, + oidc_refresh_token, + oidc_id_token, + oidc_expiry, + devurl_token + ) +VALUES + ( + $1, + $2, + $3, + $4, + $5, + $6, + $7, + $8, + $9, + $10, + $11, + $12, + $13, + $14, + $15 + ) RETURNING id, hashed_secret, user_id, application, name, last_used, expires_at, created_at, updated_at, login_type, oidc_access_token, oidc_refresh_token, oidc_id_token, oidc_expiry, devurl_token +` + +type InsertAPIKeyParams struct { + ID string `db:"id" json:"id"` + HashedSecret []byte `db:"hashed_secret" json:"hashed_secret"` + UserID string `db:"user_id" json:"user_id"` + Application bool `db:"application" json:"application"` + Name string `db:"name" json:"name"` + LastUsed time.Time `db:"last_used" json:"last_used"` + ExpiresAt time.Time `db:"expires_at" json:"expires_at"` + CreatedAt time.Time `db:"created_at" json:"created_at"` + UpdatedAt time.Time `db:"updated_at" json:"updated_at"` + LoginType LoginType `db:"login_type" json:"login_type"` + OIDCAccessToken string `db:"oidc_access_token" json:"oidc_access_token"` + OIDCRefreshToken string `db:"oidc_refresh_token" json:"oidc_refresh_token"` + OIDCIDToken string `db:"oidc_id_token" json:"oidc_id_token"` + OIDCExpiry time.Time `db:"oidc_expiry" json:"oidc_expiry"` + DevurlToken bool `db:"devurl_token" json:"devurl_token"` +} + +func (q *sqlQuerier) InsertAPIKey(ctx context.Context, arg InsertAPIKeyParams) (APIKey, error) { + row := q.db.QueryRowContext(ctx, insertAPIKey, + arg.ID, + arg.HashedSecret, + arg.UserID, + arg.Application, + arg.Name, + arg.LastUsed, + arg.ExpiresAt, + arg.CreatedAt, + arg.UpdatedAt, + arg.LoginType, + arg.OIDCAccessToken, + arg.OIDCRefreshToken, + arg.OIDCIDToken, + arg.OIDCExpiry, + arg.DevurlToken, + ) + var i APIKey + err := row.Scan( + &i.ID, + &i.HashedSecret, + &i.UserID, + &i.Application, + &i.Name, + &i.LastUsed, + &i.ExpiresAt, + &i.CreatedAt, + &i.UpdatedAt, + &i.LoginType, + &i.OIDCAccessToken, + &i.OIDCRefreshToken, + &i.OIDCIDToken, + &i.OIDCExpiry, + &i.DevurlToken, + ) + return i, err +} + +const updateAPIKeyByID = `-- name: UpdateAPIKeyByID :exec +UPDATE + api_keys +SET + last_used = $2, + expires_at = $3, + oidc_access_token = $4, + oidc_refresh_token = $5, + oidc_expiry = $6 +WHERE + id = $1 +` + +type UpdateAPIKeyByIDParams struct { + ID string `db:"id" json:"id"` + LastUsed time.Time `db:"last_used" json:"last_used"` + ExpiresAt time.Time `db:"expires_at" json:"expires_at"` + OIDCAccessToken string `db:"oidc_access_token" json:"oidc_access_token"` + OIDCRefreshToken string `db:"oidc_refresh_token" json:"oidc_refresh_token"` + OIDCExpiry time.Time `db:"oidc_expiry" json:"oidc_expiry"` +} + +func (q *sqlQuerier) UpdateAPIKeyByID(ctx context.Context, arg UpdateAPIKeyByIDParams) error { + _, err := q.db.ExecContext(ctx, updateAPIKeyByID, + arg.ID, + arg.LastUsed, + arg.ExpiresAt, + arg.OIDCAccessToken, + arg.OIDCRefreshToken, + arg.OIDCExpiry, + ) + return err +} + +const getFileByHash = `-- name: GetFileByHash :one +SELECT + hash, created_at, created_by, mimetype, data +FROM + files +WHERE + hash = $1 +LIMIT + 1 +` + +func (q *sqlQuerier) GetFileByHash(ctx context.Context, hash string) (File, error) { + row := q.db.QueryRowContext(ctx, getFileByHash, hash) + var i File + err := row.Scan( + &i.Hash, + &i.CreatedAt, + &i.CreatedBy, + &i.Mimetype, + &i.Data, + ) + return i, err +} + +const insertFile = `-- name: InsertFile :one +INSERT INTO + files (hash, created_at, created_by, mimetype, "data") +VALUES + ($1, $2, $3, $4, $5) RETURNING hash, created_at, created_by, mimetype, data +` + +type InsertFileParams struct { + Hash string `db:"hash" json:"hash"` + CreatedAt time.Time `db:"created_at" json:"created_at"` + CreatedBy string `db:"created_by" json:"created_by"` + Mimetype string `db:"mimetype" json:"mimetype"` + Data []byte `db:"data" json:"data"` +} + +func (q *sqlQuerier) InsertFile(ctx context.Context, arg InsertFileParams) (File, error) { + row := q.db.QueryRowContext(ctx, insertFile, + arg.Hash, + arg.CreatedAt, + arg.CreatedBy, + arg.Mimetype, + arg.Data, + ) + var i File + err := row.Scan( + &i.Hash, + &i.CreatedAt, + &i.CreatedBy, + &i.Mimetype, + &i.Data, + ) + return i, err +} + +const getOrganizationMemberByUserID = `-- name: GetOrganizationMemberByUserID :one +SELECT + organization_id, user_id, created_at, updated_at, roles +FROM + organization_members +WHERE + organization_id = $1 + AND user_id = $2 +LIMIT + 1 +` + +type GetOrganizationMemberByUserIDParams struct { + OrganizationID string `db:"organization_id" json:"organization_id"` + UserID string `db:"user_id" json:"user_id"` +} + +func (q *sqlQuerier) GetOrganizationMemberByUserID(ctx context.Context, arg GetOrganizationMemberByUserIDParams) (OrganizationMember, error) { + row := q.db.QueryRowContext(ctx, getOrganizationMemberByUserID, arg.OrganizationID, arg.UserID) + var i OrganizationMember + err := row.Scan( + &i.OrganizationID, + &i.UserID, + &i.CreatedAt, + &i.UpdatedAt, + pq.Array(&i.Roles), + ) + return i, err +} + +const insertOrganizationMember = `-- name: InsertOrganizationMember :one +INSERT INTO + organization_members ( + organization_id, + user_id, + created_at, + updated_at, + roles + ) +VALUES + ($1, $2, $3, $4, $5) RETURNING organization_id, user_id, created_at, updated_at, roles +` + +type InsertOrganizationMemberParams struct { + OrganizationID string `db:"organization_id" json:"organization_id"` + UserID string `db:"user_id" json:"user_id"` + CreatedAt time.Time `db:"created_at" json:"created_at"` + UpdatedAt time.Time `db:"updated_at" json:"updated_at"` + Roles []string `db:"roles" json:"roles"` +} + +func (q *sqlQuerier) InsertOrganizationMember(ctx context.Context, arg InsertOrganizationMemberParams) (OrganizationMember, error) { + row := q.db.QueryRowContext(ctx, insertOrganizationMember, + arg.OrganizationID, + arg.UserID, + arg.CreatedAt, + arg.UpdatedAt, + pq.Array(arg.Roles), + ) + var i OrganizationMember + err := row.Scan( + &i.OrganizationID, + &i.UserID, + &i.CreatedAt, + &i.UpdatedAt, + pq.Array(&i.Roles), + ) + return i, err +} + +const getOrganizationByID = `-- name: GetOrganizationByID :one +SELECT + id, name, description, created_at, updated_at, "default", auto_off_threshold, cpu_provisioning_rate, memory_provisioning_rate, workspace_auto_off +FROM + organizations +WHERE + id = $1 +` + +func (q *sqlQuerier) GetOrganizationByID(ctx context.Context, id string) (Organization, error) { + row := q.db.QueryRowContext(ctx, getOrganizationByID, id) + var i Organization + err := row.Scan( + &i.ID, + &i.Name, + &i.Description, + &i.CreatedAt, + &i.UpdatedAt, + &i.Default, + &i.AutoOffThreshold, + &i.CpuProvisioningRate, + &i.MemoryProvisioningRate, + &i.WorkspaceAutoOff, + ) + return i, err +} + +const getOrganizationByName = `-- name: GetOrganizationByName :one +SELECT + id, name, description, created_at, updated_at, "default", auto_off_threshold, cpu_provisioning_rate, memory_provisioning_rate, workspace_auto_off +FROM + organizations +WHERE + LOWER("name") = LOWER($1) +LIMIT + 1 +` + +func (q *sqlQuerier) GetOrganizationByName(ctx context.Context, name string) (Organization, error) { + row := q.db.QueryRowContext(ctx, getOrganizationByName, name) + var i Organization + err := row.Scan( + &i.ID, + &i.Name, + &i.Description, + &i.CreatedAt, + &i.UpdatedAt, + &i.Default, + &i.AutoOffThreshold, + &i.CpuProvisioningRate, + &i.MemoryProvisioningRate, + &i.WorkspaceAutoOff, + ) + return i, err +} + +const getOrganizationsByUserID = `-- name: GetOrganizationsByUserID :many +SELECT + id, name, description, created_at, updated_at, "default", auto_off_threshold, cpu_provisioning_rate, memory_provisioning_rate, workspace_auto_off +FROM + organizations +WHERE + id = ( + SELECT + organization_id + FROM + organization_members + WHERE + user_id = $1 + ) +` + +func (q *sqlQuerier) GetOrganizationsByUserID(ctx context.Context, userID string) ([]Organization, error) { + rows, err := q.db.QueryContext(ctx, getOrganizationsByUserID, userID) + if err != nil { + return nil, err + } + defer rows.Close() + var items []Organization + for rows.Next() { + var i Organization + if err := rows.Scan( + &i.ID, + &i.Name, + &i.Description, + &i.CreatedAt, + &i.UpdatedAt, + &i.Default, + &i.AutoOffThreshold, + &i.CpuProvisioningRate, + &i.MemoryProvisioningRate, + &i.WorkspaceAutoOff, + ); 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 insertOrganization = `-- name: InsertOrganization :one +INSERT INTO + organizations (id, "name", description, created_at, updated_at) +VALUES + ($1, $2, $3, $4, $5) RETURNING id, name, description, created_at, updated_at, "default", auto_off_threshold, cpu_provisioning_rate, memory_provisioning_rate, workspace_auto_off +` + +type InsertOrganizationParams struct { + ID string `db:"id" json:"id"` + Name string `db:"name" json:"name"` + Description string `db:"description" json:"description"` + CreatedAt time.Time `db:"created_at" json:"created_at"` + UpdatedAt time.Time `db:"updated_at" json:"updated_at"` +} + +func (q *sqlQuerier) InsertOrganization(ctx context.Context, arg InsertOrganizationParams) (Organization, error) { + row := q.db.QueryRowContext(ctx, insertOrganization, + arg.ID, + arg.Name, + arg.Description, + arg.CreatedAt, + arg.UpdatedAt, + ) + var i Organization + err := row.Scan( + &i.ID, + &i.Name, + &i.Description, + &i.CreatedAt, + &i.UpdatedAt, + &i.Default, + &i.AutoOffThreshold, + &i.CpuProvisioningRate, + &i.MemoryProvisioningRate, + &i.WorkspaceAutoOff, + ) + return i, err +} + +const getParameterSchemasByJobID = `-- name: GetParameterSchemasByJobID :many +SELECT + id, created_at, job_id, name, description, default_source_scheme, default_source_value, allow_override_source, default_destination_scheme, allow_override_destination, default_refresh, redisplay_value, validation_error, validation_condition, validation_type_system, validation_value_type +FROM + parameter_schemas +WHERE + job_id = $1 +` + +func (q *sqlQuerier) GetParameterSchemasByJobID(ctx context.Context, jobID uuid.UUID) ([]ParameterSchema, error) { + rows, err := q.db.QueryContext(ctx, getParameterSchemasByJobID, jobID) + if err != nil { + return nil, err + } + defer rows.Close() + var items []ParameterSchema + for rows.Next() { + var i ParameterSchema + if err := rows.Scan( + &i.ID, + &i.CreatedAt, + &i.JobID, + &i.Name, + &i.Description, + &i.DefaultSourceScheme, + &i.DefaultSourceValue, + &i.AllowOverrideSource, + &i.DefaultDestinationScheme, + &i.AllowOverrideDestination, + &i.DefaultRefresh, + &i.RedisplayValue, + &i.ValidationError, + &i.ValidationCondition, + &i.ValidationTypeSystem, + &i.ValidationValueType, + ); 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 insertParameterSchema = `-- name: InsertParameterSchema :one +INSERT INTO + parameter_schemas ( + id, + created_at, + job_id, + "name", + description, + default_source_scheme, + default_source_value, + allow_override_source, + default_destination_scheme, + allow_override_destination, + default_refresh, + redisplay_value, + validation_error, + validation_condition, + validation_type_system, + validation_value_type + ) +VALUES + ( + $1, + $2, + $3, + $4, + $5, + $6, + $7, + $8, + $9, + $10, + $11, + $12, + $13, + $14, + $15, + $16 + ) RETURNING id, created_at, job_id, name, description, default_source_scheme, default_source_value, allow_override_source, default_destination_scheme, allow_override_destination, default_refresh, redisplay_value, validation_error, validation_condition, validation_type_system, validation_value_type +` + +type InsertParameterSchemaParams struct { + ID uuid.UUID `db:"id" json:"id"` + CreatedAt time.Time `db:"created_at" json:"created_at"` + JobID uuid.UUID `db:"job_id" json:"job_id"` + Name string `db:"name" json:"name"` + Description string `db:"description" json:"description"` + DefaultSourceScheme ParameterSourceScheme `db:"default_source_scheme" json:"default_source_scheme"` + DefaultSourceValue string `db:"default_source_value" json:"default_source_value"` + AllowOverrideSource bool `db:"allow_override_source" json:"allow_override_source"` + DefaultDestinationScheme ParameterDestinationScheme `db:"default_destination_scheme" json:"default_destination_scheme"` + AllowOverrideDestination bool `db:"allow_override_destination" json:"allow_override_destination"` + DefaultRefresh string `db:"default_refresh" json:"default_refresh"` + RedisplayValue bool `db:"redisplay_value" json:"redisplay_value"` + ValidationError string `db:"validation_error" json:"validation_error"` + ValidationCondition string `db:"validation_condition" json:"validation_condition"` + ValidationTypeSystem ParameterTypeSystem `db:"validation_type_system" json:"validation_type_system"` + ValidationValueType string `db:"validation_value_type" json:"validation_value_type"` +} + +func (q *sqlQuerier) InsertParameterSchema(ctx context.Context, arg InsertParameterSchemaParams) (ParameterSchema, error) { + row := q.db.QueryRowContext(ctx, insertParameterSchema, + arg.ID, + arg.CreatedAt, + arg.JobID, + arg.Name, + arg.Description, + arg.DefaultSourceScheme, + arg.DefaultSourceValue, + arg.AllowOverrideSource, + arg.DefaultDestinationScheme, + arg.AllowOverrideDestination, + arg.DefaultRefresh, + arg.RedisplayValue, + arg.ValidationError, + arg.ValidationCondition, + arg.ValidationTypeSystem, + arg.ValidationValueType, + ) + var i ParameterSchema + err := row.Scan( + &i.ID, + &i.CreatedAt, + &i.JobID, + &i.Name, + &i.Description, + &i.DefaultSourceScheme, + &i.DefaultSourceValue, + &i.AllowOverrideSource, + &i.DefaultDestinationScheme, + &i.AllowOverrideDestination, + &i.DefaultRefresh, + &i.RedisplayValue, + &i.ValidationError, + &i.ValidationCondition, + &i.ValidationTypeSystem, + &i.ValidationValueType, + ) + return i, err +} + +const deleteParameterValueByID = `-- name: DeleteParameterValueByID :exec +DELETE FROM + parameter_values +WHERE + id = $1 +` + +func (q *sqlQuerier) DeleteParameterValueByID(ctx context.Context, id uuid.UUID) error { + _, err := q.db.ExecContext(ctx, deleteParameterValueByID, id) + return err +} + +const getParameterValueByScopeAndName = `-- name: GetParameterValueByScopeAndName :one +SELECT + id, created_at, updated_at, scope, scope_id, name, source_scheme, source_value, destination_scheme +FROM + parameter_values +WHERE + scope = $1 + AND scope_id = $2 + AND NAME = $3 +LIMIT + 1 +` + +type GetParameterValueByScopeAndNameParams struct { + Scope ParameterScope `db:"scope" json:"scope"` + ScopeID string `db:"scope_id" json:"scope_id"` + Name string `db:"name" json:"name"` +} + +func (q *sqlQuerier) GetParameterValueByScopeAndName(ctx context.Context, arg GetParameterValueByScopeAndNameParams) (ParameterValue, error) { + row := q.db.QueryRowContext(ctx, getParameterValueByScopeAndName, arg.Scope, arg.ScopeID, arg.Name) + var i ParameterValue + err := row.Scan( + &i.ID, + &i.CreatedAt, + &i.UpdatedAt, + &i.Scope, + &i.ScopeID, + &i.Name, + &i.SourceScheme, + &i.SourceValue, + &i.DestinationScheme, + ) + return i, err +} + +const getParameterValuesByScope = `-- name: GetParameterValuesByScope :many +SELECT + id, created_at, updated_at, scope, scope_id, name, source_scheme, source_value, destination_scheme +FROM + parameter_values +WHERE + scope = $1 + AND scope_id = $2 +` + +type GetParameterValuesByScopeParams struct { + Scope ParameterScope `db:"scope" json:"scope"` + ScopeID string `db:"scope_id" json:"scope_id"` +} + +func (q *sqlQuerier) GetParameterValuesByScope(ctx context.Context, arg GetParameterValuesByScopeParams) ([]ParameterValue, error) { + rows, err := q.db.QueryContext(ctx, getParameterValuesByScope, arg.Scope, arg.ScopeID) + if err != nil { + return nil, err + } + defer rows.Close() + var items []ParameterValue + for rows.Next() { + var i ParameterValue + if err := rows.Scan( + &i.ID, + &i.CreatedAt, + &i.UpdatedAt, + &i.Scope, + &i.ScopeID, + &i.Name, + &i.SourceScheme, + &i.SourceValue, + &i.DestinationScheme, + ); 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 insertParameterValue = `-- name: InsertParameterValue :one +INSERT INTO + parameter_values ( + id, + "name", + created_at, + updated_at, + scope, + scope_id, + source_scheme, + source_value, + destination_scheme + ) +VALUES + ($1, $2, $3, $4, $5, $6, $7, $8, $9) RETURNING id, created_at, updated_at, scope, scope_id, name, source_scheme, source_value, destination_scheme +` + +type InsertParameterValueParams struct { + ID uuid.UUID `db:"id" json:"id"` + Name string `db:"name" json:"name"` + CreatedAt time.Time `db:"created_at" json:"created_at"` + UpdatedAt time.Time `db:"updated_at" json:"updated_at"` + Scope ParameterScope `db:"scope" json:"scope"` + ScopeID string `db:"scope_id" json:"scope_id"` + SourceScheme ParameterSourceScheme `db:"source_scheme" json:"source_scheme"` + SourceValue string `db:"source_value" json:"source_value"` + DestinationScheme ParameterDestinationScheme `db:"destination_scheme" json:"destination_scheme"` +} + +func (q *sqlQuerier) InsertParameterValue(ctx context.Context, arg InsertParameterValueParams) (ParameterValue, error) { + row := q.db.QueryRowContext(ctx, insertParameterValue, + arg.ID, + arg.Name, + arg.CreatedAt, + arg.UpdatedAt, + arg.Scope, + arg.ScopeID, + arg.SourceScheme, + arg.SourceValue, + arg.DestinationScheme, + ) + var i ParameterValue + err := row.Scan( + &i.ID, + &i.CreatedAt, + &i.UpdatedAt, + &i.Scope, + &i.ScopeID, + &i.Name, + &i.SourceScheme, + &i.SourceValue, + &i.DestinationScheme, + ) + return i, err +} + +const getProjectByID = `-- name: GetProjectByID :one +SELECT + id, created_at, updated_at, organization_id, deleted, name, provisioner, active_version_id +FROM + projects +WHERE + id = $1 +LIMIT + 1 +` + +func (q *sqlQuerier) GetProjectByID(ctx context.Context, id uuid.UUID) (Project, error) { + row := q.db.QueryRowContext(ctx, getProjectByID, id) + var i Project + err := row.Scan( + &i.ID, + &i.CreatedAt, + &i.UpdatedAt, + &i.OrganizationID, + &i.Deleted, + &i.Name, + &i.Provisioner, + &i.ActiveVersionID, + ) + return i, err +} + +const getProjectByOrganizationAndName = `-- name: GetProjectByOrganizationAndName :one +SELECT + id, created_at, updated_at, organization_id, deleted, name, provisioner, active_version_id +FROM + projects +WHERE + organization_id = $1 + AND deleted = $2 + AND LOWER("name") = LOWER($3) +LIMIT + 1 +` + +type GetProjectByOrganizationAndNameParams struct { + OrganizationID string `db:"organization_id" json:"organization_id"` + Deleted bool `db:"deleted" json:"deleted"` + Name string `db:"name" json:"name"` +} + +func (q *sqlQuerier) GetProjectByOrganizationAndName(ctx context.Context, arg GetProjectByOrganizationAndNameParams) (Project, error) { + row := q.db.QueryRowContext(ctx, getProjectByOrganizationAndName, arg.OrganizationID, arg.Deleted, arg.Name) + var i Project + err := row.Scan( + &i.ID, + &i.CreatedAt, + &i.UpdatedAt, + &i.OrganizationID, + &i.Deleted, + &i.Name, + &i.Provisioner, + &i.ActiveVersionID, + ) + return i, err +} + +const getProjectsByIDs = `-- name: GetProjectsByIDs :many +SELECT + id, created_at, updated_at, organization_id, deleted, name, provisioner, active_version_id +FROM + projects +WHERE + id = ANY($1 :: uuid [ ]) +` + +func (q *sqlQuerier) GetProjectsByIDs(ctx context.Context, ids []uuid.UUID) ([]Project, error) { + rows, err := q.db.QueryContext(ctx, getProjectsByIDs, pq.Array(ids)) + if err != nil { + return nil, err + } + defer rows.Close() + var items []Project + for rows.Next() { + var i Project + if err := rows.Scan( + &i.ID, + &i.CreatedAt, + &i.UpdatedAt, + &i.OrganizationID, + &i.Deleted, + &i.Name, + &i.Provisioner, + &i.ActiveVersionID, + ); 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 getProjectsByOrganization = `-- name: GetProjectsByOrganization :many +SELECT + id, created_at, updated_at, organization_id, deleted, name, provisioner, active_version_id +FROM + projects +WHERE + organization_id = $1 + AND deleted = $2 +` + +type GetProjectsByOrganizationParams struct { + OrganizationID string `db:"organization_id" json:"organization_id"` + Deleted bool `db:"deleted" json:"deleted"` +} + +func (q *sqlQuerier) GetProjectsByOrganization(ctx context.Context, arg GetProjectsByOrganizationParams) ([]Project, error) { + rows, err := q.db.QueryContext(ctx, getProjectsByOrganization, arg.OrganizationID, arg.Deleted) + if err != nil { + return nil, err + } + defer rows.Close() + var items []Project + for rows.Next() { + var i Project + if err := rows.Scan( + &i.ID, + &i.CreatedAt, + &i.UpdatedAt, + &i.OrganizationID, + &i.Deleted, + &i.Name, + &i.Provisioner, + &i.ActiveVersionID, + ); 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 insertProject = `-- name: InsertProject :one +INSERT INTO + projects ( + id, + created_at, + updated_at, + organization_id, + "name", + provisioner, + active_version_id + ) +VALUES + ($1, $2, $3, $4, $5, $6, $7) RETURNING id, created_at, updated_at, organization_id, deleted, name, provisioner, active_version_id +` + +type InsertProjectParams struct { + ID uuid.UUID `db:"id" json:"id"` + CreatedAt time.Time `db:"created_at" json:"created_at"` + UpdatedAt time.Time `db:"updated_at" json:"updated_at"` + OrganizationID string `db:"organization_id" json:"organization_id"` + Name string `db:"name" json:"name"` + Provisioner ProvisionerType `db:"provisioner" json:"provisioner"` + ActiveVersionID uuid.UUID `db:"active_version_id" json:"active_version_id"` +} + +func (q *sqlQuerier) InsertProject(ctx context.Context, arg InsertProjectParams) (Project, error) { + row := q.db.QueryRowContext(ctx, insertProject, + arg.ID, + arg.CreatedAt, + arg.UpdatedAt, + arg.OrganizationID, + arg.Name, + arg.Provisioner, + arg.ActiveVersionID, + ) + var i Project + err := row.Scan( + &i.ID, + &i.CreatedAt, + &i.UpdatedAt, + &i.OrganizationID, + &i.Deleted, + &i.Name, + &i.Provisioner, + &i.ActiveVersionID, + ) + return i, err +} + +const updateProjectActiveVersionByID = `-- name: UpdateProjectActiveVersionByID :exec +UPDATE + projects +SET + active_version_id = $2 +WHERE + id = $1 +` + +type UpdateProjectActiveVersionByIDParams struct { + ID uuid.UUID `db:"id" json:"id"` + ActiveVersionID uuid.UUID `db:"active_version_id" json:"active_version_id"` +} + +func (q *sqlQuerier) UpdateProjectActiveVersionByID(ctx context.Context, arg UpdateProjectActiveVersionByIDParams) error { + _, err := q.db.ExecContext(ctx, updateProjectActiveVersionByID, arg.ID, arg.ActiveVersionID) + return err +} + +const updateProjectDeletedByID = `-- name: UpdateProjectDeletedByID :exec +UPDATE + projects +SET + deleted = $2 +WHERE + id = $1 +` + +type UpdateProjectDeletedByIDParams struct { + ID uuid.UUID `db:"id" json:"id"` + Deleted bool `db:"deleted" json:"deleted"` +} + +func (q *sqlQuerier) UpdateProjectDeletedByID(ctx context.Context, arg UpdateProjectDeletedByIDParams) error { + _, err := q.db.ExecContext(ctx, updateProjectDeletedByID, arg.ID, arg.Deleted) + return err +} + +const getProjectVersionByID = `-- name: GetProjectVersionByID :one +SELECT + id, project_id, organization_id, created_at, updated_at, name, description, job_id +FROM + project_versions +WHERE + id = $1 +` + +func (q *sqlQuerier) GetProjectVersionByID(ctx context.Context, id uuid.UUID) (ProjectVersion, error) { + row := q.db.QueryRowContext(ctx, getProjectVersionByID, id) + var i ProjectVersion + err := row.Scan( + &i.ID, + &i.ProjectID, + &i.OrganizationID, + &i.CreatedAt, + &i.UpdatedAt, + &i.Name, + &i.Description, + &i.JobID, + ) + return i, err +} + +const getProjectVersionByJobID = `-- name: GetProjectVersionByJobID :one +SELECT + id, project_id, organization_id, created_at, updated_at, name, description, job_id +FROM + project_versions +WHERE + job_id = $1 +` + +func (q *sqlQuerier) GetProjectVersionByJobID(ctx context.Context, jobID uuid.UUID) (ProjectVersion, error) { + row := q.db.QueryRowContext(ctx, getProjectVersionByJobID, jobID) + var i ProjectVersion + err := row.Scan( + &i.ID, + &i.ProjectID, + &i.OrganizationID, + &i.CreatedAt, + &i.UpdatedAt, + &i.Name, + &i.Description, + &i.JobID, + ) + return i, err +} + +const getProjectVersionByProjectIDAndName = `-- name: GetProjectVersionByProjectIDAndName :one +SELECT + id, project_id, organization_id, created_at, updated_at, name, description, job_id +FROM + project_versions +WHERE + project_id = $1 + AND "name" = $2 +` + +type GetProjectVersionByProjectIDAndNameParams struct { + ProjectID uuid.NullUUID `db:"project_id" json:"project_id"` + Name string `db:"name" json:"name"` +} + +func (q *sqlQuerier) GetProjectVersionByProjectIDAndName(ctx context.Context, arg GetProjectVersionByProjectIDAndNameParams) (ProjectVersion, error) { + row := q.db.QueryRowContext(ctx, getProjectVersionByProjectIDAndName, arg.ProjectID, arg.Name) + var i ProjectVersion + err := row.Scan( + &i.ID, + &i.ProjectID, + &i.OrganizationID, + &i.CreatedAt, + &i.UpdatedAt, + &i.Name, + &i.Description, + &i.JobID, + ) + return i, err +} + +const getProjectVersionsByProjectID = `-- name: GetProjectVersionsByProjectID :many +SELECT + id, project_id, organization_id, created_at, updated_at, name, description, job_id +FROM + project_versions +WHERE + project_id = $1 :: uuid +` + +func (q *sqlQuerier) GetProjectVersionsByProjectID(ctx context.Context, dollar_1 uuid.UUID) ([]ProjectVersion, error) { + rows, err := q.db.QueryContext(ctx, getProjectVersionsByProjectID, dollar_1) + if err != nil { + return nil, err + } + defer rows.Close() + var items []ProjectVersion + for rows.Next() { + var i ProjectVersion + if err := rows.Scan( + &i.ID, + &i.ProjectID, + &i.OrganizationID, + &i.CreatedAt, + &i.UpdatedAt, + &i.Name, + &i.Description, + &i.JobID, + ); 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 insertProjectVersion = `-- name: InsertProjectVersion :one +INSERT INTO + project_versions ( + id, + project_id, + organization_id, + created_at, + updated_at, + "name", + description, + job_id + ) +VALUES + ($1, $2, $3, $4, $5, $6, $7, $8) RETURNING id, project_id, organization_id, created_at, updated_at, name, description, job_id +` + +type InsertProjectVersionParams struct { + ID uuid.UUID `db:"id" json:"id"` + ProjectID uuid.NullUUID `db:"project_id" json:"project_id"` + OrganizationID string `db:"organization_id" json:"organization_id"` + CreatedAt time.Time `db:"created_at" json:"created_at"` + UpdatedAt time.Time `db:"updated_at" json:"updated_at"` + Name string `db:"name" json:"name"` + Description string `db:"description" json:"description"` + JobID uuid.UUID `db:"job_id" json:"job_id"` +} + +func (q *sqlQuerier) InsertProjectVersion(ctx context.Context, arg InsertProjectVersionParams) (ProjectVersion, error) { + row := q.db.QueryRowContext(ctx, insertProjectVersion, + arg.ID, + arg.ProjectID, + arg.OrganizationID, + arg.CreatedAt, + arg.UpdatedAt, + arg.Name, + arg.Description, + arg.JobID, + ) + var i ProjectVersion + err := row.Scan( + &i.ID, + &i.ProjectID, + &i.OrganizationID, + &i.CreatedAt, + &i.UpdatedAt, + &i.Name, + &i.Description, + &i.JobID, + ) + return i, err +} + +const updateProjectVersionByID = `-- name: UpdateProjectVersionByID :exec +UPDATE + project_versions +SET + project_id = $2, + updated_at = $3 +WHERE + id = $1 +` + +type UpdateProjectVersionByIDParams struct { + ID uuid.UUID `db:"id" json:"id"` + ProjectID uuid.NullUUID `db:"project_id" json:"project_id"` + UpdatedAt time.Time `db:"updated_at" json:"updated_at"` +} + +func (q *sqlQuerier) UpdateProjectVersionByID(ctx context.Context, arg UpdateProjectVersionByIDParams) error { + _, err := q.db.ExecContext(ctx, updateProjectVersionByID, arg.ID, arg.ProjectID, arg.UpdatedAt) + return err +} + +const getProvisionerDaemonByID = `-- name: GetProvisionerDaemonByID :one +SELECT + id, created_at, updated_at, organization_id, name, provisioners +FROM + provisioner_daemons +WHERE + id = $1 +` + +func (q *sqlQuerier) GetProvisionerDaemonByID(ctx context.Context, id uuid.UUID) (ProvisionerDaemon, error) { + row := q.db.QueryRowContext(ctx, getProvisionerDaemonByID, id) + var i ProvisionerDaemon + err := row.Scan( + &i.ID, + &i.CreatedAt, + &i.UpdatedAt, + &i.OrganizationID, + &i.Name, + pq.Array(&i.Provisioners), + ) + return i, err +} + +const getProvisionerDaemons = `-- name: GetProvisionerDaemons :many +SELECT + id, created_at, updated_at, organization_id, name, provisioners +FROM + provisioner_daemons +` + +func (q *sqlQuerier) GetProvisionerDaemons(ctx context.Context) ([]ProvisionerDaemon, error) { + rows, err := q.db.QueryContext(ctx, getProvisionerDaemons) + if err != nil { + return nil, err + } + defer rows.Close() + var items []ProvisionerDaemon + for rows.Next() { + var i ProvisionerDaemon + if err := rows.Scan( + &i.ID, + &i.CreatedAt, + &i.UpdatedAt, + &i.OrganizationID, + &i.Name, + pq.Array(&i.Provisioners), + ); 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 insertProvisionerDaemon = `-- name: InsertProvisionerDaemon :one +INSERT INTO + provisioner_daemons ( + id, + created_at, + organization_id, + "name", + provisioners + ) +VALUES + ($1, $2, $3, $4, $5) RETURNING id, created_at, updated_at, organization_id, name, provisioners +` + +type InsertProvisionerDaemonParams struct { + ID uuid.UUID `db:"id" json:"id"` + CreatedAt time.Time `db:"created_at" json:"created_at"` + OrganizationID sql.NullString `db:"organization_id" json:"organization_id"` + Name string `db:"name" json:"name"` + Provisioners []ProvisionerType `db:"provisioners" json:"provisioners"` +} + +func (q *sqlQuerier) InsertProvisionerDaemon(ctx context.Context, arg InsertProvisionerDaemonParams) (ProvisionerDaemon, error) { + row := q.db.QueryRowContext(ctx, insertProvisionerDaemon, + arg.ID, + arg.CreatedAt, + arg.OrganizationID, + arg.Name, + pq.Array(arg.Provisioners), + ) + var i ProvisionerDaemon + err := row.Scan( + &i.ID, + &i.CreatedAt, + &i.UpdatedAt, + &i.OrganizationID, + &i.Name, + pq.Array(&i.Provisioners), + ) + return i, err +} + +const updateProvisionerDaemonByID = `-- name: UpdateProvisionerDaemonByID :exec +UPDATE + provisioner_daemons +SET + updated_at = $2, + provisioners = $3 +WHERE + id = $1 +` + +type UpdateProvisionerDaemonByIDParams struct { + ID uuid.UUID `db:"id" json:"id"` + UpdatedAt sql.NullTime `db:"updated_at" json:"updated_at"` + Provisioners []ProvisionerType `db:"provisioners" json:"provisioners"` +} + +func (q *sqlQuerier) UpdateProvisionerDaemonByID(ctx context.Context, arg UpdateProvisionerDaemonByIDParams) error { + _, err := q.db.ExecContext(ctx, updateProvisionerDaemonByID, arg.ID, arg.UpdatedAt, pq.Array(arg.Provisioners)) + return err +} + +const getProvisionerLogsByIDBetween = `-- name: GetProvisionerLogsByIDBetween :many +SELECT + id, job_id, created_at, source, level, stage, output +FROM + provisioner_job_logs +WHERE + job_id = $1 + AND ( + created_at >= $2 + OR created_at <= $3 + ) +ORDER BY + created_at DESC +` + +type GetProvisionerLogsByIDBetweenParams struct { + JobID uuid.UUID `db:"job_id" json:"job_id"` + CreatedAfter time.Time `db:"created_after" json:"created_after"` + CreatedBefore time.Time `db:"created_before" json:"created_before"` +} + +func (q *sqlQuerier) GetProvisionerLogsByIDBetween(ctx context.Context, arg GetProvisionerLogsByIDBetweenParams) ([]ProvisionerJobLog, error) { + rows, err := q.db.QueryContext(ctx, getProvisionerLogsByIDBetween, arg.JobID, arg.CreatedAfter, arg.CreatedBefore) + if err != nil { + return nil, err + } + defer rows.Close() + var items []ProvisionerJobLog + for rows.Next() { + var i ProvisionerJobLog + if err := rows.Scan( + &i.ID, + &i.JobID, + &i.CreatedAt, + &i.Source, + &i.Level, + &i.Stage, + &i.Output, + ); 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 insertProvisionerJobLogs = `-- name: InsertProvisionerJobLogs :many +INSERT INTO + provisioner_job_logs +SELECT + unnest($1 :: uuid [ ]) AS id, + $2 :: uuid AS job_id, + unnest($3 :: timestamptz [ ]) AS created_at, + unnest($4 :: log_source [ ]) AS source, + unnest($5 :: log_level [ ]) AS LEVEL, + unnest($6 :: VARCHAR(128) [ ]) AS stage, + unnest($7 :: VARCHAR(1024) [ ]) AS output RETURNING id, job_id, created_at, source, level, stage, output +` + +type InsertProvisionerJobLogsParams struct { + ID []uuid.UUID `db:"id" json:"id"` + JobID uuid.UUID `db:"job_id" json:"job_id"` + CreatedAt []time.Time `db:"created_at" json:"created_at"` + Source []LogSource `db:"source" json:"source"` + Level []LogLevel `db:"level" json:"level"` + Stage []string `db:"stage" json:"stage"` + Output []string `db:"output" json:"output"` +} + +func (q *sqlQuerier) InsertProvisionerJobLogs(ctx context.Context, arg InsertProvisionerJobLogsParams) ([]ProvisionerJobLog, error) { + rows, err := q.db.QueryContext(ctx, insertProvisionerJobLogs, + pq.Array(arg.ID), + arg.JobID, + pq.Array(arg.CreatedAt), + pq.Array(arg.Source), + pq.Array(arg.Level), + pq.Array(arg.Stage), + pq.Array(arg.Output), + ) + if err != nil { + return nil, err + } + defer rows.Close() + var items []ProvisionerJobLog + for rows.Next() { + var i ProvisionerJobLog + if err := rows.Scan( + &i.ID, + &i.JobID, + &i.CreatedAt, + &i.Source, + &i.Level, + &i.Stage, + &i.Output, + ); 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 acquireProvisionerJob = `-- name: AcquireProvisionerJob :one +UPDATE + provisioner_jobs +SET + started_at = $1, + updated_at = $1, + worker_id = $2 +WHERE + id = ( + SELECT + id + FROM + provisioner_jobs AS nested + WHERE + nested.started_at IS NULL + AND nested.canceled_at IS NULL + AND nested.completed_at IS NULL + AND nested.provisioner = ANY($3 :: provisioner_type [ ]) + ORDER BY + nested.created_at FOR + UPDATE + SKIP LOCKED + LIMIT + 1 + ) RETURNING id, created_at, updated_at, started_at, canceled_at, completed_at, error, organization_id, initiator_id, provisioner, storage_method, storage_source, type, input, worker_id +` + +type AcquireProvisionerJobParams struct { + StartedAt sql.NullTime `db:"started_at" json:"started_at"` + WorkerID uuid.NullUUID `db:"worker_id" json:"worker_id"` + Types []ProvisionerType `db:"types" json:"types"` +} + +// Acquires the lock for a single job that isn't started, completed, +// canceled, and that matches an array of provisioner types. +// +// SKIP LOCKED is used to jump over locked rows. This prevents +// multiple provisioners from acquiring the same jobs. See: +// https://www.postgresql.org/docs/9.5/sql-select.html#SQL-FOR-UPDATE-SHARE +func (q *sqlQuerier) AcquireProvisionerJob(ctx context.Context, arg AcquireProvisionerJobParams) (ProvisionerJob, error) { + row := q.db.QueryRowContext(ctx, acquireProvisionerJob, arg.StartedAt, arg.WorkerID, pq.Array(arg.Types)) + var i ProvisionerJob + err := row.Scan( + &i.ID, + &i.CreatedAt, + &i.UpdatedAt, + &i.StartedAt, + &i.CanceledAt, + &i.CompletedAt, + &i.Error, + &i.OrganizationID, + &i.InitiatorID, + &i.Provisioner, + &i.StorageMethod, + &i.StorageSource, + &i.Type, + &i.Input, + &i.WorkerID, + ) + return i, err +} + +const getProvisionerJobByID = `-- name: GetProvisionerJobByID :one +SELECT + id, created_at, updated_at, started_at, canceled_at, completed_at, error, organization_id, initiator_id, provisioner, storage_method, storage_source, type, input, worker_id +FROM + provisioner_jobs +WHERE + id = $1 +` + +func (q *sqlQuerier) GetProvisionerJobByID(ctx context.Context, id uuid.UUID) (ProvisionerJob, error) { + row := q.db.QueryRowContext(ctx, getProvisionerJobByID, id) + var i ProvisionerJob + err := row.Scan( + &i.ID, + &i.CreatedAt, + &i.UpdatedAt, + &i.StartedAt, + &i.CanceledAt, + &i.CompletedAt, + &i.Error, + &i.OrganizationID, + &i.InitiatorID, + &i.Provisioner, + &i.StorageMethod, + &i.StorageSource, + &i.Type, + &i.Input, + &i.WorkerID, + ) + return i, err +} + +const getProvisionerJobsByIDs = `-- name: GetProvisionerJobsByIDs :many +SELECT + id, created_at, updated_at, started_at, canceled_at, completed_at, error, organization_id, initiator_id, provisioner, storage_method, storage_source, type, input, worker_id +FROM + provisioner_jobs +WHERE + id = ANY($1 :: uuid [ ]) +` + +func (q *sqlQuerier) GetProvisionerJobsByIDs(ctx context.Context, ids []uuid.UUID) ([]ProvisionerJob, error) { + rows, err := q.db.QueryContext(ctx, getProvisionerJobsByIDs, pq.Array(ids)) + if err != nil { + return nil, err + } + defer rows.Close() + var items []ProvisionerJob + for rows.Next() { + var i ProvisionerJob + if err := rows.Scan( + &i.ID, + &i.CreatedAt, + &i.UpdatedAt, + &i.StartedAt, + &i.CanceledAt, + &i.CompletedAt, + &i.Error, + &i.OrganizationID, + &i.InitiatorID, + &i.Provisioner, + &i.StorageMethod, + &i.StorageSource, + &i.Type, + &i.Input, + &i.WorkerID, + ); 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 insertProvisionerJob = `-- name: InsertProvisionerJob :one +INSERT INTO + provisioner_jobs ( + id, + created_at, + updated_at, + organization_id, + initiator_id, + provisioner, + storage_method, + storage_source, + "type", + "input" + ) +VALUES + ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10) RETURNING id, created_at, updated_at, started_at, canceled_at, completed_at, error, organization_id, initiator_id, provisioner, storage_method, storage_source, type, input, worker_id +` + +type InsertProvisionerJobParams struct { + ID uuid.UUID `db:"id" json:"id"` + CreatedAt time.Time `db:"created_at" json:"created_at"` + UpdatedAt time.Time `db:"updated_at" json:"updated_at"` + OrganizationID string `db:"organization_id" json:"organization_id"` + InitiatorID string `db:"initiator_id" json:"initiator_id"` + Provisioner ProvisionerType `db:"provisioner" json:"provisioner"` + StorageMethod ProvisionerStorageMethod `db:"storage_method" json:"storage_method"` + StorageSource string `db:"storage_source" json:"storage_source"` + Type ProvisionerJobType `db:"type" json:"type"` + Input json.RawMessage `db:"input" json:"input"` +} + +func (q *sqlQuerier) InsertProvisionerJob(ctx context.Context, arg InsertProvisionerJobParams) (ProvisionerJob, error) { + row := q.db.QueryRowContext(ctx, insertProvisionerJob, + arg.ID, + arg.CreatedAt, + arg.UpdatedAt, + arg.OrganizationID, + arg.InitiatorID, + arg.Provisioner, + arg.StorageMethod, + arg.StorageSource, + arg.Type, + arg.Input, + ) + var i ProvisionerJob + err := row.Scan( + &i.ID, + &i.CreatedAt, + &i.UpdatedAt, + &i.StartedAt, + &i.CanceledAt, + &i.CompletedAt, + &i.Error, + &i.OrganizationID, + &i.InitiatorID, + &i.Provisioner, + &i.StorageMethod, + &i.StorageSource, + &i.Type, + &i.Input, + &i.WorkerID, + ) + return i, err +} + +const updateProvisionerJobByID = `-- name: UpdateProvisionerJobByID :exec +UPDATE + provisioner_jobs +SET + updated_at = $2 +WHERE + id = $1 +` + +type UpdateProvisionerJobByIDParams struct { + ID uuid.UUID `db:"id" json:"id"` + UpdatedAt time.Time `db:"updated_at" json:"updated_at"` +} + +func (q *sqlQuerier) UpdateProvisionerJobByID(ctx context.Context, arg UpdateProvisionerJobByIDParams) error { + _, err := q.db.ExecContext(ctx, updateProvisionerJobByID, arg.ID, arg.UpdatedAt) + return err +} + +const updateProvisionerJobWithCancelByID = `-- name: UpdateProvisionerJobWithCancelByID :exec +UPDATE + provisioner_jobs +SET + canceled_at = $2 +WHERE + id = $1 +` + +type UpdateProvisionerJobWithCancelByIDParams struct { + ID uuid.UUID `db:"id" json:"id"` + CanceledAt sql.NullTime `db:"canceled_at" json:"canceled_at"` +} + +func (q *sqlQuerier) UpdateProvisionerJobWithCancelByID(ctx context.Context, arg UpdateProvisionerJobWithCancelByIDParams) error { + _, err := q.db.ExecContext(ctx, updateProvisionerJobWithCancelByID, arg.ID, arg.CanceledAt) + return err +} + +const updateProvisionerJobWithCompleteByID = `-- name: UpdateProvisionerJobWithCompleteByID :exec +UPDATE + provisioner_jobs +SET + updated_at = $2, + completed_at = $3, + error = $4 +WHERE + id = $1 +` + +type UpdateProvisionerJobWithCompleteByIDParams struct { + ID uuid.UUID `db:"id" json:"id"` + UpdatedAt time.Time `db:"updated_at" json:"updated_at"` + CompletedAt sql.NullTime `db:"completed_at" json:"completed_at"` + Error sql.NullString `db:"error" json:"error"` +} + +func (q *sqlQuerier) UpdateProvisionerJobWithCompleteByID(ctx context.Context, arg UpdateProvisionerJobWithCompleteByIDParams) error { + _, err := q.db.ExecContext(ctx, updateProvisionerJobWithCompleteByID, + arg.ID, + arg.UpdatedAt, + arg.CompletedAt, + arg.Error, + ) + return err +} + +const getUserByEmailOrUsername = `-- name: GetUserByEmailOrUsername :one +SELECT + id, email, name, revoked, login_type, hashed_password, created_at, updated_at, temporary_password, avatar_hash, ssh_key_regenerated_at, username, dotfiles_git_uri, roles, status, relatime, gpg_key_regenerated_at, _decomissioned, shell +FROM + users +WHERE + LOWER(username) = LOWER($1) + OR email = $2 +LIMIT + 1 +` + +type GetUserByEmailOrUsernameParams struct { + Username string `db:"username" json:"username"` + Email string `db:"email" json:"email"` +} + +func (q *sqlQuerier) GetUserByEmailOrUsername(ctx context.Context, arg GetUserByEmailOrUsernameParams) (User, error) { + row := q.db.QueryRowContext(ctx, getUserByEmailOrUsername, arg.Username, arg.Email) + var i User + err := row.Scan( + &i.ID, + &i.Email, + &i.Name, + &i.Revoked, + &i.LoginType, + &i.HashedPassword, + &i.CreatedAt, + &i.UpdatedAt, + &i.TemporaryPassword, + &i.AvatarHash, + &i.SshKeyRegeneratedAt, + &i.Username, + &i.DotfilesGitUri, + pq.Array(&i.Roles), + &i.Status, + &i.Relatime, + &i.GpgKeyRegeneratedAt, + &i.Decomissioned, + &i.Shell, + ) + return i, err +} + +const getUserByID = `-- name: GetUserByID :one +SELECT + id, email, name, revoked, login_type, hashed_password, created_at, updated_at, temporary_password, avatar_hash, ssh_key_regenerated_at, username, dotfiles_git_uri, roles, status, relatime, gpg_key_regenerated_at, _decomissioned, shell +FROM + users +WHERE + id = $1 +LIMIT + 1 +` + +func (q *sqlQuerier) GetUserByID(ctx context.Context, id string) (User, error) { + row := q.db.QueryRowContext(ctx, getUserByID, id) + var i User + err := row.Scan( + &i.ID, + &i.Email, + &i.Name, + &i.Revoked, + &i.LoginType, + &i.HashedPassword, + &i.CreatedAt, + &i.UpdatedAt, + &i.TemporaryPassword, + &i.AvatarHash, + &i.SshKeyRegeneratedAt, + &i.Username, + &i.DotfilesGitUri, + pq.Array(&i.Roles), + &i.Status, + &i.Relatime, + &i.GpgKeyRegeneratedAt, + &i.Decomissioned, + &i.Shell, + ) + return i, err +} + +const getUserCount = `-- name: GetUserCount :one +SELECT + COUNT(*) +FROM + users +` + +func (q *sqlQuerier) GetUserCount(ctx context.Context) (int64, error) { + row := q.db.QueryRowContext(ctx, getUserCount) + var count int64 + err := row.Scan(&count) + return count, err +} + +const insertUser = `-- name: InsertUser :one +INSERT INTO + users ( + id, + email, + "name", + login_type, + revoked, + hashed_password, + created_at, + updated_at, + username + ) +VALUES + ($1, $2, $3, $4, FALSE, $5, $6, $7, $8) RETURNING id, email, name, revoked, login_type, hashed_password, created_at, updated_at, temporary_password, avatar_hash, ssh_key_regenerated_at, username, dotfiles_git_uri, roles, status, relatime, gpg_key_regenerated_at, _decomissioned, shell +` + +type InsertUserParams struct { + ID string `db:"id" json:"id"` + Email string `db:"email" json:"email"` + Name string `db:"name" json:"name"` + LoginType LoginType `db:"login_type" json:"login_type"` + HashedPassword []byte `db:"hashed_password" json:"hashed_password"` + CreatedAt time.Time `db:"created_at" json:"created_at"` + UpdatedAt time.Time `db:"updated_at" json:"updated_at"` + Username string `db:"username" json:"username"` +} + +func (q *sqlQuerier) InsertUser(ctx context.Context, arg InsertUserParams) (User, error) { + row := q.db.QueryRowContext(ctx, insertUser, + arg.ID, + arg.Email, + arg.Name, + arg.LoginType, + arg.HashedPassword, + arg.CreatedAt, + arg.UpdatedAt, + arg.Username, + ) + var i User + err := row.Scan( + &i.ID, + &i.Email, + &i.Name, + &i.Revoked, + &i.LoginType, + &i.HashedPassword, + &i.CreatedAt, + &i.UpdatedAt, + &i.TemporaryPassword, + &i.AvatarHash, + &i.SshKeyRegeneratedAt, + &i.Username, + &i.DotfilesGitUri, + pq.Array(&i.Roles), + &i.Status, + &i.Relatime, + &i.GpgKeyRegeneratedAt, + &i.Decomissioned, + &i.Shell, + ) + return i, err +} + +const getWorkspaceAgentByAuthToken = `-- name: GetWorkspaceAgentByAuthToken :one +SELECT + id, created_at, updated_at, first_connected_at, last_connected_at, disconnected_at, resource_id, auth_token, auth_instance_id, environment_variables, startup_script, instance_metadata, resource_metadata +FROM + workspace_agents +WHERE + auth_token = $1 +ORDER BY + created_at DESC +` + +func (q *sqlQuerier) GetWorkspaceAgentByAuthToken(ctx context.Context, authToken uuid.UUID) (WorkspaceAgent, error) { + row := q.db.QueryRowContext(ctx, getWorkspaceAgentByAuthToken, authToken) + var i WorkspaceAgent + err := row.Scan( + &i.ID, + &i.CreatedAt, + &i.UpdatedAt, + &i.FirstConnectedAt, + &i.LastConnectedAt, + &i.DisconnectedAt, + &i.ResourceID, + &i.AuthToken, + &i.AuthInstanceID, + &i.EnvironmentVariables, + &i.StartupScript, + &i.InstanceMetadata, + &i.ResourceMetadata, + ) + return i, err +} + +const getWorkspaceAgentByInstanceID = `-- name: GetWorkspaceAgentByInstanceID :one +SELECT + id, created_at, updated_at, first_connected_at, last_connected_at, disconnected_at, resource_id, auth_token, auth_instance_id, environment_variables, startup_script, instance_metadata, resource_metadata +FROM + workspace_agents +WHERE + auth_instance_id = $1 :: TEXT +ORDER BY + created_at DESC +` + +func (q *sqlQuerier) GetWorkspaceAgentByInstanceID(ctx context.Context, authInstanceID string) (WorkspaceAgent, error) { + row := q.db.QueryRowContext(ctx, getWorkspaceAgentByInstanceID, authInstanceID) + var i WorkspaceAgent + err := row.Scan( + &i.ID, + &i.CreatedAt, + &i.UpdatedAt, + &i.FirstConnectedAt, + &i.LastConnectedAt, + &i.DisconnectedAt, + &i.ResourceID, + &i.AuthToken, + &i.AuthInstanceID, + &i.EnvironmentVariables, + &i.StartupScript, + &i.InstanceMetadata, + &i.ResourceMetadata, + ) + return i, err +} + +const getWorkspaceAgentByResourceID = `-- name: GetWorkspaceAgentByResourceID :one +SELECT + id, created_at, updated_at, first_connected_at, last_connected_at, disconnected_at, resource_id, auth_token, auth_instance_id, environment_variables, startup_script, instance_metadata, resource_metadata +FROM + workspace_agents +WHERE + resource_id = $1 +` + +func (q *sqlQuerier) GetWorkspaceAgentByResourceID(ctx context.Context, resourceID uuid.UUID) (WorkspaceAgent, error) { + row := q.db.QueryRowContext(ctx, getWorkspaceAgentByResourceID, resourceID) + var i WorkspaceAgent + err := row.Scan( + &i.ID, + &i.CreatedAt, + &i.UpdatedAt, + &i.FirstConnectedAt, + &i.LastConnectedAt, + &i.DisconnectedAt, + &i.ResourceID, + &i.AuthToken, + &i.AuthInstanceID, + &i.EnvironmentVariables, + &i.StartupScript, + &i.InstanceMetadata, + &i.ResourceMetadata, + ) + return i, err +} + +const insertWorkspaceAgent = `-- name: InsertWorkspaceAgent :one +INSERT INTO + workspace_agents ( + id, + created_at, + updated_at, + resource_id, + auth_token, + auth_instance_id, + environment_variables, + startup_script, + instance_metadata, + resource_metadata + ) +VALUES + ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10) RETURNING id, created_at, updated_at, first_connected_at, last_connected_at, disconnected_at, resource_id, auth_token, auth_instance_id, environment_variables, startup_script, instance_metadata, resource_metadata +` + +type InsertWorkspaceAgentParams struct { + ID uuid.UUID `db:"id" json:"id"` + CreatedAt time.Time `db:"created_at" json:"created_at"` + UpdatedAt time.Time `db:"updated_at" json:"updated_at"` + ResourceID uuid.UUID `db:"resource_id" json:"resource_id"` + AuthToken uuid.UUID `db:"auth_token" json:"auth_token"` + AuthInstanceID sql.NullString `db:"auth_instance_id" json:"auth_instance_id"` + EnvironmentVariables pqtype.NullRawMessage `db:"environment_variables" json:"environment_variables"` + StartupScript sql.NullString `db:"startup_script" json:"startup_script"` + InstanceMetadata pqtype.NullRawMessage `db:"instance_metadata" json:"instance_metadata"` + ResourceMetadata pqtype.NullRawMessage `db:"resource_metadata" json:"resource_metadata"` +} + +func (q *sqlQuerier) InsertWorkspaceAgent(ctx context.Context, arg InsertWorkspaceAgentParams) (WorkspaceAgent, error) { + row := q.db.QueryRowContext(ctx, insertWorkspaceAgent, + arg.ID, + arg.CreatedAt, + arg.UpdatedAt, + arg.ResourceID, + arg.AuthToken, + arg.AuthInstanceID, + arg.EnvironmentVariables, + arg.StartupScript, + arg.InstanceMetadata, + arg.ResourceMetadata, + ) + var i WorkspaceAgent + err := row.Scan( + &i.ID, + &i.CreatedAt, + &i.UpdatedAt, + &i.FirstConnectedAt, + &i.LastConnectedAt, + &i.DisconnectedAt, + &i.ResourceID, + &i.AuthToken, + &i.AuthInstanceID, + &i.EnvironmentVariables, + &i.StartupScript, + &i.InstanceMetadata, + &i.ResourceMetadata, + ) + return i, err +} + +const updateWorkspaceAgentConnectionByID = `-- name: UpdateWorkspaceAgentConnectionByID :exec +UPDATE + workspace_agents +SET + first_connected_at = $2, + last_connected_at = $3, + disconnected_at = $4 +WHERE + id = $1 +` + +type UpdateWorkspaceAgentConnectionByIDParams struct { + ID uuid.UUID `db:"id" json:"id"` + FirstConnectedAt sql.NullTime `db:"first_connected_at" json:"first_connected_at"` + LastConnectedAt sql.NullTime `db:"last_connected_at" json:"last_connected_at"` + DisconnectedAt sql.NullTime `db:"disconnected_at" json:"disconnected_at"` +} + +func (q *sqlQuerier) UpdateWorkspaceAgentConnectionByID(ctx context.Context, arg UpdateWorkspaceAgentConnectionByIDParams) error { + _, err := q.db.ExecContext(ctx, updateWorkspaceAgentConnectionByID, + arg.ID, + arg.FirstConnectedAt, + arg.LastConnectedAt, + arg.DisconnectedAt, + ) + return err +} + +const getWorkspaceBuildByID = `-- name: GetWorkspaceBuildByID :one +SELECT + id, created_at, updated_at, workspace_id, project_version_id, name, before_id, after_id, transition, initiator, provisioner_state, job_id +FROM + workspace_builds +WHERE + id = $1 +LIMIT + 1 +` + +func (q *sqlQuerier) GetWorkspaceBuildByID(ctx context.Context, id uuid.UUID) (WorkspaceBuild, error) { + row := q.db.QueryRowContext(ctx, getWorkspaceBuildByID, id) + var i WorkspaceBuild + err := row.Scan( + &i.ID, + &i.CreatedAt, + &i.UpdatedAt, + &i.WorkspaceID, + &i.ProjectVersionID, + &i.Name, + &i.BeforeID, + &i.AfterID, + &i.Transition, + &i.Initiator, + &i.ProvisionerState, + &i.JobID, + ) + return i, err +} + +const getWorkspaceBuildByJobID = `-- name: GetWorkspaceBuildByJobID :one +SELECT + id, created_at, updated_at, workspace_id, project_version_id, name, before_id, after_id, transition, initiator, provisioner_state, job_id +FROM + workspace_builds +WHERE + job_id = $1 +LIMIT + 1 +` + +func (q *sqlQuerier) GetWorkspaceBuildByJobID(ctx context.Context, jobID uuid.UUID) (WorkspaceBuild, error) { + row := q.db.QueryRowContext(ctx, getWorkspaceBuildByJobID, jobID) + var i WorkspaceBuild + err := row.Scan( + &i.ID, + &i.CreatedAt, + &i.UpdatedAt, + &i.WorkspaceID, + &i.ProjectVersionID, + &i.Name, + &i.BeforeID, + &i.AfterID, + &i.Transition, + &i.Initiator, + &i.ProvisionerState, + &i.JobID, + ) + return i, err +} + +const getWorkspaceBuildByWorkspaceID = `-- name: GetWorkspaceBuildByWorkspaceID :many +SELECT + id, created_at, updated_at, workspace_id, project_version_id, name, before_id, after_id, transition, initiator, provisioner_state, job_id +FROM + workspace_builds +WHERE + workspace_id = $1 +` + +func (q *sqlQuerier) GetWorkspaceBuildByWorkspaceID(ctx context.Context, workspaceID uuid.UUID) ([]WorkspaceBuild, error) { + rows, err := q.db.QueryContext(ctx, getWorkspaceBuildByWorkspaceID, workspaceID) + if err != nil { + return nil, err + } + defer rows.Close() + var items []WorkspaceBuild + for rows.Next() { + var i WorkspaceBuild + if err := rows.Scan( + &i.ID, + &i.CreatedAt, + &i.UpdatedAt, + &i.WorkspaceID, + &i.ProjectVersionID, + &i.Name, + &i.BeforeID, + &i.AfterID, + &i.Transition, + &i.Initiator, + &i.ProvisionerState, + &i.JobID, + ); 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 getWorkspaceBuildByWorkspaceIDAndName = `-- name: GetWorkspaceBuildByWorkspaceIDAndName :one +SELECT + id, created_at, updated_at, workspace_id, project_version_id, name, before_id, after_id, transition, initiator, provisioner_state, job_id +FROM + workspace_builds +WHERE + workspace_id = $1 + AND "name" = $2 +` + +type GetWorkspaceBuildByWorkspaceIDAndNameParams struct { + WorkspaceID uuid.UUID `db:"workspace_id" json:"workspace_id"` + Name string `db:"name" json:"name"` +} + +func (q *sqlQuerier) GetWorkspaceBuildByWorkspaceIDAndName(ctx context.Context, arg GetWorkspaceBuildByWorkspaceIDAndNameParams) (WorkspaceBuild, error) { + row := q.db.QueryRowContext(ctx, getWorkspaceBuildByWorkspaceIDAndName, arg.WorkspaceID, arg.Name) + var i WorkspaceBuild + err := row.Scan( + &i.ID, + &i.CreatedAt, + &i.UpdatedAt, + &i.WorkspaceID, + &i.ProjectVersionID, + &i.Name, + &i.BeforeID, + &i.AfterID, + &i.Transition, + &i.Initiator, + &i.ProvisionerState, + &i.JobID, + ) + return i, err +} + +const getWorkspaceBuildByWorkspaceIDWithoutAfter = `-- name: GetWorkspaceBuildByWorkspaceIDWithoutAfter :one +SELECT + id, created_at, updated_at, workspace_id, project_version_id, name, before_id, after_id, transition, initiator, provisioner_state, job_id +FROM + workspace_builds +WHERE + workspace_id = $1 + AND after_id IS NULL +LIMIT + 1 +` + +func (q *sqlQuerier) GetWorkspaceBuildByWorkspaceIDWithoutAfter(ctx context.Context, workspaceID uuid.UUID) (WorkspaceBuild, error) { + row := q.db.QueryRowContext(ctx, getWorkspaceBuildByWorkspaceIDWithoutAfter, workspaceID) + var i WorkspaceBuild + err := row.Scan( + &i.ID, + &i.CreatedAt, + &i.UpdatedAt, + &i.WorkspaceID, + &i.ProjectVersionID, + &i.Name, + &i.BeforeID, + &i.AfterID, + &i.Transition, + &i.Initiator, + &i.ProvisionerState, + &i.JobID, + ) + return i, err +} + +const getWorkspaceBuildsByWorkspaceIDsWithoutAfter = `-- name: GetWorkspaceBuildsByWorkspaceIDsWithoutAfter :many +SELECT + id, created_at, updated_at, workspace_id, project_version_id, name, before_id, after_id, transition, initiator, provisioner_state, job_id +FROM + workspace_builds +WHERE + workspace_id = ANY($1 :: uuid [ ]) + AND after_id IS NULL +` + +func (q *sqlQuerier) GetWorkspaceBuildsByWorkspaceIDsWithoutAfter(ctx context.Context, ids []uuid.UUID) ([]WorkspaceBuild, error) { + rows, err := q.db.QueryContext(ctx, getWorkspaceBuildsByWorkspaceIDsWithoutAfter, pq.Array(ids)) + if err != nil { + return nil, err + } + defer rows.Close() + var items []WorkspaceBuild + for rows.Next() { + var i WorkspaceBuild + if err := rows.Scan( + &i.ID, + &i.CreatedAt, + &i.UpdatedAt, + &i.WorkspaceID, + &i.ProjectVersionID, + &i.Name, + &i.BeforeID, + &i.AfterID, + &i.Transition, + &i.Initiator, + &i.ProvisionerState, + &i.JobID, + ); 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 insertWorkspaceBuild = `-- name: InsertWorkspaceBuild :one +INSERT INTO + workspace_builds ( + id, + created_at, + updated_at, + workspace_id, + project_version_id, + before_id, + "name", + transition, + initiator, + job_id, + provisioner_state + ) +VALUES + ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11) RETURNING id, created_at, updated_at, workspace_id, project_version_id, name, before_id, after_id, transition, initiator, provisioner_state, job_id +` + +type InsertWorkspaceBuildParams struct { + ID uuid.UUID `db:"id" json:"id"` + CreatedAt time.Time `db:"created_at" json:"created_at"` + UpdatedAt time.Time `db:"updated_at" json:"updated_at"` + WorkspaceID uuid.UUID `db:"workspace_id" json:"workspace_id"` + ProjectVersionID uuid.UUID `db:"project_version_id" json:"project_version_id"` + BeforeID uuid.NullUUID `db:"before_id" json:"before_id"` + Name string `db:"name" json:"name"` + Transition WorkspaceTransition `db:"transition" json:"transition"` + Initiator string `db:"initiator" json:"initiator"` + JobID uuid.UUID `db:"job_id" json:"job_id"` + ProvisionerState []byte `db:"provisioner_state" json:"provisioner_state"` +} + +func (q *sqlQuerier) InsertWorkspaceBuild(ctx context.Context, arg InsertWorkspaceBuildParams) (WorkspaceBuild, error) { + row := q.db.QueryRowContext(ctx, insertWorkspaceBuild, + arg.ID, + arg.CreatedAt, + arg.UpdatedAt, + arg.WorkspaceID, + arg.ProjectVersionID, + arg.BeforeID, + arg.Name, + arg.Transition, + arg.Initiator, + arg.JobID, + arg.ProvisionerState, + ) + var i WorkspaceBuild + err := row.Scan( + &i.ID, + &i.CreatedAt, + &i.UpdatedAt, + &i.WorkspaceID, + &i.ProjectVersionID, + &i.Name, + &i.BeforeID, + &i.AfterID, + &i.Transition, + &i.Initiator, + &i.ProvisionerState, + &i.JobID, + ) + return i, err +} + +const updateWorkspaceBuildByID = `-- name: UpdateWorkspaceBuildByID :exec +UPDATE + workspace_builds +SET + updated_at = $2, + after_id = $3, + provisioner_state = $4 +WHERE + id = $1 +` + +type UpdateWorkspaceBuildByIDParams struct { + ID uuid.UUID `db:"id" json:"id"` + UpdatedAt time.Time `db:"updated_at" json:"updated_at"` + AfterID uuid.NullUUID `db:"after_id" json:"after_id"` + ProvisionerState []byte `db:"provisioner_state" json:"provisioner_state"` +} + +func (q *sqlQuerier) UpdateWorkspaceBuildByID(ctx context.Context, arg UpdateWorkspaceBuildByIDParams) error { + _, err := q.db.ExecContext(ctx, updateWorkspaceBuildByID, + arg.ID, + arg.UpdatedAt, + arg.AfterID, + arg.ProvisionerState, + ) + return err +} + +const getWorkspaceResourceByID = `-- name: GetWorkspaceResourceByID :one +SELECT + id, created_at, job_id, transition, address, type, name, agent_id +FROM + workspace_resources +WHERE + id = $1 +` + +func (q *sqlQuerier) GetWorkspaceResourceByID(ctx context.Context, id uuid.UUID) (WorkspaceResource, error) { + row := q.db.QueryRowContext(ctx, getWorkspaceResourceByID, id) + var i WorkspaceResource + err := row.Scan( + &i.ID, + &i.CreatedAt, + &i.JobID, + &i.Transition, + &i.Address, + &i.Type, + &i.Name, + &i.AgentID, + ) + return i, err +} + +const getWorkspaceResourcesByJobID = `-- name: GetWorkspaceResourcesByJobID :many +SELECT + id, created_at, job_id, transition, address, type, name, agent_id +FROM + workspace_resources +WHERE + job_id = $1 +` + +func (q *sqlQuerier) GetWorkspaceResourcesByJobID(ctx context.Context, jobID uuid.UUID) ([]WorkspaceResource, error) { + rows, err := q.db.QueryContext(ctx, getWorkspaceResourcesByJobID, jobID) + if err != nil { + return nil, err + } + defer rows.Close() + var items []WorkspaceResource + for rows.Next() { + var i WorkspaceResource + if err := rows.Scan( + &i.ID, + &i.CreatedAt, + &i.JobID, + &i.Transition, + &i.Address, + &i.Type, + &i.Name, + &i.AgentID, + ); 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 insertWorkspaceResource = `-- name: InsertWorkspaceResource :one +INSERT INTO + workspace_resources ( + id, + created_at, + job_id, + transition, + address, + type, + name, + agent_id + ) +VALUES + ($1, $2, $3, $4, $5, $6, $7, $8) RETURNING id, created_at, job_id, transition, address, type, name, agent_id +` + +type InsertWorkspaceResourceParams struct { + ID uuid.UUID `db:"id" json:"id"` + CreatedAt time.Time `db:"created_at" json:"created_at"` + JobID uuid.UUID `db:"job_id" json:"job_id"` + Transition WorkspaceTransition `db:"transition" json:"transition"` + Address string `db:"address" json:"address"` + Type string `db:"type" json:"type"` + Name string `db:"name" json:"name"` + AgentID uuid.NullUUID `db:"agent_id" json:"agent_id"` +} + +func (q *sqlQuerier) InsertWorkspaceResource(ctx context.Context, arg InsertWorkspaceResourceParams) (WorkspaceResource, error) { + row := q.db.QueryRowContext(ctx, insertWorkspaceResource, + arg.ID, + arg.CreatedAt, + arg.JobID, + arg.Transition, + arg.Address, + arg.Type, + arg.Name, + arg.AgentID, + ) + var i WorkspaceResource + err := row.Scan( + &i.ID, + &i.CreatedAt, + &i.JobID, + &i.Transition, + &i.Address, + &i.Type, + &i.Name, + &i.AgentID, + ) + return i, err +} + +const getWorkspaceByID = `-- name: GetWorkspaceByID :one +SELECT + id, created_at, updated_at, owner_id, project_id, deleted, name +FROM + workspaces +WHERE + id = $1 +LIMIT + 1 +` + +func (q *sqlQuerier) GetWorkspaceByID(ctx context.Context, id uuid.UUID) (Workspace, error) { + row := q.db.QueryRowContext(ctx, getWorkspaceByID, id) + var i Workspace + err := row.Scan( + &i.ID, + &i.CreatedAt, + &i.UpdatedAt, + &i.OwnerID, + &i.ProjectID, + &i.Deleted, + &i.Name, + ) + return i, err +} + +const getWorkspaceByUserIDAndName = `-- name: GetWorkspaceByUserIDAndName :one +SELECT + id, created_at, updated_at, owner_id, project_id, deleted, name +FROM + workspaces +WHERE + owner_id = $1 + AND deleted = $2 + AND LOWER("name") = LOWER($3) +` + +type GetWorkspaceByUserIDAndNameParams struct { + OwnerID string `db:"owner_id" json:"owner_id"` + Deleted bool `db:"deleted" json:"deleted"` + Name string `db:"name" json:"name"` +} + +func (q *sqlQuerier) GetWorkspaceByUserIDAndName(ctx context.Context, arg GetWorkspaceByUserIDAndNameParams) (Workspace, error) { + row := q.db.QueryRowContext(ctx, getWorkspaceByUserIDAndName, arg.OwnerID, arg.Deleted, arg.Name) + var i Workspace + err := row.Scan( + &i.ID, + &i.CreatedAt, + &i.UpdatedAt, + &i.OwnerID, + &i.ProjectID, + &i.Deleted, + &i.Name, + ) + return i, err +} + +const getWorkspaceOwnerCountsByProjectIDs = `-- name: GetWorkspaceOwnerCountsByProjectIDs :many +SELECT + project_id, + COUNT(DISTINCT owner_id) +FROM + workspaces +WHERE + project_id = ANY($1 :: uuid [ ]) +GROUP BY + project_id, + owner_id +` + +type GetWorkspaceOwnerCountsByProjectIDsRow struct { + ProjectID uuid.UUID `db:"project_id" json:"project_id"` + Count int64 `db:"count" json:"count"` +} + +func (q *sqlQuerier) GetWorkspaceOwnerCountsByProjectIDs(ctx context.Context, ids []uuid.UUID) ([]GetWorkspaceOwnerCountsByProjectIDsRow, error) { + rows, err := q.db.QueryContext(ctx, getWorkspaceOwnerCountsByProjectIDs, pq.Array(ids)) + if err != nil { + return nil, err + } + defer rows.Close() + var items []GetWorkspaceOwnerCountsByProjectIDsRow + for rows.Next() { + var i GetWorkspaceOwnerCountsByProjectIDsRow + if err := rows.Scan(&i.ProjectID, &i.Count); 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 getWorkspacesByProjectID = `-- name: GetWorkspacesByProjectID :many +SELECT + id, created_at, updated_at, owner_id, project_id, deleted, name +FROM + workspaces +WHERE + project_id = $1 + AND deleted = $2 +` + +type GetWorkspacesByProjectIDParams struct { + ProjectID uuid.UUID `db:"project_id" json:"project_id"` + Deleted bool `db:"deleted" json:"deleted"` +} + +func (q *sqlQuerier) GetWorkspacesByProjectID(ctx context.Context, arg GetWorkspacesByProjectIDParams) ([]Workspace, error) { + rows, err := q.db.QueryContext(ctx, getWorkspacesByProjectID, arg.ProjectID, arg.Deleted) + if err != nil { + return nil, err + } + defer rows.Close() + var items []Workspace + for rows.Next() { + var i Workspace + if err := rows.Scan( + &i.ID, + &i.CreatedAt, + &i.UpdatedAt, + &i.OwnerID, + &i.ProjectID, + &i.Deleted, + &i.Name, + ); 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 getWorkspacesByUserID = `-- name: GetWorkspacesByUserID :many +SELECT + id, created_at, updated_at, owner_id, project_id, deleted, name +FROM + workspaces +WHERE + owner_id = $1 + AND deleted = $2 +` + +type GetWorkspacesByUserIDParams struct { + OwnerID string `db:"owner_id" json:"owner_id"` + Deleted bool `db:"deleted" json:"deleted"` +} + +func (q *sqlQuerier) GetWorkspacesByUserID(ctx context.Context, arg GetWorkspacesByUserIDParams) ([]Workspace, error) { + rows, err := q.db.QueryContext(ctx, getWorkspacesByUserID, arg.OwnerID, arg.Deleted) + if err != nil { + return nil, err + } + defer rows.Close() + var items []Workspace + for rows.Next() { + var i Workspace + if err := rows.Scan( + &i.ID, + &i.CreatedAt, + &i.UpdatedAt, + &i.OwnerID, + &i.ProjectID, + &i.Deleted, + &i.Name, + ); 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 insertWorkspace = `-- name: InsertWorkspace :one +INSERT INTO + workspaces ( + id, + created_at, + updated_at, + owner_id, + project_id, + name + ) +VALUES + ($1, $2, $3, $4, $5, $6) RETURNING id, created_at, updated_at, owner_id, project_id, deleted, name +` + +type InsertWorkspaceParams struct { + ID uuid.UUID `db:"id" json:"id"` + CreatedAt time.Time `db:"created_at" json:"created_at"` + UpdatedAt time.Time `db:"updated_at" json:"updated_at"` + OwnerID string `db:"owner_id" json:"owner_id"` + ProjectID uuid.UUID `db:"project_id" json:"project_id"` + Name string `db:"name" json:"name"` +} + +func (q *sqlQuerier) InsertWorkspace(ctx context.Context, arg InsertWorkspaceParams) (Workspace, error) { + row := q.db.QueryRowContext(ctx, insertWorkspace, + arg.ID, + arg.CreatedAt, + arg.UpdatedAt, + arg.OwnerID, + arg.ProjectID, + arg.Name, + ) + var i Workspace + err := row.Scan( + &i.ID, + &i.CreatedAt, + &i.UpdatedAt, + &i.OwnerID, + &i.ProjectID, + &i.Deleted, + &i.Name, + ) + return i, err +} + +const updateWorkspaceDeletedByID = `-- name: UpdateWorkspaceDeletedByID :exec +UPDATE + workspaces +SET + deleted = $2 +WHERE + id = $1 +` + +type UpdateWorkspaceDeletedByIDParams struct { + ID uuid.UUID `db:"id" json:"id"` + Deleted bool `db:"deleted" json:"deleted"` +} + +func (q *sqlQuerier) UpdateWorkspaceDeletedByID(ctx context.Context, arg UpdateWorkspaceDeletedByIDParams) error { + _, err := q.db.ExecContext(ctx, updateWorkspaceDeletedByID, arg.ID, arg.Deleted) + return err +} diff --git a/coderd/database/sqlc.yaml b/coderd/database/sqlc.yaml index 0319ccf47c1d3..8248ad8a72259 100644 --- a/coderd/database/sqlc.yaml +++ b/coderd/database/sqlc.yaml @@ -4,8 +4,8 @@ version: "1" packages: - name: "database" - path: "." - queries: "./queries/" + path: "./queries" + queries: "./queries" schema: "./dump.sql" engine: "postgresql" emit_interface: true diff --git a/coderd/database/users.sql.go b/coderd/database/users.sql.go deleted file mode 100644 index c56aabecca8bf..0000000000000 --- a/coderd/database/users.sql.go +++ /dev/null @@ -1,171 +0,0 @@ -// Code generated by sqlc. DO NOT EDIT. -// source: users.sql - -package database - -import ( - "context" - "time" - - "github.com/lib/pq" -) - -const getUserByEmailOrUsername = `-- name: GetUserByEmailOrUsername :one -SELECT - id, email, name, revoked, login_type, hashed_password, created_at, updated_at, temporary_password, avatar_hash, ssh_key_regenerated_at, username, dotfiles_git_uri, roles, status, relatime, gpg_key_regenerated_at, _decomissioned, shell -FROM - users -WHERE - LOWER(username) = LOWER($1) - OR email = $2 -LIMIT - 1 -` - -type GetUserByEmailOrUsernameParams struct { - Username string `db:"username" json:"username"` - Email string `db:"email" json:"email"` -} - -func (q *sqlQuerier) GetUserByEmailOrUsername(ctx context.Context, arg GetUserByEmailOrUsernameParams) (User, error) { - row := q.db.QueryRowContext(ctx, getUserByEmailOrUsername, arg.Username, arg.Email) - var i User - err := row.Scan( - &i.ID, - &i.Email, - &i.Name, - &i.Revoked, - &i.LoginType, - &i.HashedPassword, - &i.CreatedAt, - &i.UpdatedAt, - &i.TemporaryPassword, - &i.AvatarHash, - &i.SshKeyRegeneratedAt, - &i.Username, - &i.DotfilesGitUri, - pq.Array(&i.Roles), - &i.Status, - &i.Relatime, - &i.GpgKeyRegeneratedAt, - &i.Decomissioned, - &i.Shell, - ) - return i, err -} - -const getUserByID = `-- name: GetUserByID :one -SELECT - id, email, name, revoked, login_type, hashed_password, created_at, updated_at, temporary_password, avatar_hash, ssh_key_regenerated_at, username, dotfiles_git_uri, roles, status, relatime, gpg_key_regenerated_at, _decomissioned, shell -FROM - users -WHERE - id = $1 -LIMIT - 1 -` - -func (q *sqlQuerier) GetUserByID(ctx context.Context, id string) (User, error) { - row := q.db.QueryRowContext(ctx, getUserByID, id) - var i User - err := row.Scan( - &i.ID, - &i.Email, - &i.Name, - &i.Revoked, - &i.LoginType, - &i.HashedPassword, - &i.CreatedAt, - &i.UpdatedAt, - &i.TemporaryPassword, - &i.AvatarHash, - &i.SshKeyRegeneratedAt, - &i.Username, - &i.DotfilesGitUri, - pq.Array(&i.Roles), - &i.Status, - &i.Relatime, - &i.GpgKeyRegeneratedAt, - &i.Decomissioned, - &i.Shell, - ) - return i, err -} - -const getUserCount = `-- name: GetUserCount :one -SELECT - COUNT(*) -FROM - users -` - -func (q *sqlQuerier) GetUserCount(ctx context.Context) (int64, error) { - row := q.db.QueryRowContext(ctx, getUserCount) - var count int64 - err := row.Scan(&count) - return count, err -} - -const insertUser = `-- name: InsertUser :one -INSERT INTO - users ( - id, - email, - "name", - login_type, - revoked, - hashed_password, - created_at, - updated_at, - username - ) -VALUES - ($1, $2, $3, $4, FALSE, $5, $6, $7, $8) RETURNING id, email, name, revoked, login_type, hashed_password, created_at, updated_at, temporary_password, avatar_hash, ssh_key_regenerated_at, username, dotfiles_git_uri, roles, status, relatime, gpg_key_regenerated_at, _decomissioned, shell -` - -type InsertUserParams struct { - ID string `db:"id" json:"id"` - Email string `db:"email" json:"email"` - Name string `db:"name" json:"name"` - LoginType LoginType `db:"login_type" json:"login_type"` - HashedPassword []byte `db:"hashed_password" json:"hashed_password"` - CreatedAt time.Time `db:"created_at" json:"created_at"` - UpdatedAt time.Time `db:"updated_at" json:"updated_at"` - Username string `db:"username" json:"username"` -} - -func (q *sqlQuerier) InsertUser(ctx context.Context, arg InsertUserParams) (User, error) { - row := q.db.QueryRowContext(ctx, insertUser, - arg.ID, - arg.Email, - arg.Name, - arg.LoginType, - arg.HashedPassword, - arg.CreatedAt, - arg.UpdatedAt, - arg.Username, - ) - var i User - err := row.Scan( - &i.ID, - &i.Email, - &i.Name, - &i.Revoked, - &i.LoginType, - &i.HashedPassword, - &i.CreatedAt, - &i.UpdatedAt, - &i.TemporaryPassword, - &i.AvatarHash, - &i.SshKeyRegeneratedAt, - &i.Username, - &i.DotfilesGitUri, - pq.Array(&i.Roles), - &i.Status, - &i.Relatime, - &i.GpgKeyRegeneratedAt, - &i.Decomissioned, - &i.Shell, - ) - return i, err -} diff --git a/coderd/database/workspaceagents.sql.go b/coderd/database/workspaceagents.sql.go deleted file mode 100644 index e0d61981792da..0000000000000 --- a/coderd/database/workspaceagents.sql.go +++ /dev/null @@ -1,198 +0,0 @@ -// Code generated by sqlc. DO NOT EDIT. -// source: workspaceagents.sql - -package database - -import ( - "context" - "database/sql" - "time" - - "github.com/google/uuid" - "github.com/tabbed/pqtype" -) - -const getWorkspaceAgentByAuthToken = `-- name: GetWorkspaceAgentByAuthToken :one -SELECT - id, created_at, updated_at, first_connected_at, last_connected_at, disconnected_at, resource_id, auth_token, auth_instance_id, environment_variables, startup_script, instance_metadata, resource_metadata -FROM - workspace_agents -WHERE - auth_token = $1 -ORDER BY - created_at DESC -` - -func (q *sqlQuerier) GetWorkspaceAgentByAuthToken(ctx context.Context, authToken uuid.UUID) (WorkspaceAgent, error) { - row := q.db.QueryRowContext(ctx, getWorkspaceAgentByAuthToken, authToken) - var i WorkspaceAgent - err := row.Scan( - &i.ID, - &i.CreatedAt, - &i.UpdatedAt, - &i.FirstConnectedAt, - &i.LastConnectedAt, - &i.DisconnectedAt, - &i.ResourceID, - &i.AuthToken, - &i.AuthInstanceID, - &i.EnvironmentVariables, - &i.StartupScript, - &i.InstanceMetadata, - &i.ResourceMetadata, - ) - return i, err -} - -const getWorkspaceAgentByInstanceID = `-- name: GetWorkspaceAgentByInstanceID :one -SELECT - id, created_at, updated_at, first_connected_at, last_connected_at, disconnected_at, resource_id, auth_token, auth_instance_id, environment_variables, startup_script, instance_metadata, resource_metadata -FROM - workspace_agents -WHERE - auth_instance_id = $1 :: TEXT -ORDER BY - created_at DESC -` - -func (q *sqlQuerier) GetWorkspaceAgentByInstanceID(ctx context.Context, authInstanceID string) (WorkspaceAgent, error) { - row := q.db.QueryRowContext(ctx, getWorkspaceAgentByInstanceID, authInstanceID) - var i WorkspaceAgent - err := row.Scan( - &i.ID, - &i.CreatedAt, - &i.UpdatedAt, - &i.FirstConnectedAt, - &i.LastConnectedAt, - &i.DisconnectedAt, - &i.ResourceID, - &i.AuthToken, - &i.AuthInstanceID, - &i.EnvironmentVariables, - &i.StartupScript, - &i.InstanceMetadata, - &i.ResourceMetadata, - ) - return i, err -} - -const getWorkspaceAgentByResourceID = `-- name: GetWorkspaceAgentByResourceID :one -SELECT - id, created_at, updated_at, first_connected_at, last_connected_at, disconnected_at, resource_id, auth_token, auth_instance_id, environment_variables, startup_script, instance_metadata, resource_metadata -FROM - workspace_agents -WHERE - resource_id = $1 -` - -func (q *sqlQuerier) GetWorkspaceAgentByResourceID(ctx context.Context, resourceID uuid.UUID) (WorkspaceAgent, error) { - row := q.db.QueryRowContext(ctx, getWorkspaceAgentByResourceID, resourceID) - var i WorkspaceAgent - err := row.Scan( - &i.ID, - &i.CreatedAt, - &i.UpdatedAt, - &i.FirstConnectedAt, - &i.LastConnectedAt, - &i.DisconnectedAt, - &i.ResourceID, - &i.AuthToken, - &i.AuthInstanceID, - &i.EnvironmentVariables, - &i.StartupScript, - &i.InstanceMetadata, - &i.ResourceMetadata, - ) - return i, err -} - -const insertWorkspaceAgent = `-- name: InsertWorkspaceAgent :one -INSERT INTO - workspace_agents ( - id, - created_at, - updated_at, - resource_id, - auth_token, - auth_instance_id, - environment_variables, - startup_script, - instance_metadata, - resource_metadata - ) -VALUES - ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10) RETURNING id, created_at, updated_at, first_connected_at, last_connected_at, disconnected_at, resource_id, auth_token, auth_instance_id, environment_variables, startup_script, instance_metadata, resource_metadata -` - -type InsertWorkspaceAgentParams struct { - ID uuid.UUID `db:"id" json:"id"` - CreatedAt time.Time `db:"created_at" json:"created_at"` - UpdatedAt time.Time `db:"updated_at" json:"updated_at"` - ResourceID uuid.UUID `db:"resource_id" json:"resource_id"` - AuthToken uuid.UUID `db:"auth_token" json:"auth_token"` - AuthInstanceID sql.NullString `db:"auth_instance_id" json:"auth_instance_id"` - EnvironmentVariables pqtype.NullRawMessage `db:"environment_variables" json:"environment_variables"` - StartupScript sql.NullString `db:"startup_script" json:"startup_script"` - InstanceMetadata pqtype.NullRawMessage `db:"instance_metadata" json:"instance_metadata"` - ResourceMetadata pqtype.NullRawMessage `db:"resource_metadata" json:"resource_metadata"` -} - -func (q *sqlQuerier) InsertWorkspaceAgent(ctx context.Context, arg InsertWorkspaceAgentParams) (WorkspaceAgent, error) { - row := q.db.QueryRowContext(ctx, insertWorkspaceAgent, - arg.ID, - arg.CreatedAt, - arg.UpdatedAt, - arg.ResourceID, - arg.AuthToken, - arg.AuthInstanceID, - arg.EnvironmentVariables, - arg.StartupScript, - arg.InstanceMetadata, - arg.ResourceMetadata, - ) - var i WorkspaceAgent - err := row.Scan( - &i.ID, - &i.CreatedAt, - &i.UpdatedAt, - &i.FirstConnectedAt, - &i.LastConnectedAt, - &i.DisconnectedAt, - &i.ResourceID, - &i.AuthToken, - &i.AuthInstanceID, - &i.EnvironmentVariables, - &i.StartupScript, - &i.InstanceMetadata, - &i.ResourceMetadata, - ) - return i, err -} - -const updateWorkspaceAgentConnectionByID = `-- name: UpdateWorkspaceAgentConnectionByID :exec -UPDATE - workspace_agents -SET - first_connected_at = $2, - last_connected_at = $3, - disconnected_at = $4 -WHERE - id = $1 -` - -type UpdateWorkspaceAgentConnectionByIDParams struct { - ID uuid.UUID `db:"id" json:"id"` - FirstConnectedAt sql.NullTime `db:"first_connected_at" json:"first_connected_at"` - LastConnectedAt sql.NullTime `db:"last_connected_at" json:"last_connected_at"` - DisconnectedAt sql.NullTime `db:"disconnected_at" json:"disconnected_at"` -} - -func (q *sqlQuerier) UpdateWorkspaceAgentConnectionByID(ctx context.Context, arg UpdateWorkspaceAgentConnectionByIDParams) error { - _, err := q.db.ExecContext(ctx, updateWorkspaceAgentConnectionByID, - arg.ID, - arg.FirstConnectedAt, - arg.LastConnectedAt, - arg.DisconnectedAt, - ) - return err -} diff --git a/coderd/database/workspacebuilds.sql.go b/coderd/database/workspacebuilds.sql.go deleted file mode 100644 index 2752db26d43d9..0000000000000 --- a/coderd/database/workspacebuilds.sql.go +++ /dev/null @@ -1,325 +0,0 @@ -// Code generated by sqlc. DO NOT EDIT. -// source: workspacebuilds.sql - -package database - -import ( - "context" - "time" - - "github.com/google/uuid" - "github.com/lib/pq" -) - -const getWorkspaceBuildByID = `-- name: GetWorkspaceBuildByID :one -SELECT - id, created_at, updated_at, workspace_id, project_version_id, name, before_id, after_id, transition, initiator, provisioner_state, job_id -FROM - workspace_builds -WHERE - id = $1 -LIMIT - 1 -` - -func (q *sqlQuerier) GetWorkspaceBuildByID(ctx context.Context, id uuid.UUID) (WorkspaceBuild, error) { - row := q.db.QueryRowContext(ctx, getWorkspaceBuildByID, id) - var i WorkspaceBuild - err := row.Scan( - &i.ID, - &i.CreatedAt, - &i.UpdatedAt, - &i.WorkspaceID, - &i.ProjectVersionID, - &i.Name, - &i.BeforeID, - &i.AfterID, - &i.Transition, - &i.Initiator, - &i.ProvisionerState, - &i.JobID, - ) - return i, err -} - -const getWorkspaceBuildByJobID = `-- name: GetWorkspaceBuildByJobID :one -SELECT - id, created_at, updated_at, workspace_id, project_version_id, name, before_id, after_id, transition, initiator, provisioner_state, job_id -FROM - workspace_builds -WHERE - job_id = $1 -LIMIT - 1 -` - -func (q *sqlQuerier) GetWorkspaceBuildByJobID(ctx context.Context, jobID uuid.UUID) (WorkspaceBuild, error) { - row := q.db.QueryRowContext(ctx, getWorkspaceBuildByJobID, jobID) - var i WorkspaceBuild - err := row.Scan( - &i.ID, - &i.CreatedAt, - &i.UpdatedAt, - &i.WorkspaceID, - &i.ProjectVersionID, - &i.Name, - &i.BeforeID, - &i.AfterID, - &i.Transition, - &i.Initiator, - &i.ProvisionerState, - &i.JobID, - ) - return i, err -} - -const getWorkspaceBuildByWorkspaceID = `-- name: GetWorkspaceBuildByWorkspaceID :many -SELECT - id, created_at, updated_at, workspace_id, project_version_id, name, before_id, after_id, transition, initiator, provisioner_state, job_id -FROM - workspace_builds -WHERE - workspace_id = $1 -` - -func (q *sqlQuerier) GetWorkspaceBuildByWorkspaceID(ctx context.Context, workspaceID uuid.UUID) ([]WorkspaceBuild, error) { - rows, err := q.db.QueryContext(ctx, getWorkspaceBuildByWorkspaceID, workspaceID) - if err != nil { - return nil, err - } - defer rows.Close() - var items []WorkspaceBuild - for rows.Next() { - var i WorkspaceBuild - if err := rows.Scan( - &i.ID, - &i.CreatedAt, - &i.UpdatedAt, - &i.WorkspaceID, - &i.ProjectVersionID, - &i.Name, - &i.BeforeID, - &i.AfterID, - &i.Transition, - &i.Initiator, - &i.ProvisionerState, - &i.JobID, - ); 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 getWorkspaceBuildByWorkspaceIDAndName = `-- name: GetWorkspaceBuildByWorkspaceIDAndName :one -SELECT - id, created_at, updated_at, workspace_id, project_version_id, name, before_id, after_id, transition, initiator, provisioner_state, job_id -FROM - workspace_builds -WHERE - workspace_id = $1 - AND "name" = $2 -` - -type GetWorkspaceBuildByWorkspaceIDAndNameParams struct { - WorkspaceID uuid.UUID `db:"workspace_id" json:"workspace_id"` - Name string `db:"name" json:"name"` -} - -func (q *sqlQuerier) GetWorkspaceBuildByWorkspaceIDAndName(ctx context.Context, arg GetWorkspaceBuildByWorkspaceIDAndNameParams) (WorkspaceBuild, error) { - row := q.db.QueryRowContext(ctx, getWorkspaceBuildByWorkspaceIDAndName, arg.WorkspaceID, arg.Name) - var i WorkspaceBuild - err := row.Scan( - &i.ID, - &i.CreatedAt, - &i.UpdatedAt, - &i.WorkspaceID, - &i.ProjectVersionID, - &i.Name, - &i.BeforeID, - &i.AfterID, - &i.Transition, - &i.Initiator, - &i.ProvisionerState, - &i.JobID, - ) - return i, err -} - -const getWorkspaceBuildByWorkspaceIDWithoutAfter = `-- name: GetWorkspaceBuildByWorkspaceIDWithoutAfter :one -SELECT - id, created_at, updated_at, workspace_id, project_version_id, name, before_id, after_id, transition, initiator, provisioner_state, job_id -FROM - workspace_builds -WHERE - workspace_id = $1 - AND after_id IS NULL -LIMIT - 1 -` - -func (q *sqlQuerier) GetWorkspaceBuildByWorkspaceIDWithoutAfter(ctx context.Context, workspaceID uuid.UUID) (WorkspaceBuild, error) { - row := q.db.QueryRowContext(ctx, getWorkspaceBuildByWorkspaceIDWithoutAfter, workspaceID) - var i WorkspaceBuild - err := row.Scan( - &i.ID, - &i.CreatedAt, - &i.UpdatedAt, - &i.WorkspaceID, - &i.ProjectVersionID, - &i.Name, - &i.BeforeID, - &i.AfterID, - &i.Transition, - &i.Initiator, - &i.ProvisionerState, - &i.JobID, - ) - return i, err -} - -const getWorkspaceBuildsByWorkspaceIDsWithoutAfter = `-- name: GetWorkspaceBuildsByWorkspaceIDsWithoutAfter :many -SELECT - id, created_at, updated_at, workspace_id, project_version_id, name, before_id, after_id, transition, initiator, provisioner_state, job_id -FROM - workspace_builds -WHERE - workspace_id = ANY($1 :: uuid [ ]) - AND after_id IS NULL -` - -func (q *sqlQuerier) GetWorkspaceBuildsByWorkspaceIDsWithoutAfter(ctx context.Context, ids []uuid.UUID) ([]WorkspaceBuild, error) { - rows, err := q.db.QueryContext(ctx, getWorkspaceBuildsByWorkspaceIDsWithoutAfter, pq.Array(ids)) - if err != nil { - return nil, err - } - defer rows.Close() - var items []WorkspaceBuild - for rows.Next() { - var i WorkspaceBuild - if err := rows.Scan( - &i.ID, - &i.CreatedAt, - &i.UpdatedAt, - &i.WorkspaceID, - &i.ProjectVersionID, - &i.Name, - &i.BeforeID, - &i.AfterID, - &i.Transition, - &i.Initiator, - &i.ProvisionerState, - &i.JobID, - ); 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 insertWorkspaceBuild = `-- name: InsertWorkspaceBuild :one -INSERT INTO - workspace_builds ( - id, - created_at, - updated_at, - workspace_id, - project_version_id, - before_id, - "name", - transition, - initiator, - job_id, - provisioner_state - ) -VALUES - ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11) RETURNING id, created_at, updated_at, workspace_id, project_version_id, name, before_id, after_id, transition, initiator, provisioner_state, job_id -` - -type InsertWorkspaceBuildParams struct { - ID uuid.UUID `db:"id" json:"id"` - CreatedAt time.Time `db:"created_at" json:"created_at"` - UpdatedAt time.Time `db:"updated_at" json:"updated_at"` - WorkspaceID uuid.UUID `db:"workspace_id" json:"workspace_id"` - ProjectVersionID uuid.UUID `db:"project_version_id" json:"project_version_id"` - BeforeID uuid.NullUUID `db:"before_id" json:"before_id"` - Name string `db:"name" json:"name"` - Transition WorkspaceTransition `db:"transition" json:"transition"` - Initiator string `db:"initiator" json:"initiator"` - JobID uuid.UUID `db:"job_id" json:"job_id"` - ProvisionerState []byte `db:"provisioner_state" json:"provisioner_state"` -} - -func (q *sqlQuerier) InsertWorkspaceBuild(ctx context.Context, arg InsertWorkspaceBuildParams) (WorkspaceBuild, error) { - row := q.db.QueryRowContext(ctx, insertWorkspaceBuild, - arg.ID, - arg.CreatedAt, - arg.UpdatedAt, - arg.WorkspaceID, - arg.ProjectVersionID, - arg.BeforeID, - arg.Name, - arg.Transition, - arg.Initiator, - arg.JobID, - arg.ProvisionerState, - ) - var i WorkspaceBuild - err := row.Scan( - &i.ID, - &i.CreatedAt, - &i.UpdatedAt, - &i.WorkspaceID, - &i.ProjectVersionID, - &i.Name, - &i.BeforeID, - &i.AfterID, - &i.Transition, - &i.Initiator, - &i.ProvisionerState, - &i.JobID, - ) - return i, err -} - -const updateWorkspaceBuildByID = `-- name: UpdateWorkspaceBuildByID :exec -UPDATE - workspace_builds -SET - updated_at = $2, - after_id = $3, - provisioner_state = $4 -WHERE - id = $1 -` - -type UpdateWorkspaceBuildByIDParams struct { - ID uuid.UUID `db:"id" json:"id"` - UpdatedAt time.Time `db:"updated_at" json:"updated_at"` - AfterID uuid.NullUUID `db:"after_id" json:"after_id"` - ProvisionerState []byte `db:"provisioner_state" json:"provisioner_state"` -} - -func (q *sqlQuerier) UpdateWorkspaceBuildByID(ctx context.Context, arg UpdateWorkspaceBuildByIDParams) error { - _, err := q.db.ExecContext(ctx, updateWorkspaceBuildByID, - arg.ID, - arg.UpdatedAt, - arg.AfterID, - arg.ProvisionerState, - ) - return err -} diff --git a/coderd/database/workspaceresources.sql.go b/coderd/database/workspaceresources.sql.go deleted file mode 100644 index 78c11570d4737..0000000000000 --- a/coderd/database/workspaceresources.sql.go +++ /dev/null @@ -1,129 +0,0 @@ -// Code generated by sqlc. DO NOT EDIT. -// source: workspaceresources.sql - -package database - -import ( - "context" - "time" - - "github.com/google/uuid" -) - -const getWorkspaceResourceByID = `-- name: GetWorkspaceResourceByID :one -SELECT - id, created_at, job_id, transition, address, type, name, agent_id -FROM - workspace_resources -WHERE - id = $1 -` - -func (q *sqlQuerier) GetWorkspaceResourceByID(ctx context.Context, id uuid.UUID) (WorkspaceResource, error) { - row := q.db.QueryRowContext(ctx, getWorkspaceResourceByID, id) - var i WorkspaceResource - err := row.Scan( - &i.ID, - &i.CreatedAt, - &i.JobID, - &i.Transition, - &i.Address, - &i.Type, - &i.Name, - &i.AgentID, - ) - return i, err -} - -const getWorkspaceResourcesByJobID = `-- name: GetWorkspaceResourcesByJobID :many -SELECT - id, created_at, job_id, transition, address, type, name, agent_id -FROM - workspace_resources -WHERE - job_id = $1 -` - -func (q *sqlQuerier) GetWorkspaceResourcesByJobID(ctx context.Context, jobID uuid.UUID) ([]WorkspaceResource, error) { - rows, err := q.db.QueryContext(ctx, getWorkspaceResourcesByJobID, jobID) - if err != nil { - return nil, err - } - defer rows.Close() - var items []WorkspaceResource - for rows.Next() { - var i WorkspaceResource - if err := rows.Scan( - &i.ID, - &i.CreatedAt, - &i.JobID, - &i.Transition, - &i.Address, - &i.Type, - &i.Name, - &i.AgentID, - ); 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 insertWorkspaceResource = `-- name: InsertWorkspaceResource :one -INSERT INTO - workspace_resources ( - id, - created_at, - job_id, - transition, - address, - type, - name, - agent_id - ) -VALUES - ($1, $2, $3, $4, $5, $6, $7, $8) RETURNING id, created_at, job_id, transition, address, type, name, agent_id -` - -type InsertWorkspaceResourceParams struct { - ID uuid.UUID `db:"id" json:"id"` - CreatedAt time.Time `db:"created_at" json:"created_at"` - JobID uuid.UUID `db:"job_id" json:"job_id"` - Transition WorkspaceTransition `db:"transition" json:"transition"` - Address string `db:"address" json:"address"` - Type string `db:"type" json:"type"` - Name string `db:"name" json:"name"` - AgentID uuid.NullUUID `db:"agent_id" json:"agent_id"` -} - -func (q *sqlQuerier) InsertWorkspaceResource(ctx context.Context, arg InsertWorkspaceResourceParams) (WorkspaceResource, error) { - row := q.db.QueryRowContext(ctx, insertWorkspaceResource, - arg.ID, - arg.CreatedAt, - arg.JobID, - arg.Transition, - arg.Address, - arg.Type, - arg.Name, - arg.AgentID, - ) - var i WorkspaceResource - err := row.Scan( - &i.ID, - &i.CreatedAt, - &i.JobID, - &i.Transition, - &i.Address, - &i.Type, - &i.Name, - &i.AgentID, - ) - return i, err -} diff --git a/coderd/database/workspaces.sql.go b/coderd/database/workspaces.sql.go deleted file mode 100644 index 38584e4cdd308..0000000000000 --- a/coderd/database/workspaces.sql.go +++ /dev/null @@ -1,267 +0,0 @@ -// Code generated by sqlc. DO NOT EDIT. -// source: workspaces.sql - -package database - -import ( - "context" - "time" - - "github.com/google/uuid" - "github.com/lib/pq" -) - -const getWorkspaceByID = `-- name: GetWorkspaceByID :one -SELECT - id, created_at, updated_at, owner_id, project_id, deleted, name -FROM - workspaces -WHERE - id = $1 -LIMIT - 1 -` - -func (q *sqlQuerier) GetWorkspaceByID(ctx context.Context, id uuid.UUID) (Workspace, error) { - row := q.db.QueryRowContext(ctx, getWorkspaceByID, id) - var i Workspace - err := row.Scan( - &i.ID, - &i.CreatedAt, - &i.UpdatedAt, - &i.OwnerID, - &i.ProjectID, - &i.Deleted, - &i.Name, - ) - return i, err -} - -const getWorkspaceByUserIDAndName = `-- name: GetWorkspaceByUserIDAndName :one -SELECT - id, created_at, updated_at, owner_id, project_id, deleted, name -FROM - workspaces -WHERE - owner_id = $1 - AND deleted = $2 - AND LOWER("name") = LOWER($3) -` - -type GetWorkspaceByUserIDAndNameParams struct { - OwnerID string `db:"owner_id" json:"owner_id"` - Deleted bool `db:"deleted" json:"deleted"` - Name string `db:"name" json:"name"` -} - -func (q *sqlQuerier) GetWorkspaceByUserIDAndName(ctx context.Context, arg GetWorkspaceByUserIDAndNameParams) (Workspace, error) { - row := q.db.QueryRowContext(ctx, getWorkspaceByUserIDAndName, arg.OwnerID, arg.Deleted, arg.Name) - var i Workspace - err := row.Scan( - &i.ID, - &i.CreatedAt, - &i.UpdatedAt, - &i.OwnerID, - &i.ProjectID, - &i.Deleted, - &i.Name, - ) - return i, err -} - -const getWorkspaceOwnerCountsByProjectIDs = `-- name: GetWorkspaceOwnerCountsByProjectIDs :many -SELECT - project_id, - COUNT(DISTINCT owner_id) -FROM - workspaces -WHERE - project_id = ANY($1 :: uuid [ ]) -GROUP BY - project_id, - owner_id -` - -type GetWorkspaceOwnerCountsByProjectIDsRow struct { - ProjectID uuid.UUID `db:"project_id" json:"project_id"` - Count int64 `db:"count" json:"count"` -} - -func (q *sqlQuerier) GetWorkspaceOwnerCountsByProjectIDs(ctx context.Context, ids []uuid.UUID) ([]GetWorkspaceOwnerCountsByProjectIDsRow, error) { - rows, err := q.db.QueryContext(ctx, getWorkspaceOwnerCountsByProjectIDs, pq.Array(ids)) - if err != nil { - return nil, err - } - defer rows.Close() - var items []GetWorkspaceOwnerCountsByProjectIDsRow - for rows.Next() { - var i GetWorkspaceOwnerCountsByProjectIDsRow - if err := rows.Scan(&i.ProjectID, &i.Count); 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 getWorkspacesByProjectID = `-- name: GetWorkspacesByProjectID :many -SELECT - id, created_at, updated_at, owner_id, project_id, deleted, name -FROM - workspaces -WHERE - project_id = $1 - AND deleted = $2 -` - -type GetWorkspacesByProjectIDParams struct { - ProjectID uuid.UUID `db:"project_id" json:"project_id"` - Deleted bool `db:"deleted" json:"deleted"` -} - -func (q *sqlQuerier) GetWorkspacesByProjectID(ctx context.Context, arg GetWorkspacesByProjectIDParams) ([]Workspace, error) { - rows, err := q.db.QueryContext(ctx, getWorkspacesByProjectID, arg.ProjectID, arg.Deleted) - if err != nil { - return nil, err - } - defer rows.Close() - var items []Workspace - for rows.Next() { - var i Workspace - if err := rows.Scan( - &i.ID, - &i.CreatedAt, - &i.UpdatedAt, - &i.OwnerID, - &i.ProjectID, - &i.Deleted, - &i.Name, - ); 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 getWorkspacesByUserID = `-- name: GetWorkspacesByUserID :many -SELECT - id, created_at, updated_at, owner_id, project_id, deleted, name -FROM - workspaces -WHERE - owner_id = $1 - AND deleted = $2 -` - -type GetWorkspacesByUserIDParams struct { - OwnerID string `db:"owner_id" json:"owner_id"` - Deleted bool `db:"deleted" json:"deleted"` -} - -func (q *sqlQuerier) GetWorkspacesByUserID(ctx context.Context, arg GetWorkspacesByUserIDParams) ([]Workspace, error) { - rows, err := q.db.QueryContext(ctx, getWorkspacesByUserID, arg.OwnerID, arg.Deleted) - if err != nil { - return nil, err - } - defer rows.Close() - var items []Workspace - for rows.Next() { - var i Workspace - if err := rows.Scan( - &i.ID, - &i.CreatedAt, - &i.UpdatedAt, - &i.OwnerID, - &i.ProjectID, - &i.Deleted, - &i.Name, - ); 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 insertWorkspace = `-- name: InsertWorkspace :one -INSERT INTO - workspaces ( - id, - created_at, - updated_at, - owner_id, - project_id, - name - ) -VALUES - ($1, $2, $3, $4, $5, $6) RETURNING id, created_at, updated_at, owner_id, project_id, deleted, name -` - -type InsertWorkspaceParams struct { - ID uuid.UUID `db:"id" json:"id"` - CreatedAt time.Time `db:"created_at" json:"created_at"` - UpdatedAt time.Time `db:"updated_at" json:"updated_at"` - OwnerID string `db:"owner_id" json:"owner_id"` - ProjectID uuid.UUID `db:"project_id" json:"project_id"` - Name string `db:"name" json:"name"` -} - -func (q *sqlQuerier) InsertWorkspace(ctx context.Context, arg InsertWorkspaceParams) (Workspace, error) { - row := q.db.QueryRowContext(ctx, insertWorkspace, - arg.ID, - arg.CreatedAt, - arg.UpdatedAt, - arg.OwnerID, - arg.ProjectID, - arg.Name, - ) - var i Workspace - err := row.Scan( - &i.ID, - &i.CreatedAt, - &i.UpdatedAt, - &i.OwnerID, - &i.ProjectID, - &i.Deleted, - &i.Name, - ) - return i, err -} - -const updateWorkspaceDeletedByID = `-- name: UpdateWorkspaceDeletedByID :exec -UPDATE - workspaces -SET - deleted = $2 -WHERE - id = $1 -` - -type UpdateWorkspaceDeletedByIDParams struct { - ID uuid.UUID `db:"id" json:"id"` - Deleted bool `db:"deleted" json:"deleted"` -} - -func (q *sqlQuerier) UpdateWorkspaceDeletedByID(ctx context.Context, arg UpdateWorkspaceDeletedByIDParams) error { - _, err := q.db.ExecContext(ctx, updateWorkspaceDeletedByID, arg.ID, arg.Deleted) - return err -} diff --git a/go.mod b/go.mod index 9594fa2e37411..2a96acb125815 100644 --- a/go.mod +++ b/go.mod @@ -40,6 +40,7 @@ require ( github.com/briandowns/spinner v1.18.1 github.com/charmbracelet/charm v0.11.0 github.com/charmbracelet/lipgloss v0.5.0 + github.com/cli/safeexec v1.0.0 github.com/cloudflare/cloudflared v0.0.0-20220308214351-5352b3cf0489 github.com/coder/retry v1.3.0 github.com/coreos/go-systemd v0.0.0-20191104093116-d3cd4ed1dbcf @@ -93,8 +94,6 @@ require ( storj.io/drpc v0.0.30 ) -require github.com/cli/safeexec v1.0.0 - require ( github.com/Azure/go-ansiterm v0.0.0-20210617225240-d185dfc1b5a1 // indirect github.com/BurntSushi/toml v1.0.0 // indirect From 2ef8d8a88c4b33cf759617ceb116da9c30d0449e Mon Sep 17 00:00:00 2001 From: Colin Adler Date: Thu, 31 Mar 2022 16:47:26 -0500 Subject: [PATCH 4/9] install goimports --- .github/workflows/coder.yaml | 1 + 1 file changed, 1 insertion(+) diff --git a/.github/workflows/coder.yaml b/.github/workflows/coder.yaml index 8c1b36cc92bae..366553bcc0b86 100644 --- a/.github/workflows/coder.yaml +++ b/.github/workflows/coder.yaml @@ -89,6 +89,7 @@ jobs: - run: go install google.golang.org/protobuf/cmd/protoc-gen-go@v1.26 - run: go install storj.io/drpc/cmd/protoc-gen-go-drpc@v0.0.26 + - run: go install golang.org/x/tools/cmd/goimports@latest - run: "make --output-sync -j gen" - run: ./scripts/check_unstaged.sh From 7e32318d7dfeed3e80695e0bacc28873f68dcce1 Mon Sep 17 00:00:00 2001 From: Colin Adler Date: Thu, 31 Mar 2022 16:50:58 -0500 Subject: [PATCH 5/9] comment generate.sh --- coderd/database/generate.sh | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/coderd/database/generate.sh b/coderd/database/generate.sh index 20268098cb3de..612b983f343b2 100755 --- a/coderd/database/generate.sh +++ b/coderd/database/generate.sh @@ -8,19 +8,26 @@ sqlc generate first=true for fi in queries/*.sql.go; do + # Find the last line from the imports section and add 1. cut=$(grep -n ')' "$fi" | head -n 1 | cut -d: -f1) cut=$((cut + 1)) + # Copy the header from the first file only, ignoring the source comment. if $first; then head -n 4 < "$fi" | grep -v "source" > queries.sql.go first=false fi + # Append the file past the imports section into queries.sql.go. tail -n "+$cut" < "$fi" >> queries.sql.go done +# Remove temporary go files. rm -f queries/*.go +# Ensure correct imports exist. goimports -w queries.sql.go + +# Fix struct/interface names. gofmt -w -r 'Querier -> querier' -- *.go gofmt -w -r 'Queries -> sqlQuerier' -- *.go From 5aeb544752783c6a79488287f903bb059983b621 Mon Sep 17 00:00:00 2001 From: Colin Adler Date: Thu, 31 Mar 2022 16:52:13 -0500 Subject: [PATCH 6/9] try go mod tidy --- coderd/database/generate.sh | 1 + 1 file changed, 1 insertion(+) diff --git a/coderd/database/generate.sh b/coderd/database/generate.sh index 612b983f343b2..fd9089dc9fc9a 100755 --- a/coderd/database/generate.sh +++ b/coderd/database/generate.sh @@ -25,6 +25,7 @@ done # Remove temporary go files. rm -f queries/*.go +go mod tidy # Ensure correct imports exist. goimports -w queries.sql.go From 449abba5e126cf1d6e042e7b2ee5128fae848b2f Mon Sep 17 00:00:00 2001 From: Colin Adler Date: Thu, 31 Mar 2022 16:55:16 -0500 Subject: [PATCH 7/9] mod download instead --- coderd/database/generate.sh | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/coderd/database/generate.sh b/coderd/database/generate.sh index fd9089dc9fc9a..e3fab7b7c907e 100755 --- a/coderd/database/generate.sh +++ b/coderd/database/generate.sh @@ -25,8 +25,9 @@ done # Remove temporary go files. rm -f queries/*.go -go mod tidy -# Ensure correct imports exist. +# Ensure correct imports exist. Modules must all be downloaded so we get correct +# suggestions. +go mod download goimports -w queries.sql.go # Fix struct/interface names. From 303297cc9815869ee7cb22fa8f3a493d6be03881 Mon Sep 17 00:00:00 2001 From: Colin Adler Date: Fri, 1 Apr 2022 14:52:00 -0500 Subject: [PATCH 8/9] fix schema --- coderd/database/dump.sql | 4 +- coderd/database/generate.sh | 8 +- coderd/database/queries.sql.go | 166 ++++++++++++--------------------- 3 files changed, 64 insertions(+), 114 deletions(-) diff --git a/coderd/database/dump.sql b/coderd/database/dump.sql index 548b1b93d1e75..3ee32b5f98d07 100644 --- a/coderd/database/dump.sql +++ b/coderd/database/dump.sql @@ -362,12 +362,12 @@ CREATE UNIQUE INDEX idx_organization_name ON organizations USING btree (name); CREATE UNIQUE INDEX idx_organization_name_lower ON organizations USING btree (lower(name)); +CREATE UNIQUE INDEX idx_projects_name_lower ON projects USING btree (lower((name)::text)); + CREATE UNIQUE INDEX idx_users_email ON users USING btree (email); CREATE UNIQUE INDEX idx_users_username ON users USING btree (username); -CREATE UNIQUE INDEX idx_projects_name_lower ON projects USING btree (lower((name)::text)); - CREATE UNIQUE INDEX idx_workspaces_name_lower ON workspaces USING btree (lower((name)::text)); CREATE UNIQUE INDEX projects_organization_id_name_idx ON projects USING btree (organization_id, name) WHERE (deleted = false); diff --git a/coderd/database/generate.sh b/coderd/database/generate.sh index e3fab7b7c907e..96234494edfed 100755 --- a/coderd/database/generate.sh +++ b/coderd/database/generate.sh @@ -25,11 +25,11 @@ done # Remove temporary go files. rm -f queries/*.go +# Fix struct/interface names. +gofmt -w -r 'Querier -> querier' -- *.go +gofmt -w -r 'Queries -> sqlQuerier' -- *.go + # Ensure correct imports exist. Modules must all be downloaded so we get correct # suggestions. go mod download goimports -w queries.sql.go - -# Fix struct/interface names. -gofmt -w -r 'Querier -> querier' -- *.go -gofmt -w -r 'Queries -> sqlQuerier' -- *.go diff --git a/coderd/database/queries.sql.go b/coderd/database/queries.sql.go index 5bd2d11aae83c..49f0669143f38 100644 --- a/coderd/database/queries.sql.go +++ b/coderd/database/queries.sql.go @@ -89,7 +89,7 @@ VALUES type InsertAPIKeyParams struct { ID string `db:"id" json:"id"` HashedSecret []byte `db:"hashed_secret" json:"hashed_secret"` - UserID string `db:"user_id" json:"user_id"` + UserID uuid.UUID `db:"user_id" json:"user_id"` Application bool `db:"application" json:"application"` Name string `db:"name" json:"name"` LastUsed time.Time `db:"last_used" json:"last_used"` @@ -211,7 +211,7 @@ VALUES type InsertFileParams struct { Hash string `db:"hash" json:"hash"` CreatedAt time.Time `db:"created_at" json:"created_at"` - CreatedBy string `db:"created_by" json:"created_by"` + CreatedBy uuid.UUID `db:"created_by" json:"created_by"` Mimetype string `db:"mimetype" json:"mimetype"` Data []byte `db:"data" json:"data"` } @@ -237,7 +237,7 @@ func (q *sqlQuerier) InsertFile(ctx context.Context, arg InsertFileParams) (File const getOrganizationMemberByUserID = `-- name: GetOrganizationMemberByUserID :one SELECT - organization_id, user_id, created_at, updated_at, roles + user_id, organization_id, created_at, updated_at, roles FROM organization_members WHERE @@ -248,16 +248,16 @@ LIMIT ` type GetOrganizationMemberByUserIDParams struct { - OrganizationID string `db:"organization_id" json:"organization_id"` - UserID string `db:"user_id" json:"user_id"` + OrganizationID uuid.UUID `db:"organization_id" json:"organization_id"` + UserID uuid.UUID `db:"user_id" json:"user_id"` } func (q *sqlQuerier) GetOrganizationMemberByUserID(ctx context.Context, arg GetOrganizationMemberByUserIDParams) (OrganizationMember, error) { row := q.db.QueryRowContext(ctx, getOrganizationMemberByUserID, arg.OrganizationID, arg.UserID) var i OrganizationMember err := row.Scan( - &i.OrganizationID, &i.UserID, + &i.OrganizationID, &i.CreatedAt, &i.UpdatedAt, pq.Array(&i.Roles), @@ -275,12 +275,12 @@ INSERT INTO roles ) VALUES - ($1, $2, $3, $4, $5) RETURNING organization_id, user_id, created_at, updated_at, roles + ($1, $2, $3, $4, $5) RETURNING user_id, organization_id, created_at, updated_at, roles ` type InsertOrganizationMemberParams struct { - OrganizationID string `db:"organization_id" json:"organization_id"` - UserID string `db:"user_id" json:"user_id"` + OrganizationID uuid.UUID `db:"organization_id" json:"organization_id"` + UserID uuid.UUID `db:"user_id" json:"user_id"` CreatedAt time.Time `db:"created_at" json:"created_at"` UpdatedAt time.Time `db:"updated_at" json:"updated_at"` Roles []string `db:"roles" json:"roles"` @@ -296,8 +296,8 @@ func (q *sqlQuerier) InsertOrganizationMember(ctx context.Context, arg InsertOrg ) var i OrganizationMember err := row.Scan( - &i.OrganizationID, &i.UserID, + &i.OrganizationID, &i.CreatedAt, &i.UpdatedAt, pq.Array(&i.Roles), @@ -307,14 +307,14 @@ func (q *sqlQuerier) InsertOrganizationMember(ctx context.Context, arg InsertOrg const getOrganizationByID = `-- name: GetOrganizationByID :one SELECT - id, name, description, created_at, updated_at, "default", auto_off_threshold, cpu_provisioning_rate, memory_provisioning_rate, workspace_auto_off + id, name, description, created_at, updated_at FROM organizations WHERE id = $1 ` -func (q *sqlQuerier) GetOrganizationByID(ctx context.Context, id string) (Organization, error) { +func (q *sqlQuerier) GetOrganizationByID(ctx context.Context, id uuid.UUID) (Organization, error) { row := q.db.QueryRowContext(ctx, getOrganizationByID, id) var i Organization err := row.Scan( @@ -323,18 +323,13 @@ func (q *sqlQuerier) GetOrganizationByID(ctx context.Context, id string) (Organi &i.Description, &i.CreatedAt, &i.UpdatedAt, - &i.Default, - &i.AutoOffThreshold, - &i.CpuProvisioningRate, - &i.MemoryProvisioningRate, - &i.WorkspaceAutoOff, ) return i, err } const getOrganizationByName = `-- name: GetOrganizationByName :one SELECT - id, name, description, created_at, updated_at, "default", auto_off_threshold, cpu_provisioning_rate, memory_provisioning_rate, workspace_auto_off + id, name, description, created_at, updated_at FROM organizations WHERE @@ -352,18 +347,13 @@ func (q *sqlQuerier) GetOrganizationByName(ctx context.Context, name string) (Or &i.Description, &i.CreatedAt, &i.UpdatedAt, - &i.Default, - &i.AutoOffThreshold, - &i.CpuProvisioningRate, - &i.MemoryProvisioningRate, - &i.WorkspaceAutoOff, ) return i, err } const getOrganizationsByUserID = `-- name: GetOrganizationsByUserID :many SELECT - id, name, description, created_at, updated_at, "default", auto_off_threshold, cpu_provisioning_rate, memory_provisioning_rate, workspace_auto_off + id, name, description, created_at, updated_at FROM organizations WHERE @@ -377,7 +367,7 @@ WHERE ) ` -func (q *sqlQuerier) GetOrganizationsByUserID(ctx context.Context, userID string) ([]Organization, error) { +func (q *sqlQuerier) GetOrganizationsByUserID(ctx context.Context, userID uuid.UUID) ([]Organization, error) { rows, err := q.db.QueryContext(ctx, getOrganizationsByUserID, userID) if err != nil { return nil, err @@ -392,11 +382,6 @@ func (q *sqlQuerier) GetOrganizationsByUserID(ctx context.Context, userID string &i.Description, &i.CreatedAt, &i.UpdatedAt, - &i.Default, - &i.AutoOffThreshold, - &i.CpuProvisioningRate, - &i.MemoryProvisioningRate, - &i.WorkspaceAutoOff, ); err != nil { return nil, err } @@ -415,11 +400,11 @@ const insertOrganization = `-- name: InsertOrganization :one INSERT INTO organizations (id, "name", description, created_at, updated_at) VALUES - ($1, $2, $3, $4, $5) RETURNING id, name, description, created_at, updated_at, "default", auto_off_threshold, cpu_provisioning_rate, memory_provisioning_rate, workspace_auto_off + ($1, $2, $3, $4, $5) RETURNING id, name, description, created_at, updated_at ` type InsertOrganizationParams struct { - ID string `db:"id" json:"id"` + ID uuid.UUID `db:"id" json:"id"` Name string `db:"name" json:"name"` Description string `db:"description" json:"description"` CreatedAt time.Time `db:"created_at" json:"created_at"` @@ -441,11 +426,6 @@ func (q *sqlQuerier) InsertOrganization(ctx context.Context, arg InsertOrganizat &i.Description, &i.CreatedAt, &i.UpdatedAt, - &i.Default, - &i.AutoOffThreshold, - &i.CpuProvisioningRate, - &i.MemoryProvisioningRate, - &i.WorkspaceAutoOff, ) return i, err } @@ -627,7 +607,7 @@ LIMIT type GetParameterValueByScopeAndNameParams struct { Scope ParameterScope `db:"scope" json:"scope"` - ScopeID string `db:"scope_id" json:"scope_id"` + ScopeID uuid.UUID `db:"scope_id" json:"scope_id"` Name string `db:"name" json:"name"` } @@ -660,7 +640,7 @@ WHERE type GetParameterValuesByScopeParams struct { Scope ParameterScope `db:"scope" json:"scope"` - ScopeID string `db:"scope_id" json:"scope_id"` + ScopeID uuid.UUID `db:"scope_id" json:"scope_id"` } func (q *sqlQuerier) GetParameterValuesByScope(ctx context.Context, arg GetParameterValuesByScopeParams) ([]ParameterValue, error) { @@ -719,7 +699,7 @@ type InsertParameterValueParams struct { CreatedAt time.Time `db:"created_at" json:"created_at"` UpdatedAt time.Time `db:"updated_at" json:"updated_at"` Scope ParameterScope `db:"scope" json:"scope"` - ScopeID string `db:"scope_id" json:"scope_id"` + ScopeID uuid.UUID `db:"scope_id" json:"scope_id"` SourceScheme ParameterSourceScheme `db:"source_scheme" json:"source_scheme"` SourceValue string `db:"source_value" json:"source_value"` DestinationScheme ParameterDestinationScheme `db:"destination_scheme" json:"destination_scheme"` @@ -793,9 +773,9 @@ LIMIT ` type GetProjectByOrganizationAndNameParams struct { - OrganizationID string `db:"organization_id" json:"organization_id"` - Deleted bool `db:"deleted" json:"deleted"` - Name string `db:"name" json:"name"` + OrganizationID uuid.UUID `db:"organization_id" json:"organization_id"` + Deleted bool `db:"deleted" json:"deleted"` + Name string `db:"name" json:"name"` } func (q *sqlQuerier) GetProjectByOrganizationAndName(ctx context.Context, arg GetProjectByOrganizationAndNameParams) (Project, error) { @@ -866,8 +846,8 @@ WHERE ` type GetProjectsByOrganizationParams struct { - OrganizationID string `db:"organization_id" json:"organization_id"` - Deleted bool `db:"deleted" json:"deleted"` + OrganizationID uuid.UUID `db:"organization_id" json:"organization_id"` + Deleted bool `db:"deleted" json:"deleted"` } func (q *sqlQuerier) GetProjectsByOrganization(ctx context.Context, arg GetProjectsByOrganizationParams) ([]Project, error) { @@ -921,7 +901,7 @@ type InsertProjectParams struct { ID uuid.UUID `db:"id" json:"id"` CreatedAt time.Time `db:"created_at" json:"created_at"` UpdatedAt time.Time `db:"updated_at" json:"updated_at"` - OrganizationID string `db:"organization_id" json:"organization_id"` + OrganizationID uuid.UUID `db:"organization_id" json:"organization_id"` Name string `db:"name" json:"name"` Provisioner ProvisionerType `db:"provisioner" json:"provisioner"` ActiveVersionID uuid.UUID `db:"active_version_id" json:"active_version_id"` @@ -1130,7 +1110,7 @@ VALUES type InsertProjectVersionParams struct { ID uuid.UUID `db:"id" json:"id"` ProjectID uuid.NullUUID `db:"project_id" json:"project_id"` - OrganizationID string `db:"organization_id" json:"organization_id"` + OrganizationID uuid.UUID `db:"organization_id" json:"organization_id"` CreatedAt time.Time `db:"created_at" json:"created_at"` UpdatedAt time.Time `db:"updated_at" json:"updated_at"` Name string `db:"name" json:"name"` @@ -1260,7 +1240,7 @@ VALUES type InsertProvisionerDaemonParams struct { ID uuid.UUID `db:"id" json:"id"` CreatedAt time.Time `db:"created_at" json:"created_at"` - OrganizationID sql.NullString `db:"organization_id" json:"organization_id"` + OrganizationID uuid.NullUUID `db:"organization_id" json:"organization_id"` Name string `db:"name" json:"name"` Provisioners []ProvisionerType `db:"provisioners" json:"provisioners"` } @@ -1584,8 +1564,8 @@ type InsertProvisionerJobParams struct { ID uuid.UUID `db:"id" json:"id"` CreatedAt time.Time `db:"created_at" json:"created_at"` UpdatedAt time.Time `db:"updated_at" json:"updated_at"` - OrganizationID string `db:"organization_id" json:"organization_id"` - InitiatorID string `db:"initiator_id" json:"initiator_id"` + OrganizationID uuid.UUID `db:"organization_id" json:"organization_id"` + InitiatorID uuid.UUID `db:"initiator_id" json:"initiator_id"` Provisioner ProvisionerType `db:"provisioner" json:"provisioner"` StorageMethod ProvisionerStorageMethod `db:"storage_method" json:"storage_method"` StorageSource string `db:"storage_source" json:"storage_source"` @@ -1695,7 +1675,7 @@ func (q *sqlQuerier) UpdateProvisionerJobWithCompleteByID(ctx context.Context, a const getUserByEmailOrUsername = `-- name: GetUserByEmailOrUsername :one SELECT - id, email, name, revoked, login_type, hashed_password, created_at, updated_at, temporary_password, avatar_hash, ssh_key_regenerated_at, username, dotfiles_git_uri, roles, status, relatime, gpg_key_regenerated_at, _decomissioned, shell + id, email, name, revoked, login_type, hashed_password, created_at, updated_at, username FROM users WHERE @@ -1722,24 +1702,14 @@ func (q *sqlQuerier) GetUserByEmailOrUsername(ctx context.Context, arg GetUserBy &i.HashedPassword, &i.CreatedAt, &i.UpdatedAt, - &i.TemporaryPassword, - &i.AvatarHash, - &i.SshKeyRegeneratedAt, &i.Username, - &i.DotfilesGitUri, - pq.Array(&i.Roles), - &i.Status, - &i.Relatime, - &i.GpgKeyRegeneratedAt, - &i.Decomissioned, - &i.Shell, ) return i, err } const getUserByID = `-- name: GetUserByID :one SELECT - id, email, name, revoked, login_type, hashed_password, created_at, updated_at, temporary_password, avatar_hash, ssh_key_regenerated_at, username, dotfiles_git_uri, roles, status, relatime, gpg_key_regenerated_at, _decomissioned, shell + id, email, name, revoked, login_type, hashed_password, created_at, updated_at, username FROM users WHERE @@ -1748,7 +1718,7 @@ LIMIT 1 ` -func (q *sqlQuerier) GetUserByID(ctx context.Context, id string) (User, error) { +func (q *sqlQuerier) GetUserByID(ctx context.Context, id uuid.UUID) (User, error) { row := q.db.QueryRowContext(ctx, getUserByID, id) var i User err := row.Scan( @@ -1760,17 +1730,7 @@ func (q *sqlQuerier) GetUserByID(ctx context.Context, id string) (User, error) { &i.HashedPassword, &i.CreatedAt, &i.UpdatedAt, - &i.TemporaryPassword, - &i.AvatarHash, - &i.SshKeyRegeneratedAt, &i.Username, - &i.DotfilesGitUri, - pq.Array(&i.Roles), - &i.Status, - &i.Relatime, - &i.GpgKeyRegeneratedAt, - &i.Decomissioned, - &i.Shell, ) return i, err } @@ -1803,11 +1763,11 @@ INSERT INTO username ) VALUES - ($1, $2, $3, $4, FALSE, $5, $6, $7, $8) RETURNING id, email, name, revoked, login_type, hashed_password, created_at, updated_at, temporary_password, avatar_hash, ssh_key_regenerated_at, username, dotfiles_git_uri, roles, status, relatime, gpg_key_regenerated_at, _decomissioned, shell + ($1, $2, $3, $4, FALSE, $5, $6, $7, $8) RETURNING id, email, name, revoked, login_type, hashed_password, created_at, updated_at, username ` type InsertUserParams struct { - ID string `db:"id" json:"id"` + ID uuid.UUID `db:"id" json:"id"` Email string `db:"email" json:"email"` Name string `db:"name" json:"name"` LoginType LoginType `db:"login_type" json:"login_type"` @@ -1838,17 +1798,7 @@ func (q *sqlQuerier) InsertUser(ctx context.Context, arg InsertUserParams) (User &i.HashedPassword, &i.CreatedAt, &i.UpdatedAt, - &i.TemporaryPassword, - &i.AvatarHash, - &i.SshKeyRegeneratedAt, &i.Username, - &i.DotfilesGitUri, - pq.Array(&i.Roles), - &i.Status, - &i.Relatime, - &i.GpgKeyRegeneratedAt, - &i.Decomissioned, - &i.Shell, ) return i, err } @@ -2040,7 +1990,7 @@ func (q *sqlQuerier) UpdateWorkspaceAgentConnectionByID(ctx context.Context, arg const getWorkspaceBuildByID = `-- name: GetWorkspaceBuildByID :one SELECT - id, created_at, updated_at, workspace_id, project_version_id, name, before_id, after_id, transition, initiator, provisioner_state, job_id + id, created_at, updated_at, workspace_id, project_version_id, name, before_id, after_id, transition, initiator_id, provisioner_state, job_id FROM workspace_builds WHERE @@ -2062,7 +2012,7 @@ func (q *sqlQuerier) GetWorkspaceBuildByID(ctx context.Context, id uuid.UUID) (W &i.BeforeID, &i.AfterID, &i.Transition, - &i.Initiator, + &i.InitiatorID, &i.ProvisionerState, &i.JobID, ) @@ -2071,7 +2021,7 @@ func (q *sqlQuerier) GetWorkspaceBuildByID(ctx context.Context, id uuid.UUID) (W const getWorkspaceBuildByJobID = `-- name: GetWorkspaceBuildByJobID :one SELECT - id, created_at, updated_at, workspace_id, project_version_id, name, before_id, after_id, transition, initiator, provisioner_state, job_id + id, created_at, updated_at, workspace_id, project_version_id, name, before_id, after_id, transition, initiator_id, provisioner_state, job_id FROM workspace_builds WHERE @@ -2093,7 +2043,7 @@ func (q *sqlQuerier) GetWorkspaceBuildByJobID(ctx context.Context, jobID uuid.UU &i.BeforeID, &i.AfterID, &i.Transition, - &i.Initiator, + &i.InitiatorID, &i.ProvisionerState, &i.JobID, ) @@ -2102,7 +2052,7 @@ func (q *sqlQuerier) GetWorkspaceBuildByJobID(ctx context.Context, jobID uuid.UU const getWorkspaceBuildByWorkspaceID = `-- name: GetWorkspaceBuildByWorkspaceID :many SELECT - id, created_at, updated_at, workspace_id, project_version_id, name, before_id, after_id, transition, initiator, provisioner_state, job_id + id, created_at, updated_at, workspace_id, project_version_id, name, before_id, after_id, transition, initiator_id, provisioner_state, job_id FROM workspace_builds WHERE @@ -2128,7 +2078,7 @@ func (q *sqlQuerier) GetWorkspaceBuildByWorkspaceID(ctx context.Context, workspa &i.BeforeID, &i.AfterID, &i.Transition, - &i.Initiator, + &i.InitiatorID, &i.ProvisionerState, &i.JobID, ); err != nil { @@ -2147,7 +2097,7 @@ func (q *sqlQuerier) GetWorkspaceBuildByWorkspaceID(ctx context.Context, workspa const getWorkspaceBuildByWorkspaceIDAndName = `-- name: GetWorkspaceBuildByWorkspaceIDAndName :one SELECT - id, created_at, updated_at, workspace_id, project_version_id, name, before_id, after_id, transition, initiator, provisioner_state, job_id + id, created_at, updated_at, workspace_id, project_version_id, name, before_id, after_id, transition, initiator_id, provisioner_state, job_id FROM workspace_builds WHERE @@ -2173,7 +2123,7 @@ func (q *sqlQuerier) GetWorkspaceBuildByWorkspaceIDAndName(ctx context.Context, &i.BeforeID, &i.AfterID, &i.Transition, - &i.Initiator, + &i.InitiatorID, &i.ProvisionerState, &i.JobID, ) @@ -2182,7 +2132,7 @@ func (q *sqlQuerier) GetWorkspaceBuildByWorkspaceIDAndName(ctx context.Context, const getWorkspaceBuildByWorkspaceIDWithoutAfter = `-- name: GetWorkspaceBuildByWorkspaceIDWithoutAfter :one SELECT - id, created_at, updated_at, workspace_id, project_version_id, name, before_id, after_id, transition, initiator, provisioner_state, job_id + id, created_at, updated_at, workspace_id, project_version_id, name, before_id, after_id, transition, initiator_id, provisioner_state, job_id FROM workspace_builds WHERE @@ -2205,7 +2155,7 @@ func (q *sqlQuerier) GetWorkspaceBuildByWorkspaceIDWithoutAfter(ctx context.Cont &i.BeforeID, &i.AfterID, &i.Transition, - &i.Initiator, + &i.InitiatorID, &i.ProvisionerState, &i.JobID, ) @@ -2214,7 +2164,7 @@ func (q *sqlQuerier) GetWorkspaceBuildByWorkspaceIDWithoutAfter(ctx context.Cont const getWorkspaceBuildsByWorkspaceIDsWithoutAfter = `-- name: GetWorkspaceBuildsByWorkspaceIDsWithoutAfter :many SELECT - id, created_at, updated_at, workspace_id, project_version_id, name, before_id, after_id, transition, initiator, provisioner_state, job_id + id, created_at, updated_at, workspace_id, project_version_id, name, before_id, after_id, transition, initiator_id, provisioner_state, job_id FROM workspace_builds WHERE @@ -2241,7 +2191,7 @@ func (q *sqlQuerier) GetWorkspaceBuildsByWorkspaceIDsWithoutAfter(ctx context.Co &i.BeforeID, &i.AfterID, &i.Transition, - &i.Initiator, + &i.InitiatorID, &i.ProvisionerState, &i.JobID, ); err != nil { @@ -2269,12 +2219,12 @@ INSERT INTO before_id, "name", transition, - initiator, + initiator_id, job_id, provisioner_state ) VALUES - ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11) RETURNING id, created_at, updated_at, workspace_id, project_version_id, name, before_id, after_id, transition, initiator, provisioner_state, job_id + ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11) RETURNING id, created_at, updated_at, workspace_id, project_version_id, name, before_id, after_id, transition, initiator_id, provisioner_state, job_id ` type InsertWorkspaceBuildParams struct { @@ -2286,7 +2236,7 @@ type InsertWorkspaceBuildParams struct { BeforeID uuid.NullUUID `db:"before_id" json:"before_id"` Name string `db:"name" json:"name"` Transition WorkspaceTransition `db:"transition" json:"transition"` - Initiator string `db:"initiator" json:"initiator"` + InitiatorID uuid.UUID `db:"initiator_id" json:"initiator_id"` JobID uuid.UUID `db:"job_id" json:"job_id"` ProvisionerState []byte `db:"provisioner_state" json:"provisioner_state"` } @@ -2301,7 +2251,7 @@ func (q *sqlQuerier) InsertWorkspaceBuild(ctx context.Context, arg InsertWorkspa arg.BeforeID, arg.Name, arg.Transition, - arg.Initiator, + arg.InitiatorID, arg.JobID, arg.ProvisionerState, ) @@ -2316,7 +2266,7 @@ func (q *sqlQuerier) InsertWorkspaceBuild(ctx context.Context, arg InsertWorkspa &i.BeforeID, &i.AfterID, &i.Transition, - &i.Initiator, + &i.InitiatorID, &i.ProvisionerState, &i.JobID, ) @@ -2507,9 +2457,9 @@ WHERE ` type GetWorkspaceByUserIDAndNameParams struct { - OwnerID string `db:"owner_id" json:"owner_id"` - Deleted bool `db:"deleted" json:"deleted"` - Name string `db:"name" json:"name"` + OwnerID uuid.UUID `db:"owner_id" json:"owner_id"` + Deleted bool `db:"deleted" json:"deleted"` + Name string `db:"name" json:"name"` } func (q *sqlQuerier) GetWorkspaceByUserIDAndName(ctx context.Context, arg GetWorkspaceByUserIDAndNameParams) (Workspace, error) { @@ -2625,8 +2575,8 @@ WHERE ` type GetWorkspacesByUserIDParams struct { - OwnerID string `db:"owner_id" json:"owner_id"` - Deleted bool `db:"deleted" json:"deleted"` + OwnerID uuid.UUID `db:"owner_id" json:"owner_id"` + Deleted bool `db:"deleted" json:"deleted"` } func (q *sqlQuerier) GetWorkspacesByUserID(ctx context.Context, arg GetWorkspacesByUserIDParams) ([]Workspace, error) { @@ -2678,7 +2628,7 @@ type InsertWorkspaceParams struct { ID uuid.UUID `db:"id" json:"id"` CreatedAt time.Time `db:"created_at" json:"created_at"` UpdatedAt time.Time `db:"updated_at" json:"updated_at"` - OwnerID string `db:"owner_id" json:"owner_id"` + OwnerID uuid.UUID `db:"owner_id" json:"owner_id"` ProjectID uuid.UUID `db:"project_id" json:"project_id"` Name string `db:"name" json:"name"` } From 55476d7b199385e51c39f727ca234ac957befa85 Mon Sep 17 00:00:00 2001 From: Colin Adler Date: Fri, 1 Apr 2022 14:58:30 -0500 Subject: [PATCH 9/9] generate.sh comment --- coderd/database/generate.sh | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/coderd/database/generate.sh b/coderd/database/generate.sh index 96234494edfed..7e5eb965742c1 100755 --- a/coderd/database/generate.sh +++ b/coderd/database/generate.sh @@ -1,5 +1,11 @@ #!/usr/bin/env bash +# This script turns many *.sql.go files into a single queries.sql.go file. This +# is due to sqlc's behavior when using multiple sql files to output them to +# multiple Go files. We decided it would be cleaner to move these to a single +# file for readability. We should probably contribute the option to do this +# upstream instead, because this is quite janky. + set -euo pipefail cd "$(dirname "$0")"