chore: Update sqlc to v1.16.0 (#5788)

* chore: Update sqlc to v1.16.0

* chore: Fix cases where types became Null-types

* chore: Set parameter_schemas default_destination_scheme and default_source_scheme to NOT NULL

* chore: Add enum validation to database fake

* chore: Fix all tests that skipping enum values

* fix: Use correct err in providionerdserver audit log failure log

.github/workflows/coder.yaml

@@ -215,7 +215,7 @@ jobs:
 
       - name: Install sqlc
         run: |
-          curl -sSL https://github.com/kyleconroy/sqlc/releases/download/v1.13.0/sqlc_1.13.0_linux_amd64.tar.gz | sudo tar -C /usr/bin -xz sqlc
+          curl -sSL https://github.com/kyleconroy/sqlc/releases/download/v1.16.0/sqlc_1.16.0_linux_amd64.tar.gz | sudo tar -C /usr/bin -xz sqlc
       - name: Install protoc-gen-go
         run: go install google.golang.org/protobuf/cmd/protoc-gen-go@v1.26
       - name: Install protoc-gen-go-drpc

coderd/audit.go

@@ -198,7 +198,7 @@ func (api *API) convertAuditLog(ctx context.Context, dblog database.GetAuditLogs
 			Username:  dblog.UserUsername.String,
 			Email:     dblog.UserEmail.String,
 			CreatedAt: dblog.UserCreatedAt.Time,
-			Status:    codersdk.UserStatus(dblog.UserStatus),
+			Status:    codersdk.UserStatus(dblog.UserStatus.UserStatus),
 			Roles:     []codersdk.Role{},
 			AvatarURL: dblog.UserAvatarUrl.String,
 		}

coderd/database/databasefake/databasefake.go

@@ -4,6 +4,8 @@ import (
 	"context"
 	"database/sql"
 	"encoding/json"
+	"fmt"
+	"reflect"
 	"sort"
 	"strings"
 	"sync"
@@ -129,6 +131,65 @@ type data struct {
 	lastLicenseID   int32
 }
 
+func validateDatabaseTypeWithValid(v reflect.Value) (handled bool, err error) {
+	if v.Kind() == reflect.Struct {
+		return false, nil
+	}
+
+	if v.CanInterface() {
+		if !strings.Contains(v.Type().PkgPath(), "coderd/database") {
+			return true, nil
+		}
+		if valid, ok := v.Interface().(interface{ Valid() bool }); ok {
+			if !valid.Valid() {
+				return true, xerrors.Errorf("invalid %s: %q", v.Type().Name(), v.Interface())
+			}
+		}
+		return true, nil
+	}
+	return false, nil
+}
+
+// validateDatabaseType uses reflect to check if struct properties are types
+// with a Valid() bool function set. If so, call it and return an error
+// if false.
+//
+// Note that we only check immediate values and struct fields. We do not
+// recurse into nested structs.
+func validateDatabaseType(args interface{}) error {
+	v := reflect.ValueOf(args)
+
+	// Note: database.Null* types don't have a Valid method, we skip them here
+	// because their embedded types may have a Valid method and we don't want
+	// to bother with checking both that the Valid field is true and that the
+	// type it embeds validates to true. We would need to check:
+	//
+	//	dbNullEnum.Valid && dbNullEnum.Enum.Valid()
+	if strings.HasPrefix(v.Type().Name(), "Null") {
+		return nil
+	}
+
+	if ok, err := validateDatabaseTypeWithValid(v); ok {
+		return err
+	}
+	switch v.Kind() {
+	case reflect.Struct:
+		var errs []string
+		for i := 0; i < v.NumField(); i++ {
+			field := v.Field(i)
+			if ok, err := validateDatabaseTypeWithValid(field); ok && err != nil {
+				errs = append(errs, fmt.Sprintf("%s.%s: %s", v.Type().Name(), v.Type().Field(i).Name, err.Error()))
+			}
+		}
+		if len(errs) > 0 {
+			return xerrors.Errorf("invalid database type fields:\n\t%s", strings.Join(errs, "\n\t"))
+		}
+	default:
+		panic(fmt.Sprintf("unhandled type: %s", v.Type().Name()))
+	}
+	return nil
+}
+
 func (fakeQuerier) IsFakeDB() {}
 func (*fakeQuerier) Ping(_ context.Context) (time.Duration, error) {
 	return 0, nil
@@ -142,6 +203,10 @@ func (q *fakeQuerier) InTx(fn func(database.Store) error, _ *sql.TxOptions) erro
 }
 
 func (q *fakeQuerier) AcquireProvisionerJob(_ context.Context, arg database.AcquireProvisionerJobParams) (database.ProvisionerJob, error) {
+	if err := validateDatabaseType(arg); err != nil {
+		return database.ProvisionerJob{}, err
+	}
+
 	q.mutex.Lock()
 	defer q.mutex.Unlock()
 
@@ -198,6 +263,10 @@ func (*fakeQuerier) DeleteOldAgentStats(_ context.Context) error {
 }
 
 func (q *fakeQuerier) InsertAgentStat(_ context.Context, p database.InsertAgentStatParams) (database.AgentStat, error) {
+	if err := validateDatabaseType(p); err != nil {
+		return database.AgentStat{}, err
+	}
+
 	q.mutex.Lock()
 	defer q.mutex.Unlock()
 
@@ -282,6 +351,10 @@ func (q *fakeQuerier) GetTemplateDAUs(_ context.Context, templateID uuid.UUID) (
 }
 
 func (q *fakeQuerier) GetTemplateAverageBuildTime(ctx context.Context, arg database.GetTemplateAverageBuildTimeParams) (database.GetTemplateAverageBuildTimeRow, error) {
+	if err := validateDatabaseType(arg); err != nil {
+		return database.GetTemplateAverageBuildTimeRow{}, err
+	}
+
 	var emptyRow database.GetTemplateAverageBuildTimeRow
 	var (
 		startTimes  []float64
@@ -382,6 +455,10 @@ func (q *fakeQuerier) GetAPIKeysLastUsedAfter(_ context.Context, after time.Time
 }
 
 func (q *fakeQuerier) GetAPIKeysByLoginType(_ context.Context, t database.LoginType) ([]database.APIKey, error) {
+	if err := validateDatabaseType(t); err != nil {
+		return nil, err
+	}
+
 	q.mutex.RLock()
 	defer q.mutex.RUnlock()
 
@@ -423,6 +500,10 @@ func (q *fakeQuerier) DeleteAPIKeysByUserID(_ context.Context, userID uuid.UUID)
 }
 
 func (q *fakeQuerier) GetFileByHashAndCreator(_ context.Context, arg database.GetFileByHashAndCreatorParams) (database.File, error) {
+	if err := validateDatabaseType(arg); err != nil {
+		return database.File{}, err
+	}
+
 	q.mutex.RLock()
 	defer q.mutex.RUnlock()
 
@@ -447,6 +528,10 @@ func (q *fakeQuerier) GetFileByID(_ context.Context, id uuid.UUID) (database.Fil
 }
 
 func (q *fakeQuerier) GetUserByEmailOrUsername(_ context.Context, arg database.GetUserByEmailOrUsernameParams) (database.User, error) {
+	if err := validateDatabaseType(arg); err != nil {
+		return database.User{}, err
+	}
+
 	q.mutex.RLock()
 	defer q.mutex.RUnlock()
 
@@ -497,11 +582,18 @@ func (q *fakeQuerier) GetActiveUserCount(_ context.Context) (int64, error) {
 }
 
 func (q *fakeQuerier) GetFilteredUserCount(ctx context.Context, arg database.GetFilteredUserCountParams) (int64, error) {
+	if err := validateDatabaseType(arg); err != nil {
+		return 0, err
+	}
 	count, err := q.GetAuthorizedUserCount(ctx, arg, nil)
 	return count, err
 }
 
 func (q *fakeQuerier) GetAuthorizedUserCount(ctx context.Context, params database.GetFilteredUserCountParams, prepared rbac.PreparedAuthorized) (int64, error) {
+	if err := validateDatabaseType(params); err != nil {
+		return 0, err
+	}
+
 	q.mutex.RLock()
 	defer q.mutex.RUnlock()
 
@@ -564,6 +656,10 @@ func (q *fakeQuerier) GetAuthorizedUserCount(ctx context.Context, params databas
 }
 
 func (q *fakeQuerier) UpdateUserDeletedByID(_ context.Context, params database.UpdateUserDeletedByIDParams) error {
+	if err := validateDatabaseType(params); err != nil {
+		return err
+	}
+
 	q.mutex.Lock()
 	defer q.mutex.Unlock()
 
@@ -578,6 +674,10 @@ func (q *fakeQuerier) UpdateUserDeletedByID(_ context.Context, params database.U
 }
 
 func (q *fakeQuerier) GetUsers(_ context.Context, params database.GetUsersParams) ([]database.GetUsersRow, error) {
+	if err := validateDatabaseType(params); err != nil {
+		return nil, err
+	}
+
 	q.mutex.RLock()
 	defer q.mutex.RUnlock()
 
@@ -757,6 +857,10 @@ func (q *fakeQuerier) GetAuthorizationUserRoles(_ context.Context, userID uuid.U
 }
 
 func (q *fakeQuerier) GetWorkspaces(ctx context.Context, arg database.GetWorkspacesParams) ([]database.GetWorkspacesRow, error) {
+	if err := validateDatabaseType(arg); err != nil {
+		return nil, err
+	}
+
 	// A nil auth filter means no auth filter.
 	workspaceRows, err := q.GetAuthorizedWorkspaces(ctx, arg, nil)
 	return workspaceRows, err
@@ -764,6 +868,10 @@ func (q *fakeQuerier) GetWorkspaces(ctx context.Context, arg database.GetWorkspa
 
 //nolint:gocyclo
 func (q *fakeQuerier) GetAuthorizedWorkspaces(ctx context.Context, arg database.GetWorkspacesParams, prepared rbac.PreparedAuthorized) ([]database.GetWorkspacesRow, error) {
+	if err := validateDatabaseType(arg); err != nil {
+		return nil, err
+	}
+
 	q.mutex.RLock()
 	defer q.mutex.RUnlock()
 
@@ -1074,6 +1182,10 @@ func (q *fakeQuerier) GetWorkspaceByAgentID(_ context.Context, agentID uuid.UUID
 }
 
 func (q *fakeQuerier) GetWorkspaceByOwnerIDAndName(_ context.Context, arg database.GetWorkspaceByOwnerIDAndNameParams) (database.Workspace, error) {
+	if err := validateDatabaseType(arg); err != nil {
+		return database.Workspace{}, err
+	}
+
 	q.mutex.RLock()
 	defer q.mutex.RUnlock()
 
@@ -1295,6 +1407,10 @@ func (q *fakeQuerier) GetLatestWorkspaceBuildsByWorkspaceIDs(_ context.Context,
 func (q *fakeQuerier) GetWorkspaceBuildsByWorkspaceID(_ context.Context,
 	params database.GetWorkspaceBuildsByWorkspaceIDParams,
 ) ([]database.WorkspaceBuild, error) {
+	if err := validateDatabaseType(params); err != nil {
+		return nil, err
+	}
+
 	q.mutex.RLock()
 	defer q.mutex.RUnlock()
 
@@ -1352,6 +1468,10 @@ func (q *fakeQuerier) GetWorkspaceBuildsByWorkspaceID(_ context.Context,
 }
 
 func (q *fakeQuerier) GetWorkspaceBuildByWorkspaceIDAndBuildNumber(_ context.Context, arg database.GetWorkspaceBuildByWorkspaceIDAndBuildNumberParams) (database.WorkspaceBuild, error) {
+	if err := validateDatabaseType(arg); err != nil {
+		return database.WorkspaceBuild{}, err
+	}
+
 	q.mutex.RLock()
 	defer q.mutex.RUnlock()
 
@@ -1451,6 +1571,10 @@ func (q *fakeQuerier) GetOrganizationsByUserID(_ context.Context, userID uuid.UU
 }
 
 func (q *fakeQuerier) ParameterValues(_ context.Context, arg database.ParameterValuesParams) ([]database.ParameterValue, error) {
+	if err := validateDatabaseType(arg); err != nil {
+		return nil, err
+	}
+
 	q.mutex.RLock()
 	defer q.mutex.RUnlock()
 
@@ -1493,6 +1617,10 @@ func (q *fakeQuerier) GetTemplateByID(_ context.Context, id uuid.UUID) (database
 }
 
 func (q *fakeQuerier) GetTemplateByOrganizationAndName(_ context.Context, arg database.GetTemplateByOrganizationAndNameParams) (database.Template, error) {
+	if err := validateDatabaseType(arg); err != nil {
+		return database.Template{}, err
+	}
+
 	q.mutex.RLock()
 	defer q.mutex.RUnlock()
 
@@ -1512,6 +1640,10 @@ func (q *fakeQuerier) GetTemplateByOrganizationAndName(_ context.Context, arg da
 }
 
 func (q *fakeQuerier) UpdateTemplateMetaByID(_ context.Context, arg database.UpdateTemplateMetaByIDParams) (database.Template, error) {
+	if err := validateDatabaseType(arg); err != nil {
+		return database.Template{}, err
+	}
+
 	q.mutex.RLock()
 	defer q.mutex.RUnlock()
 
@@ -1533,10 +1665,18 @@ func (q *fakeQuerier) UpdateTemplateMetaByID(_ context.Context, arg database.Upd
 }
 
 func (q *fakeQuerier) GetTemplatesWithFilter(ctx context.Context, arg database.GetTemplatesWithFilterParams) ([]database.Template, error) {
+	if err := validateDatabaseType(arg); err != nil {
+		return nil, err
+	}
+
 	return q.GetAuthorizedTemplates(ctx, arg, nil)
 }
 
 func (q *fakeQuerier) GetAuthorizedTemplates(ctx context.Context, arg database.GetTemplatesWithFilterParams, prepared rbac.PreparedAuthorized) ([]database.Template, error) {
+	if err := validateDatabaseType(arg); err != nil {
+		return nil, err
+	}
+
 	q.mutex.RLock()
 	defer q.mutex.RUnlock()
 
@@ -1585,6 +1725,10 @@ func (q *fakeQuerier) GetAuthorizedTemplates(ctx context.Context, arg database.G
 }
 
 func (q *fakeQuerier) GetTemplateVersionsByTemplateID(_ context.Context, arg database.GetTemplateVersionsByTemplateIDParams) (version []database.TemplateVersion, err error) {
+	if err := validateDatabaseType(arg); err != nil {
+		return version, err
+	}
+
 	q.mutex.RLock()
 	defer q.mutex.RUnlock()
 
@@ -1657,6 +1801,10 @@ func (q *fakeQuerier) GetTemplateVersionsCreatedAfter(_ context.Context, after t
 }
 
 func (q *fakeQuerier) GetTemplateVersionByTemplateIDAndName(_ context.Context, arg database.GetTemplateVersionByTemplateIDAndNameParams) (database.TemplateVersion, error) {
+	if err := validateDatabaseType(arg); err != nil {
+		return database.TemplateVersion{}, err
+	}
+
 	q.mutex.RLock()
 	defer q.mutex.RUnlock()
 
@@ -1687,6 +1835,10 @@ func (q *fakeQuerier) GetTemplateVersionParameters(_ context.Context, templateVe
 }
 
 func (q *fakeQuerier) GetTemplateVersionByOrganizationAndName(_ context.Context, arg database.GetTemplateVersionByOrganizationAndNameParams) (database.TemplateVersion, error) {
+	if err := validateDatabaseType(arg); err != nil {
+		return database.TemplateVersion{}, err
+	}
+
 	q.mutex.RLock()
 	defer q.mutex.RUnlock()
 
@@ -1749,6 +1901,10 @@ func (q *fakeQuerier) GetTemplateVersionByJobID(_ context.Context, jobID uuid.UU
 }
 
 func (q *fakeQuerier) GetPreviousTemplateVersion(_ context.Context, arg database.GetPreviousTemplateVersionParams) (database.TemplateVersion, error) {
+	if err := validateDatabaseType(arg); err != nil {
+		return database.TemplateVersion{}, err
+	}
+
 	q.mutex.RLock()
 	defer q.mutex.RUnlock()
 
@@ -1829,6 +1985,10 @@ func (q *fakeQuerier) GetParameterSchemasCreatedAfter(_ context.Context, after t
 }
 
 func (q *fakeQuerier) GetParameterValueByScopeAndName(_ context.Context, arg database.GetParameterValueByScopeAndNameParams) (database.ParameterValue, error) {
+	if err := validateDatabaseType(arg); err != nil {
+		return database.ParameterValue{}, err
+	}
+
 	q.mutex.RLock()
 	defer q.mutex.RUnlock()
 
@@ -1941,6 +2101,10 @@ func (q *fakeQuerier) GetTemplateGroupRoles(_ context.Context, id uuid.UUID) ([]
 }
 
 func (q *fakeQuerier) GetOrganizationMemberByUserID(_ context.Context, arg database.GetOrganizationMemberByUserIDParams) (database.OrganizationMember, error) {
+	if err := validateDatabaseType(arg); err != nil {
+		return database.OrganizationMember{}, err
+	}
+
 	q.mutex.RLock()
 	defer q.mutex.RUnlock()
 
@@ -1995,6 +2159,10 @@ func (q *fakeQuerier) GetOrganizationMembershipsByUserID(_ context.Context, user
 }
 
 func (q *fakeQuerier) UpdateMemberRoles(_ context.Context, arg database.UpdateMemberRolesParams) (database.OrganizationMember, error) {
+	if err := validateDatabaseType(arg); err != nil {
+		return database.OrganizationMember{}, err
+	}
+
 	q.mutex.Lock()
 	defer q.mutex.Unlock()
 
@@ -2102,6 +2270,10 @@ func (q *fakeQuerier) GetWorkspaceAgentsCreatedAfter(_ context.Context, after ti
 }
 
 func (q *fakeQuerier) GetWorkspaceAppByAgentIDAndSlug(_ context.Context, arg database.GetWorkspaceAppByAgentIDAndSlugParams) (database.WorkspaceApp, error) {
+	if err := validateDatabaseType(arg); err != nil {
+		return database.WorkspaceApp{}, err
+	}
+
 	q.mutex.RLock()
 	defer q.mutex.RUnlock()
 
@@ -2271,6 +2443,10 @@ func (q *fakeQuerier) GetProvisionerJobsCreatedAfter(_ context.Context, after ti
 }
 
 func (q *fakeQuerier) GetProvisionerLogsByIDBetween(_ context.Context, arg database.GetProvisionerLogsByIDBetweenParams) ([]database.ProvisionerJobLog, error) {
+	if err := validateDatabaseType(arg); err != nil {
+		return nil, err
+	}
+
 	q.mutex.RLock()
 	defer q.mutex.RUnlock()
 
@@ -2291,6 +2467,10 @@ func (q *fakeQuerier) GetProvisionerLogsByIDBetween(_ context.Context, arg datab
 }
 
 func (q *fakeQuerier) InsertAPIKey(_ context.Context, arg database.InsertAPIKeyParams) (database.APIKey, error) {
+	if err := validateDatabaseType(arg); err != nil {
+		return database.APIKey{}, err
+	}
+
 	q.mutex.Lock()
 	defer q.mutex.Unlock()
 
@@ -2317,6 +2497,10 @@ func (q *fakeQuerier) InsertAPIKey(_ context.Context, arg database.InsertAPIKeyP
 }
 
 func (q *fakeQuerier) InsertFile(_ context.Context, arg database.InsertFileParams) (database.File, error) {
+	if err := validateDatabaseType(arg); err != nil {
+		return database.File{}, err
+	}
+
 	q.mutex.Lock()
 	defer q.mutex.Unlock()
 
@@ -2334,6 +2518,10 @@ func (q *fakeQuerier) InsertFile(_ context.Context, arg database.InsertFileParam
 }
 
 func (q *fakeQuerier) InsertOrganization(_ context.Context, arg database.InsertOrganizationParams) (database.Organization, error) {
+	if err := validateDatabaseType(arg); err != nil {
+		return database.Organization{}, err
+	}
+
 	q.mutex.Lock()
 	defer q.mutex.Unlock()
 
@@ -2348,6 +2536,10 @@ func (q *fakeQuerier) InsertOrganization(_ context.Context, arg database.InsertO
 }
 
 func (q *fakeQuerier) InsertOrganizationMember(_ context.Context, arg database.InsertOrganizationMemberParams) (database.OrganizationMember, error) {
+	if err := validateDatabaseType(arg); err != nil {
+		return database.OrganizationMember{}, err
+	}
+
 	q.mutex.Lock()
 	defer q.mutex.Unlock()
 
@@ -2364,6 +2556,10 @@ func (q *fakeQuerier) InsertOrganizationMember(_ context.Context, arg database.I
 }
 
 func (q *fakeQuerier) InsertParameterValue(_ context.Context, arg database.InsertParameterValueParams) (database.ParameterValue, error) {
+	if err := validateDatabaseType(arg); err != nil {
+		return database.ParameterValue{}, err
+	}
+
 	q.mutex.Lock()
 	defer q.mutex.Unlock()
 
@@ -2384,6 +2580,10 @@ func (q *fakeQuerier) InsertParameterValue(_ context.Context, arg database.Inser
 }
 
 func (q *fakeQuerier) InsertTemplate(_ context.Context, arg database.InsertTemplateParams) (database.Template, error) {
+	if err := validateDatabaseType(arg); err != nil {
+		return database.Template{}, err
+	}
+
 	q.mutex.Lock()
 	defer q.mutex.Unlock()
 
@@ -2409,6 +2609,10 @@ func (q *fakeQuerier) InsertTemplate(_ context.Context, arg database.InsertTempl
 }
 
 func (q *fakeQuerier) InsertTemplateVersion(_ context.Context, arg database.InsertTemplateVersionParams) (database.TemplateVersion, error) {
+	if err := validateDatabaseType(arg); err != nil {
+		return database.TemplateVersion{}, err
+	}
+
 	q.mutex.Lock()
 	defer q.mutex.Unlock()
 
@@ -2429,6 +2633,10 @@ func (q *fakeQuerier) InsertTemplateVersion(_ context.Context, arg database.Inse
 }
 
 func (q *fakeQuerier) InsertTemplateVersionParameter(_ context.Context, arg database.InsertTemplateVersionParameterParams) (database.TemplateVersionParameter, error) {
+	if err := validateDatabaseType(arg); err != nil {
+		return database.TemplateVersionParameter{}, err
+	}
+
 	q.mutex.Lock()
 	defer q.mutex.Unlock()
 
@@ -2451,6 +2659,10 @@ func (q *fakeQuerier) InsertTemplateVersionParameter(_ context.Context, arg data
 }
 
 func (q *fakeQuerier) InsertProvisionerJobLogs(_ context.Context, arg database.InsertProvisionerJobLogsParams) ([]database.ProvisionerJobLog, error) {
+	if err := validateDatabaseType(arg); err != nil {
+		return nil, err
+	}
+
 	q.mutex.Lock()
 	defer q.mutex.Unlock()
 
@@ -2476,6 +2688,10 @@ func (q *fakeQuerier) InsertProvisionerJobLogs(_ context.Context, arg database.I
 }
 
 func (q *fakeQuerier) InsertParameterSchema(_ context.Context, arg database.InsertParameterSchemaParams) (database.ParameterSchema, error) {
+	if err := validateDatabaseType(arg); err != nil {
+		return database.ParameterSchema{}, err
+	}
+
 	q.mutex.Lock()
 	defer q.mutex.Unlock()
 
@@ -2504,6 +2720,10 @@ func (q *fakeQuerier) InsertParameterSchema(_ context.Context, arg database.Inse
 }
 
 func (q *fakeQuerier) InsertProvisionerDaemon(_ context.Context, arg database.InsertProvisionerDaemonParams) (database.ProvisionerDaemon, error) {
+	if err := validateDatabaseType(arg); err != nil {
+		return database.ProvisionerDaemon{}, err
+	}
+
 	q.mutex.Lock()
 	defer q.mutex.Unlock()
 
@@ -2519,6 +2739,10 @@ func (q *fakeQuerier) InsertProvisionerDaemon(_ context.Context, arg database.In
 }
 
 func (q *fakeQuerier) InsertProvisionerJob(_ context.Context, arg database.InsertProvisionerJobParams) (database.ProvisionerJob, error) {
+	if err := validateDatabaseType(arg); err != nil {
+		return database.ProvisionerJob{}, err
+	}
+
 	q.mutex.Lock()
 	defer q.mutex.Unlock()
 
@@ -2540,6 +2764,10 @@ func (q *fakeQuerier) InsertProvisionerJob(_ context.Context, arg database.Inser
 }
 
 func (q *fakeQuerier) InsertWorkspaceAgent(_ context.Context, arg database.InsertWorkspaceAgentParams) (database.WorkspaceAgent, error) {
+	if err := validateDatabaseType(arg); err != nil {
+		return database.WorkspaceAgent{}, err
+	}
+
 	q.mutex.Lock()
 	defer q.mutex.Unlock()
 
@@ -2568,6 +2796,10 @@ func (q *fakeQuerier) InsertWorkspaceAgent(_ context.Context, arg database.Inser
 }
 
 func (q *fakeQuerier) InsertWorkspaceResource(_ context.Context, arg database.InsertWorkspaceResourceParams) (database.WorkspaceResource, error) {
+	if err := validateDatabaseType(arg); err != nil {
+		return database.WorkspaceResource{}, err
+	}
+
 	q.mutex.Lock()
 	defer q.mutex.Unlock()
 
@@ -2588,6 +2820,10 @@ func (q *fakeQuerier) InsertWorkspaceResource(_ context.Context, arg database.In
 }
 
 func (q *fakeQuerier) InsertWorkspaceResourceMetadata(_ context.Context, arg database.InsertWorkspaceResourceMetadataParams) ([]database.WorkspaceResourceMetadatum, error) {
+	if err := validateDatabaseType(arg); err != nil {
+		return nil, err
+	}
+
 	q.mutex.Lock()
 	defer q.mutex.Unlock()
 
@@ -2615,6 +2851,10 @@ func (q *fakeQuerier) InsertWorkspaceResourceMetadata(_ context.Context, arg dat
 }
 
 func (q *fakeQuerier) InsertUser(_ context.Context, arg database.InsertUserParams) (database.User, error) {
+	if err := validateDatabaseType(arg); err != nil {
+		return database.User{}, err
+	}
+
 	q.mutex.Lock()
 	defer q.mutex.Unlock()
 
@@ -2640,6 +2880,10 @@ func (q *fakeQuerier) InsertUser(_ context.Context, arg database.InsertUserParam
 }
 
 func (q *fakeQuerier) UpdateUserRoles(_ context.Context, arg database.UpdateUserRolesParams) (database.User, error) {
+	if err := validateDatabaseType(arg); err != nil {
+		return database.User{}, err
+	}
+
 	q.mutex.Lock()
 	defer q.mutex.Unlock()
 
@@ -2670,6 +2914,10 @@ func (q *fakeQuerier) UpdateUserRoles(_ context.Context, arg database.UpdateUser
 }
 
 func (q *fakeQuerier) UpdateUserProfile(_ context.Context, arg database.UpdateUserProfileParams) (database.User, error) {
+	if err := validateDatabaseType(arg); err != nil {
+		return database.User{}, err
+	}
+
 	q.mutex.Lock()
 	defer q.mutex.Unlock()
 
@@ -2687,6 +2935,10 @@ func (q *fakeQuerier) UpdateUserProfile(_ context.Context, arg database.UpdateUs
 }
 
 func (q *fakeQuerier) UpdateUserStatus(_ context.Context, arg database.UpdateUserStatusParams) (database.User, error) {
+	if err := validateDatabaseType(arg); err != nil {
+		return database.User{}, err
+	}
+
 	q.mutex.Lock()
 	defer q.mutex.Unlock()
 
@@ -2703,6 +2955,10 @@ func (q *fakeQuerier) UpdateUserStatus(_ context.Context, arg database.UpdateUse
 }
 
 func (q *fakeQuerier) UpdateUserLastSeenAt(_ context.Context, arg database.UpdateUserLastSeenAtParams) (database.User, error) {
+	if err := validateDatabaseType(arg); err != nil {
+		return database.User{}, err
+	}
+
 	q.mutex.Lock()
 	defer q.mutex.Unlock()
 
@@ -2719,6 +2975,10 @@ func (q *fakeQuerier) UpdateUserLastSeenAt(_ context.Context, arg database.Updat
 }
 
 func (q *fakeQuerier) UpdateUserHashedPassword(_ context.Context, arg database.UpdateUserHashedPasswordParams) error {
+	if err := validateDatabaseType(arg); err != nil {
+		return err
+	}
+
 	q.mutex.Lock()
 	defer q.mutex.Unlock()
 
@@ -2734,6 +2994,10 @@ func (q *fakeQuerier) UpdateUserHashedPassword(_ context.Context, arg database.U
 }
 
 func (q *fakeQuerier) InsertWorkspace(_ context.Context, arg database.InsertWorkspaceParams) (database.Workspace, error) {
+	if err := validateDatabaseType(arg); err != nil {
+		return database.Workspace{}, err
+	}
+
 	q.mutex.Lock()
 	defer q.mutex.Unlock()
 
@@ -2754,6 +3018,10 @@ func (q *fakeQuerier) InsertWorkspace(_ context.Context, arg database.InsertWork
 }
 
 func (q *fakeQuerier) InsertWorkspaceBuild(_ context.Context, arg database.InsertWorkspaceBuildParams) (database.WorkspaceBuild, error) {
+	if err := validateDatabaseType(arg); err != nil {
+		return database.WorkspaceBuild{}, err
+	}
+
 	q.mutex.Lock()
 	defer q.mutex.Unlock()
 
@@ -2776,6 +3044,10 @@ func (q *fakeQuerier) InsertWorkspaceBuild(_ context.Context, arg database.Inser
 }
 
 func (q *fakeQuerier) InsertWorkspaceBuildParameters(_ context.Context, arg database.InsertWorkspaceBuildParametersParams) error {
+	if err := validateDatabaseType(arg); err != nil {
+		return err
+	}
+
 	q.mutex.Lock()
 	defer q.mutex.Unlock()
 
@@ -2790,6 +3062,10 @@ func (q *fakeQuerier) InsertWorkspaceBuildParameters(_ context.Context, arg data
 }
 
 func (q *fakeQuerier) InsertWorkspaceApp(_ context.Context, arg database.InsertWorkspaceAppParams) (database.WorkspaceApp, error) {
+	if err := validateDatabaseType(arg); err != nil {
+		return database.WorkspaceApp{}, err
+	}
+
 	q.mutex.Lock()
 	defer q.mutex.Unlock()
 
@@ -2820,6 +3096,10 @@ func (q *fakeQuerier) InsertWorkspaceApp(_ context.Context, arg database.InsertW
 }
 
 func (q *fakeQuerier) UpdateWorkspaceAppHealthByID(_ context.Context, arg database.UpdateWorkspaceAppHealthByIDParams) error {
+	if err := validateDatabaseType(arg); err != nil {
+		return err
+	}
+
 	q.mutex.Lock()
 	defer q.mutex.Unlock()
 
@@ -2835,6 +3115,10 @@ func (q *fakeQuerier) UpdateWorkspaceAppHealthByID(_ context.Context, arg databa
 }
 
 func (q *fakeQuerier) UpdateAPIKeyByID(_ context.Context, arg database.UpdateAPIKeyByIDParams) error {
+	if err := validateDatabaseType(arg); err != nil {
+		return err
+	}
+
 	q.mutex.Lock()
 	defer q.mutex.Unlock()
 
@@ -2852,6 +3136,10 @@ func (q *fakeQuerier) UpdateAPIKeyByID(_ context.Context, arg database.UpdateAPI
 }
 
 func (q *fakeQuerier) UpdateTemplateActiveVersionByID(_ context.Context, arg database.UpdateTemplateActiveVersionByIDParams) error {
+	if err := validateDatabaseType(arg); err != nil {
+		return err
+	}
+
 	q.mutex.Lock()
 	defer q.mutex.Unlock()
 
@@ -2868,6 +3156,10 @@ func (q *fakeQuerier) UpdateTemplateActiveVersionByID(_ context.Context, arg dat
 }
 
 func (q *fakeQuerier) UpdateTemplateDeletedByID(_ context.Context, arg database.UpdateTemplateDeletedByIDParams) error {
+	if err := validateDatabaseType(arg); err != nil {
+		return err
+	}
+
 	q.mutex.Lock()
 	defer q.mutex.Unlock()
 
@@ -2884,6 +3176,10 @@ func (q *fakeQuerier) UpdateTemplateDeletedByID(_ context.Context, arg database.
 }
 
 func (q *fakeQuerier) UpdateTemplateACLByID(_ context.Context, arg database.UpdateTemplateACLByIDParams) (database.Template, error) {
+	if err := validateDatabaseType(arg); err != nil {
+		return database.Template{}, err
+	}
+
 	q.mutex.Lock()
 	defer q.mutex.Unlock()
 
@@ -2901,6 +3197,10 @@ func (q *fakeQuerier) UpdateTemplateACLByID(_ context.Context, arg database.Upda
 }
 
 func (q *fakeQuerier) UpdateTemplateVersionByID(_ context.Context, arg database.UpdateTemplateVersionByIDParams) error {
+	if err := validateDatabaseType(arg); err != nil {
+		return err
+	}
+
 	q.mutex.Lock()
 	defer q.mutex.Unlock()
 
@@ -2917,6 +3217,10 @@ func (q *fakeQuerier) UpdateTemplateVersionByID(_ context.Context, arg database.
 }
 
 func (q *fakeQuerier) UpdateTemplateVersionDescriptionByJobID(_ context.Context, arg database.UpdateTemplateVersionDescriptionByJobIDParams) error {
+	if err := validateDatabaseType(arg); err != nil {
+		return err
+	}
+
 	q.mutex.Lock()
 	defer q.mutex.Unlock()
 
@@ -2933,6 +3237,10 @@ func (q *fakeQuerier) UpdateTemplateVersionDescriptionByJobID(_ context.Context,
 }
 
 func (q *fakeQuerier) UpdateProvisionerDaemonByID(_ context.Context, arg database.UpdateProvisionerDaemonByIDParams) error {
+	if err := validateDatabaseType(arg); err != nil {
+		return err
+	}
+
 	q.mutex.Lock()
 	defer q.mutex.Unlock()
 
@@ -2949,6 +3257,10 @@ func (q *fakeQuerier) UpdateProvisionerDaemonByID(_ context.Context, arg databas
 }
 
 func (q *fakeQuerier) UpdateWorkspaceAgentConnectionByID(_ context.Context, arg database.UpdateWorkspaceAgentConnectionByIDParams) error {
+	if err := validateDatabaseType(arg); err != nil {
+		return err
+	}
+
 	q.mutex.Lock()
 	defer q.mutex.Unlock()
 
@@ -2967,6 +3279,10 @@ func (q *fakeQuerier) UpdateWorkspaceAgentConnectionByID(_ context.Context, arg
 }
 
 func (q *fakeQuerier) UpdateWorkspaceAgentVersionByID(_ context.Context, arg database.UpdateWorkspaceAgentVersionByIDParams) error {
+	if err := validateDatabaseType(arg); err != nil {
+		return err
+	}
+
 	q.mutex.Lock()
 	defer q.mutex.Unlock()
 
@@ -2983,6 +3299,10 @@ func (q *fakeQuerier) UpdateWorkspaceAgentVersionByID(_ context.Context, arg dat
 }
 
 func (q *fakeQuerier) UpdateProvisionerJobByID(_ context.Context, arg database.UpdateProvisionerJobByIDParams) error {
+	if err := validateDatabaseType(arg); err != nil {
+		return err
+	}
+
 	q.mutex.Lock()
 	defer q.mutex.Unlock()
 
@@ -2998,6 +3318,10 @@ func (q *fakeQuerier) UpdateProvisionerJobByID(_ context.Context, arg database.U
 }
 
 func (q *fakeQuerier) UpdateProvisionerJobWithCancelByID(_ context.Context, arg database.UpdateProvisionerJobWithCancelByIDParams) error {
+	if err := validateDatabaseType(arg); err != nil {
+		return err
+	}
+
 	q.mutex.Lock()
 	defer q.mutex.Unlock()
 
@@ -3014,6 +3338,10 @@ func (q *fakeQuerier) UpdateProvisionerJobWithCancelByID(_ context.Context, arg
 }
 
 func (q *fakeQuerier) UpdateProvisionerJobWithCompleteByID(_ context.Context, arg database.UpdateProvisionerJobWithCompleteByIDParams) error {
+	if err := validateDatabaseType(arg); err != nil {
+		return err
+	}
+
 	q.mutex.Lock()
 	defer q.mutex.Unlock()
 
@@ -3031,6 +3359,10 @@ func (q *fakeQuerier) UpdateProvisionerJobWithCompleteByID(_ context.Context, ar
 }
 
 func (q *fakeQuerier) UpdateWorkspace(_ context.Context, arg database.UpdateWorkspaceParams) (database.Workspace, error) {
+	if err := validateDatabaseType(arg); err != nil {
+		return database.Workspace{}, err
+	}
+
 	q.mutex.Lock()
 	defer q.mutex.Unlock()
 
@@ -3057,6 +3389,10 @@ func (q *fakeQuerier) UpdateWorkspace(_ context.Context, arg database.UpdateWork
 }
 
 func (q *fakeQuerier) UpdateWorkspaceAutostart(_ context.Context, arg database.UpdateWorkspaceAutostartParams) error {
+	if err := validateDatabaseType(arg); err != nil {
+		return err
+	}
+
 	q.mutex.Lock()
 	defer q.mutex.Unlock()
 
@@ -3073,6 +3409,10 @@ func (q *fakeQuerier) UpdateWorkspaceAutostart(_ context.Context, arg database.U
 }
 
 func (q *fakeQuerier) UpdateWorkspaceTTL(_ context.Context, arg database.UpdateWorkspaceTTLParams) error {
+	if err := validateDatabaseType(arg); err != nil {
+		return err
+	}
+
 	q.mutex.Lock()
 	defer q.mutex.Unlock()
 
@@ -3089,6 +3429,10 @@ func (q *fakeQuerier) UpdateWorkspaceTTL(_ context.Context, arg database.UpdateW
 }
 
 func (q *fakeQuerier) UpdateWorkspaceLastUsedAt(_ context.Context, arg database.UpdateWorkspaceLastUsedAtParams) error {
+	if err := validateDatabaseType(arg); err != nil {
+		return err
+	}
+
 	q.mutex.Lock()
 	defer q.mutex.Unlock()
 
@@ -3105,6 +3449,10 @@ func (q *fakeQuerier) UpdateWorkspaceLastUsedAt(_ context.Context, arg database.
 }
 
 func (q *fakeQuerier) UpdateWorkspaceBuildByID(_ context.Context, arg database.UpdateWorkspaceBuildByIDParams) (database.WorkspaceBuild, error) {
+	if err := validateDatabaseType(arg); err != nil {
+		return database.WorkspaceBuild{}, err
+	}
+
 	q.mutex.Lock()
 	defer q.mutex.Unlock()
 
@@ -3122,6 +3470,10 @@ func (q *fakeQuerier) UpdateWorkspaceBuildByID(_ context.Context, arg database.U
 }
 
 func (q *fakeQuerier) UpdateWorkspaceBuildCostByID(_ context.Context, arg database.UpdateWorkspaceBuildCostByIDParams) (database.WorkspaceBuild, error) {
+	if err := validateDatabaseType(arg); err != nil {
+		return database.WorkspaceBuild{}, err
+	}
+
 	q.mutex.Lock()
 	defer q.mutex.Unlock()
 
@@ -3137,6 +3489,10 @@ func (q *fakeQuerier) UpdateWorkspaceBuildCostByID(_ context.Context, arg databa
 }
 
 func (q *fakeQuerier) UpdateWorkspaceDeletedByID(_ context.Context, arg database.UpdateWorkspaceDeletedByIDParams) error {
+	if err := validateDatabaseType(arg); err != nil {
+		return err
+	}
+
 	q.mutex.Lock()
 	defer q.mutex.Unlock()
 
@@ -3152,6 +3508,10 @@ func (q *fakeQuerier) UpdateWorkspaceDeletedByID(_ context.Context, arg database
 }
 
 func (q *fakeQuerier) InsertGitSSHKey(_ context.Context, arg database.InsertGitSSHKeyParams) (database.GitSSHKey, error) {
+	if err := validateDatabaseType(arg); err != nil {
+		return database.GitSSHKey{}, err
+	}
+
 	q.mutex.Lock()
 	defer q.mutex.Unlock()
 
@@ -3180,6 +3540,10 @@ func (q *fakeQuerier) GetGitSSHKey(_ context.Context, userID uuid.UUID) (databas
 }
 
 func (q *fakeQuerier) UpdateGitSSHKey(_ context.Context, arg database.UpdateGitSSHKeyParams) (database.GitSSHKey, error) {
+	if err := validateDatabaseType(arg); err != nil {
+		return database.GitSSHKey{}, err
+	}
+
 	q.mutex.Lock()
 	defer q.mutex.Unlock()
 
@@ -3197,6 +3561,10 @@ func (q *fakeQuerier) UpdateGitSSHKey(_ context.Context, arg database.UpdateGitS
 }
 
 func (q *fakeQuerier) InsertGroupMember(_ context.Context, arg database.InsertGroupMemberParams) error {
+	if err := validateDatabaseType(arg); err != nil {
+		return err
+	}
+
 	q.mutex.Lock()
 	defer q.mutex.Unlock()
 
@@ -3229,6 +3597,10 @@ func (q *fakeQuerier) DeleteGroupMember(_ context.Context, userID uuid.UUID) err
 }
 
 func (q *fakeQuerier) UpdateGroupByID(_ context.Context, arg database.UpdateGroupByIDParams) (database.Group, error) {
+	if err := validateDatabaseType(arg); err != nil {
+		return database.Group{}, err
+	}
+
 	q.mutex.Lock()
 	defer q.mutex.Unlock()
 
@@ -3260,6 +3632,10 @@ func (q *fakeQuerier) DeleteGitSSHKey(_ context.Context, userID uuid.UUID) error
 }
 
 func (q *fakeQuerier) GetAuditLogsOffset(ctx context.Context, arg database.GetAuditLogsOffsetParams) ([]database.GetAuditLogsOffsetRow, error) {
+	if err := validateDatabaseType(arg); err != nil {
+		return nil, err
+	}
+
 	q.mutex.RLock()
 	defer q.mutex.RUnlock()
 
@@ -3324,7 +3700,7 @@ func (q *fakeQuerier) GetAuditLogsOffset(ctx context.Context, arg database.GetAu
 			UserUsername:     sql.NullString{String: user.Username, Valid: userValid},
 			UserEmail:        sql.NullString{String: user.Email, Valid: userValid},
 			UserCreatedAt:    sql.NullTime{Time: user.CreatedAt, Valid: userValid},
-			UserStatus:       user.Status,
+			UserStatus:       database.NullUserStatus{UserStatus: user.Status, Valid: userValid},
 			UserRoles:        user.RBACRoles,
 			Count:            0,
 		})
@@ -3343,6 +3719,10 @@ func (q *fakeQuerier) GetAuditLogsOffset(ctx context.Context, arg database.GetAu
 }
 
 func (q *fakeQuerier) InsertAuditLog(_ context.Context, arg database.InsertAuditLogParams) (database.AuditLog, error) {
+	if err := validateDatabaseType(arg); err != nil {
+		return database.AuditLog{}, err
+	}
+
 	q.mutex.Lock()
 	defer q.mutex.Unlock()
 
@@ -3445,6 +3825,10 @@ func (q *fakeQuerier) GetLogoURL(_ context.Context) (string, error) {
 func (q *fakeQuerier) InsertLicense(
 	_ context.Context, arg database.InsertLicenseParams,
 ) (database.License, error) {
+	if err := validateDatabaseType(arg); err != nil {
+		return database.License{}, err
+	}
+
 	q.mutex.Lock()
 	defer q.mutex.Unlock()
 
@@ -3510,6 +3894,10 @@ func (q *fakeQuerier) GetUserLinkByLinkedID(_ context.Context, id string) (datab
 }
 
 func (q *fakeQuerier) GetUserLinkByUserIDLoginType(_ context.Context, params database.GetUserLinkByUserIDLoginTypeParams) (database.UserLink, error) {
+	if err := validateDatabaseType(params); err != nil {
+		return database.UserLink{}, err
+	}
+
 	q.mutex.RLock()
 	defer q.mutex.RUnlock()
 
@@ -3541,6 +3929,10 @@ func (q *fakeQuerier) InsertUserLink(_ context.Context, args database.InsertUser
 }
 
 func (q *fakeQuerier) UpdateUserLinkedID(_ context.Context, params database.UpdateUserLinkedIDParams) (database.UserLink, error) {
+	if err := validateDatabaseType(params); err != nil {
+		return database.UserLink{}, err
+	}
+
 	q.mutex.RLock()
 	defer q.mutex.RUnlock()
 
@@ -3557,6 +3949,10 @@ func (q *fakeQuerier) UpdateUserLinkedID(_ context.Context, params database.Upda
 }
 
 func (q *fakeQuerier) UpdateUserLink(_ context.Context, params database.UpdateUserLinkParams) (database.UserLink, error) {
+	if err := validateDatabaseType(params); err != nil {
+		return database.UserLink{}, err
+	}
+
 	q.mutex.RLock()
 	defer q.mutex.RUnlock()
 
@@ -3588,6 +3984,10 @@ func (q *fakeQuerier) GetGroupByID(_ context.Context, id uuid.UUID) (database.Gr
 }
 
 func (q *fakeQuerier) GetGroupByOrgAndName(_ context.Context, arg database.GetGroupByOrgAndNameParams) (database.Group, error) {
+	if err := validateDatabaseType(arg); err != nil {
+		return database.Group{}, err
+	}
+
 	q.mutex.RLock()
 	defer q.mutex.RUnlock()
 
@@ -3610,6 +4010,10 @@ func (q *fakeQuerier) InsertAllUsersGroup(ctx context.Context, orgID uuid.UUID)
 }
 
 func (q *fakeQuerier) InsertGroup(_ context.Context, arg database.InsertGroupParams) (database.Group, error) {
+	if err := validateDatabaseType(arg); err != nil {
+		return database.Group{}, err
+	}
+
 	q.mutex.RLock()
 	defer q.mutex.RUnlock()
 
@@ -3724,6 +4128,10 @@ func (q *fakeQuerier) DeleteReplicasUpdatedBefore(_ context.Context, before time
 }
 
 func (q *fakeQuerier) InsertReplica(_ context.Context, arg database.InsertReplicaParams) (database.Replica, error) {
+	if err := validateDatabaseType(arg); err != nil {
+		return database.Replica{}, err
+	}
+
 	q.mutex.Lock()
 	defer q.mutex.Unlock()
 
@@ -3743,6 +4151,10 @@ func (q *fakeQuerier) InsertReplica(_ context.Context, arg database.InsertReplic
 }
 
 func (q *fakeQuerier) UpdateReplica(_ context.Context, arg database.UpdateReplicaParams) (database.Replica, error) {
+	if err := validateDatabaseType(arg); err != nil {
+		return database.Replica{}, err
+	}
+
 	q.mutex.Lock()
 	defer q.mutex.Unlock()
 
@@ -3778,6 +4190,10 @@ func (q *fakeQuerier) GetReplicasUpdatedAfter(_ context.Context, updatedAt time.
 }
 
 func (q *fakeQuerier) GetGitAuthLink(_ context.Context, arg database.GetGitAuthLinkParams) (database.GitAuthLink, error) {
+	if err := validateDatabaseType(arg); err != nil {
+		return database.GitAuthLink{}, err
+	}
+
 	q.mutex.RLock()
 	defer q.mutex.RUnlock()
 	for _, gitAuthLink := range q.gitAuthLinks {
@@ -3793,6 +4209,10 @@ func (q *fakeQuerier) GetGitAuthLink(_ context.Context, arg database.GetGitAuthL
 }
 
 func (q *fakeQuerier) InsertGitAuthLink(_ context.Context, arg database.InsertGitAuthLinkParams) (database.GitAuthLink, error) {
+	if err := validateDatabaseType(arg); err != nil {
+		return database.GitAuthLink{}, err
+	}
+
 	q.mutex.Lock()
 	defer q.mutex.Unlock()
 	// nolint:gosimple
@@ -3810,6 +4230,10 @@ func (q *fakeQuerier) InsertGitAuthLink(_ context.Context, arg database.InsertGi
 }
 
 func (q *fakeQuerier) UpdateGitAuthLink(_ context.Context, arg database.UpdateGitAuthLinkParams) error {
+	if err := validateDatabaseType(arg); err != nil {
+		return err
+	}
+
 	q.mutex.Lock()
 	defer q.mutex.Unlock()
 	for index, gitAuthLink := range q.gitAuthLinks {

coderd/database/dump.sql

@@ -238,10 +238,10 @@ CREATE TABLE parameter_schemas (
     job_id uuid NOT NULL,
     name character varying(64) NOT NULL,
     description character varying(8192) DEFAULT ''::character varying NOT NULL,
-    default_source_scheme parameter_source_scheme,
+    default_source_scheme parameter_source_scheme NOT NULL,
     default_source_value text NOT NULL,
     allow_override_source boolean NOT NULL,
-    default_destination_scheme parameter_destination_scheme,
+    default_destination_scheme parameter_destination_scheme NOT NULL,
     allow_override_destination boolean NOT NULL,
     default_refresh text NOT NULL,
     redisplay_value boolean NOT NULL,

coderd/database/generate.sh

@@ -18,7 +18,7 @@ SCRIPT_DIR=$(dirname "${BASH_SOURCE[0]}")
 	# Dump the updated schema (use make to utilize caching).
 	make -C ../.. --no-print-directory coderd/database/dump.sql
 	# The logic below depends on the exact version being correct :(
-	go run github.com/kyleconroy/sqlc/cmd/sqlc@v1.13.0 generate
+	go run github.com/kyleconroy/sqlc/cmd/sqlc@v1.16.0 generate
 
 	first=true
 	for fi in queries/*.sql.go; do

coderd/database/migrations/000090_sqlc_upgrade_fix_nullable_values.down.sql

@@ -0,0 +1,5 @@
+BEGIN;
+ALTER TABLE parameter_schemas ALTER COLUMN default_source_scheme DROP NOT NULL;
+
+ALTER TABLE parameter_schemas ALTER COLUMN default_destination_scheme DROP NOT NULL;
+COMMIT;

coderd/database/migrations/000090_sqlc_upgrade_fix_nullable_values.up.sql

@@ -0,0 +1,7 @@
+BEGIN;
+UPDATE parameter_schemas SET default_source_scheme = 'none' WHERE default_source_scheme IS NULL;
+ALTER TABLE parameter_schemas ALTER COLUMN default_source_scheme SET NOT NULL;
+
+UPDATE parameter_schemas SET default_destination_scheme = 'none' WHERE default_destination_scheme IS NULL;
+ALTER TABLE parameter_schemas ALTER COLUMN default_destination_scheme SET NOT NULL;
+COMMIT;

coderd/database/models.go

@@ -1,11 +1,12 @@
 // Code generated by sqlc. DO NOT EDIT.
 // versions:
-//   sqlc v1.13.0
+//   sqlc v1.16.0
 
 package database
 
 import (
 	"database/sql"
+	"database/sql/driver"
 	"encoding/json"
 	"fmt"
 	"time"
@@ -35,6 +36,45 @@ func (e *APIKeyScope) Scan(src interface{}) error {
 	return nil
 }
 
+type NullAPIKeyScope struct {
+	APIKeyScope APIKeyScope
+	Valid       bool // Valid is true if APIKeyScope is not NULL
+}
+
+// Scan implements the Scanner interface.
+func (ns *NullAPIKeyScope) Scan(value interface{}) error {
+	if value == nil {
+		ns.APIKeyScope, ns.Valid = "", false
+		return nil
+	}
+	ns.Valid = true
+	return ns.APIKeyScope.Scan(value)
+}
+
+// Value implements the driver Valuer interface.
+func (ns NullAPIKeyScope) Value() (driver.Value, error) {
+	if !ns.Valid {
+		return nil, nil
+	}
+	return ns.APIKeyScope, nil
+}
+
+func (e APIKeyScope) Valid() bool {
+	switch e {
+	case APIKeyScopeAll,
+		APIKeyScopeApplicationConnect:
+		return true
+	}
+	return false
+}
+
+func AllAPIKeyScopeValues() []APIKeyScope {
+	return []APIKeyScope{
+		APIKeyScopeAll,
+		APIKeyScopeApplicationConnect,
+	}
+}
+
 type AppSharingLevel string
 
 const (
@@ -55,6 +95,47 @@ func (e *AppSharingLevel) Scan(src interface{}) error {
 	return nil
 }
 
+type NullAppSharingLevel struct {
+	AppSharingLevel AppSharingLevel
+	Valid           bool // Valid is true if AppSharingLevel is not NULL
+}
+
+// Scan implements the Scanner interface.
+func (ns *NullAppSharingLevel) Scan(value interface{}) error {
+	if value == nil {
+		ns.AppSharingLevel, ns.Valid = "", false
+		return nil
+	}
+	ns.Valid = true
+	return ns.AppSharingLevel.Scan(value)
+}
+
+// Value implements the driver Valuer interface.
+func (ns NullAppSharingLevel) Value() (driver.Value, error) {
+	if !ns.Valid {
+		return nil, nil
+	}
+	return ns.AppSharingLevel, nil
+}
+
+func (e AppSharingLevel) Valid() bool {
+	switch e {
+	case AppSharingLevelOwner,
+		AppSharingLevelAuthenticated,
+		AppSharingLevelPublic:
+		return true
+	}
+	return false
+}
+
+func AllAppSharingLevelValues() []AppSharingLevel {
+	return []AppSharingLevel{
+		AppSharingLevelOwner,
+		AppSharingLevelAuthenticated,
+		AppSharingLevelPublic,
+	}
+}
+
 type AuditAction string
 
 const (
@@ -77,6 +158,51 @@ func (e *AuditAction) Scan(src interface{}) error {
 	return nil
 }
 
+type NullAuditAction struct {
+	AuditAction AuditAction
+	Valid       bool // Valid is true if AuditAction is not NULL
+}
+
+// Scan implements the Scanner interface.
+func (ns *NullAuditAction) Scan(value interface{}) error {
+	if value == nil {
+		ns.AuditAction, ns.Valid = "", false
+		return nil
+	}
+	ns.Valid = true
+	return ns.AuditAction.Scan(value)
+}
+
+// Value implements the driver Valuer interface.
+func (ns NullAuditAction) Value() (driver.Value, error) {
+	if !ns.Valid {
+		return nil, nil
+	}
+	return ns.AuditAction, nil
+}
+
+func (e AuditAction) Valid() bool {
+	switch e {
+	case AuditActionCreate,
+		AuditActionWrite,
+		AuditActionDelete,
+		AuditActionStart,
+		AuditActionStop:
+		return true
+	}
+	return false
+}
+
+func AllAuditActionValues() []AuditAction {
+	return []AuditAction{
+		AuditActionCreate,
+		AuditActionWrite,
+		AuditActionDelete,
+		AuditActionStart,
+		AuditActionStop,
+	}
+}
+
 type BuildReason string
 
 const (
@@ -97,6 +223,47 @@ func (e *BuildReason) Scan(src interface{}) error {
 	return nil
 }
 
+type NullBuildReason struct {
+	BuildReason BuildReason
+	Valid       bool // Valid is true if BuildReason is not NULL
+}
+
+// Scan implements the Scanner interface.
+func (ns *NullBuildReason) Scan(value interface{}) error {
+	if value == nil {
+		ns.BuildReason, ns.Valid = "", false
+		return nil
+	}
+	ns.Valid = true
+	return ns.BuildReason.Scan(value)
+}
+
+// Value implements the driver Valuer interface.
+func (ns NullBuildReason) Value() (driver.Value, error) {
+	if !ns.Valid {
+		return nil, nil
+	}
+	return ns.BuildReason, nil
+}
+
+func (e BuildReason) Valid() bool {
+	switch e {
+	case BuildReasonInitiator,
+		BuildReasonAutostart,
+		BuildReasonAutostop:
+		return true
+	}
+	return false
+}
+
+func AllBuildReasonValues() []BuildReason {
+	return []BuildReason{
+		BuildReasonInitiator,
+		BuildReasonAutostart,
+		BuildReasonAutostop,
+	}
+}
+
 type LogLevel string
 
 const (
@@ -119,6 +286,51 @@ func (e *LogLevel) Scan(src interface{}) error {
 	return nil
 }
 
+type NullLogLevel struct {
+	LogLevel LogLevel
+	Valid    bool // Valid is true if LogLevel is not NULL
+}
+
+// Scan implements the Scanner interface.
+func (ns *NullLogLevel) Scan(value interface{}) error {
+	if value == nil {
+		ns.LogLevel, ns.Valid = "", false
+		return nil
+	}
+	ns.Valid = true
+	return ns.LogLevel.Scan(value)
+}
+
+// Value implements the driver Valuer interface.
+func (ns NullLogLevel) Value() (driver.Value, error) {
+	if !ns.Valid {
+		return nil, nil
+	}
+	return ns.LogLevel, nil
+}
+
+func (e LogLevel) Valid() bool {
+	switch e {
+	case LogLevelTrace,
+		LogLevelDebug,
+		LogLevelInfo,
+		LogLevelWarn,
+		LogLevelError:
+		return true
+	}
+	return false
+}
+
+func AllLogLevelValues() []LogLevel {
+	return []LogLevel{
+		LogLevelTrace,
+		LogLevelDebug,
+		LogLevelInfo,
+		LogLevelWarn,
+		LogLevelError,
+	}
+}
+
 type LogSource string
 
 const (
@@ -138,6 +350,45 @@ func (e *LogSource) Scan(src interface{}) error {
 	return nil
 }
 
+type NullLogSource struct {
+	LogSource LogSource
+	Valid     bool // Valid is true if LogSource is not NULL
+}
+
+// Scan implements the Scanner interface.
+func (ns *NullLogSource) Scan(value interface{}) error {
+	if value == nil {
+		ns.LogSource, ns.Valid = "", false
+		return nil
+	}
+	ns.Valid = true
+	return ns.LogSource.Scan(value)
+}
+
+// Value implements the driver Valuer interface.
+func (ns NullLogSource) Value() (driver.Value, error) {
+	if !ns.Valid {
+		return nil, nil
+	}
+	return ns.LogSource, nil
+}
+
+func (e LogSource) Valid() bool {
+	switch e {
+	case LogSourceProvisionerDaemon,
+		LogSourceProvisioner:
+		return true
+	}
+	return false
+}
+
+func AllLogSourceValues() []LogSource {
+	return []LogSource{
+		LogSourceProvisionerDaemon,
+		LogSourceProvisioner,
+	}
+}
+
 type LoginType string
 
 const (
@@ -159,6 +410,49 @@ func (e *LoginType) Scan(src interface{}) error {
 	return nil
 }
 
+type NullLoginType struct {
+	LoginType LoginType
+	Valid     bool // Valid is true if LoginType is not NULL
+}
+
+// Scan implements the Scanner interface.
+func (ns *NullLoginType) Scan(value interface{}) error {
+	if value == nil {
+		ns.LoginType, ns.Valid = "", false
+		return nil
+	}
+	ns.Valid = true
+	return ns.LoginType.Scan(value)
+}
+
+// Value implements the driver Valuer interface.
+func (ns NullLoginType) Value() (driver.Value, error) {
+	if !ns.Valid {
+		return nil, nil
+	}
+	return ns.LoginType, nil
+}
+
+func (e LoginType) Valid() bool {
+	switch e {
+	case LoginTypePassword,
+		LoginTypeGithub,
+		LoginTypeOIDC,
+		LoginTypeToken:
+		return true
+	}
+	return false
+}
+
+func AllLoginTypeValues() []LoginType {
+	return []LoginType{
+		LoginTypePassword,
+		LoginTypeGithub,
+		LoginTypeOIDC,
+		LoginTypeToken,
+	}
+}
+
 type ParameterDestinationScheme string
 
 const (
@@ -179,6 +473,47 @@ func (e *ParameterDestinationScheme) Scan(src interface{}) error {
 	return nil
 }
 
+type NullParameterDestinationScheme struct {
+	ParameterDestinationScheme ParameterDestinationScheme
+	Valid                      bool // Valid is true if ParameterDestinationScheme is not NULL
+}
+
+// Scan implements the Scanner interface.
+func (ns *NullParameterDestinationScheme) Scan(value interface{}) error {
+	if value == nil {
+		ns.ParameterDestinationScheme, ns.Valid = "", false
+		return nil
+	}
+	ns.Valid = true
+	return ns.ParameterDestinationScheme.Scan(value)
+}
+
+// Value implements the driver Valuer interface.
+func (ns NullParameterDestinationScheme) Value() (driver.Value, error) {
+	if !ns.Valid {
+		return nil, nil
+	}
+	return ns.ParameterDestinationScheme, nil
+}
+
+func (e ParameterDestinationScheme) Valid() bool {
+	switch e {
+	case ParameterDestinationSchemeNone,
+		ParameterDestinationSchemeEnvironmentVariable,
+		ParameterDestinationSchemeProvisionerVariable:
+		return true
+	}
+	return false
+}
+
+func AllParameterDestinationSchemeValues() []ParameterDestinationScheme {
+	return []ParameterDestinationScheme{
+		ParameterDestinationSchemeNone,
+		ParameterDestinationSchemeEnvironmentVariable,
+		ParameterDestinationSchemeProvisionerVariable,
+	}
+}
+
 type ParameterScope string
 
 const (
@@ -199,6 +534,47 @@ func (e *ParameterScope) Scan(src interface{}) error {
 	return nil
 }
 
+type NullParameterScope struct {
+	ParameterScope ParameterScope
+	Valid          bool // Valid is true if ParameterScope is not NULL
+}
+
+// Scan implements the Scanner interface.
+func (ns *NullParameterScope) Scan(value interface{}) error {
+	if value == nil {
+		ns.ParameterScope, ns.Valid = "", false
+		return nil
+	}
+	ns.Valid = true
+	return ns.ParameterScope.Scan(value)
+}
+
+// Value implements the driver Valuer interface.
+func (ns NullParameterScope) Value() (driver.Value, error) {
+	if !ns.Valid {
+		return nil, nil
+	}
+	return ns.ParameterScope, nil
+}
+
+func (e ParameterScope) Valid() bool {
+	switch e {
+	case ParameterScopeTemplate,
+		ParameterScopeImportJob,
+		ParameterScopeWorkspace:
+		return true
+	}
+	return false
+}
+
+func AllParameterScopeValues() []ParameterScope {
+	return []ParameterScope{
+		ParameterScopeTemplate,
+		ParameterScopeImportJob,
+		ParameterScopeWorkspace,
+	}
+}
+
 type ParameterSourceScheme string
 
 const (
@@ -218,6 +594,45 @@ func (e *ParameterSourceScheme) Scan(src interface{}) error {
 	return nil
 }
 
+type NullParameterSourceScheme struct {
+	ParameterSourceScheme ParameterSourceScheme
+	Valid                 bool // Valid is true if ParameterSourceScheme is not NULL
+}
+
+// Scan implements the Scanner interface.
+func (ns *NullParameterSourceScheme) Scan(value interface{}) error {
+	if value == nil {
+		ns.ParameterSourceScheme, ns.Valid = "", false
+		return nil
+	}
+	ns.Valid = true
+	return ns.ParameterSourceScheme.Scan(value)
+}
+
+// Value implements the driver Valuer interface.
+func (ns NullParameterSourceScheme) Value() (driver.Value, error) {
+	if !ns.Valid {
+		return nil, nil
+	}
+	return ns.ParameterSourceScheme, nil
+}
+
+func (e ParameterSourceScheme) Valid() bool {
+	switch e {
+	case ParameterSourceSchemeNone,
+		ParameterSourceSchemeData:
+		return true
+	}
+	return false
+}
+
+func AllParameterSourceSchemeValues() []ParameterSourceScheme {
+	return []ParameterSourceScheme{
+		ParameterSourceSchemeNone,
+		ParameterSourceSchemeData,
+	}
+}
+
 type ParameterTypeSystem string
 
 const (
@@ -237,6 +652,45 @@ func (e *ParameterTypeSystem) Scan(src interface{}) error {
 	return nil
 }
 
+type NullParameterTypeSystem struct {
+	ParameterTypeSystem ParameterTypeSystem
+	Valid               bool // Valid is true if ParameterTypeSystem is not NULL
+}
+
+// Scan implements the Scanner interface.
+func (ns *NullParameterTypeSystem) Scan(value interface{}) error {
+	if value == nil {
+		ns.ParameterTypeSystem, ns.Valid = "", false
+		return nil
+	}
+	ns.Valid = true
+	return ns.ParameterTypeSystem.Scan(value)
+}
+
+// Value implements the driver Valuer interface.
+func (ns NullParameterTypeSystem) Value() (driver.Value, error) {
+	if !ns.Valid {
+		return nil, nil
+	}
+	return ns.ParameterTypeSystem, nil
+}
+
+func (e ParameterTypeSystem) Valid() bool {
+	switch e {
+	case ParameterTypeSystemNone,
+		ParameterTypeSystemHCL:
+		return true
+	}
+	return false
+}
+
+func AllParameterTypeSystemValues() []ParameterTypeSystem {
+	return []ParameterTypeSystem{
+		ParameterTypeSystemNone,
+		ParameterTypeSystemHCL,
+	}
+}
+
 type ProvisionerJobType string
 
 const (
@@ -257,6 +711,47 @@ func (e *ProvisionerJobType) Scan(src interface{}) error {
 	return nil
 }
 
+type NullProvisionerJobType struct {
+	ProvisionerJobType ProvisionerJobType
+	Valid              bool // Valid is true if ProvisionerJobType is not NULL
+}
+
+// Scan implements the Scanner interface.
+func (ns *NullProvisionerJobType) Scan(value interface{}) error {
+	if value == nil {
+		ns.ProvisionerJobType, ns.Valid = "", false
+		return nil
+	}
+	ns.Valid = true
+	return ns.ProvisionerJobType.Scan(value)
+}
+
+// Value implements the driver Valuer interface.
+func (ns NullProvisionerJobType) Value() (driver.Value, error) {
+	if !ns.Valid {
+		return nil, nil
+	}
+	return ns.ProvisionerJobType, nil
+}
+
+func (e ProvisionerJobType) Valid() bool {
+	switch e {
+	case ProvisionerJobTypeTemplateVersionImport,
+		ProvisionerJobTypeWorkspaceBuild,
+		ProvisionerJobTypeTemplateVersionDryRun:
+		return true
+	}
+	return false
+}
+
+func AllProvisionerJobTypeValues() []ProvisionerJobType {
+	return []ProvisionerJobType{
+		ProvisionerJobTypeTemplateVersionImport,
+		ProvisionerJobTypeWorkspaceBuild,
+		ProvisionerJobTypeTemplateVersionDryRun,
+	}
+}
+
 type ProvisionerStorageMethod string
 
 const (
@@ -275,6 +770,43 @@ func (e *ProvisionerStorageMethod) Scan(src interface{}) error {
 	return nil
 }
 
+type NullProvisionerStorageMethod struct {
+	ProvisionerStorageMethod ProvisionerStorageMethod
+	Valid                    bool // Valid is true if ProvisionerStorageMethod is not NULL
+}
+
+// Scan implements the Scanner interface.
+func (ns *NullProvisionerStorageMethod) Scan(value interface{}) error {
+	if value == nil {
+		ns.ProvisionerStorageMethod, ns.Valid = "", false
+		return nil
+	}
+	ns.Valid = true
+	return ns.ProvisionerStorageMethod.Scan(value)
+}
+
+// Value implements the driver Valuer interface.
+func (ns NullProvisionerStorageMethod) Value() (driver.Value, error) {
+	if !ns.Valid {
+		return nil, nil
+	}
+	return ns.ProvisionerStorageMethod, nil
+}
+
+func (e ProvisionerStorageMethod) Valid() bool {
+	switch e {
+	case ProvisionerStorageMethodFile:
+		return true
+	}
+	return false
+}
+
+func AllProvisionerStorageMethodValues() []ProvisionerStorageMethod {
+	return []ProvisionerStorageMethod{
+		ProvisionerStorageMethodFile,
+	}
+}
+
 type ProvisionerType string
 
 const (
@@ -294,6 +826,45 @@ func (e *ProvisionerType) Scan(src interface{}) error {
 	return nil
 }
 
+type NullProvisionerType struct {
+	ProvisionerType ProvisionerType
+	Valid           bool // Valid is true if ProvisionerType is not NULL
+}
+
+// Scan implements the Scanner interface.
+func (ns *NullProvisionerType) Scan(value interface{}) error {
+	if value == nil {
+		ns.ProvisionerType, ns.Valid = "", false
+		return nil
+	}
+	ns.Valid = true
+	return ns.ProvisionerType.Scan(value)
+}
+
+// Value implements the driver Valuer interface.
+func (ns NullProvisionerType) Value() (driver.Value, error) {
+	if !ns.Valid {
+		return nil, nil
+	}
+	return ns.ProvisionerType, nil
+}
+
+func (e ProvisionerType) Valid() bool {
+	switch e {
+	case ProvisionerTypeEcho,
+		ProvisionerTypeTerraform:
+		return true
+	}
+	return false
+}
+
+func AllProvisionerTypeValues() []ProvisionerType {
+	return []ProvisionerType{
+		ProvisionerTypeEcho,
+		ProvisionerTypeTerraform,
+	}
+}
+
 type ResourceType string
 
 const (
@@ -320,6 +891,59 @@ func (e *ResourceType) Scan(src interface{}) error {
 	return nil
 }
 
+type NullResourceType struct {
+	ResourceType ResourceType
+	Valid        bool // Valid is true if ResourceType is not NULL
+}
+
+// Scan implements the Scanner interface.
+func (ns *NullResourceType) Scan(value interface{}) error {
+	if value == nil {
+		ns.ResourceType, ns.Valid = "", false
+		return nil
+	}
+	ns.Valid = true
+	return ns.ResourceType.Scan(value)
+}
+
+// Value implements the driver Valuer interface.
+func (ns NullResourceType) Value() (driver.Value, error) {
+	if !ns.Valid {
+		return nil, nil
+	}
+	return ns.ResourceType, nil
+}
+
+func (e ResourceType) Valid() bool {
+	switch e {
+	case ResourceTypeOrganization,
+		ResourceTypeTemplate,
+		ResourceTypeTemplateVersion,
+		ResourceTypeUser,
+		ResourceTypeWorkspace,
+		ResourceTypeGitSshKey,
+		ResourceTypeApiKey,
+		ResourceTypeGroup,
+		ResourceTypeWorkspaceBuild:
+		return true
+	}
+	return false
+}
+
+func AllResourceTypeValues() []ResourceType {
+	return []ResourceType{
+		ResourceTypeOrganization,
+		ResourceTypeTemplate,
+		ResourceTypeTemplateVersion,
+		ResourceTypeUser,
+		ResourceTypeWorkspace,
+		ResourceTypeGitSshKey,
+		ResourceTypeApiKey,
+		ResourceTypeGroup,
+		ResourceTypeWorkspaceBuild,
+	}
+}
+
 type UserStatus string
 
 const (
@@ -339,6 +963,45 @@ func (e *UserStatus) Scan(src interface{}) error {
 	return nil
 }
 
+type NullUserStatus struct {
+	UserStatus UserStatus
+	Valid      bool // Valid is true if UserStatus is not NULL
+}
+
+// Scan implements the Scanner interface.
+func (ns *NullUserStatus) Scan(value interface{}) error {
+	if value == nil {
+		ns.UserStatus, ns.Valid = "", false
+		return nil
+	}
+	ns.Valid = true
+	return ns.UserStatus.Scan(value)
+}
+
+// Value implements the driver Valuer interface.
+func (ns NullUserStatus) Value() (driver.Value, error) {
+	if !ns.Valid {
+		return nil, nil
+	}
+	return ns.UserStatus, nil
+}
+
+func (e UserStatus) Valid() bool {
+	switch e {
+	case UserStatusActive,
+		UserStatusSuspended:
+		return true
+	}
+	return false
+}
+
+func AllUserStatusValues() []UserStatus {
+	return []UserStatus{
+		UserStatusActive,
+		UserStatusSuspended,
+	}
+}
+
 type WorkspaceAppHealth string
 
 const (
@@ -360,6 +1023,49 @@ func (e *WorkspaceAppHealth) Scan(src interface{}) error {
 	return nil
 }
 
+type NullWorkspaceAppHealth struct {
+	WorkspaceAppHealth WorkspaceAppHealth
+	Valid              bool // Valid is true if WorkspaceAppHealth is not NULL
+}
+
+// Scan implements the Scanner interface.
+func (ns *NullWorkspaceAppHealth) Scan(value interface{}) error {
+	if value == nil {
+		ns.WorkspaceAppHealth, ns.Valid = "", false
+		return nil
+	}
+	ns.Valid = true
+	return ns.WorkspaceAppHealth.Scan(value)
+}
+
+// Value implements the driver Valuer interface.
+func (ns NullWorkspaceAppHealth) Value() (driver.Value, error) {
+	if !ns.Valid {
+		return nil, nil
+	}
+	return ns.WorkspaceAppHealth, nil
+}
+
+func (e WorkspaceAppHealth) Valid() bool {
+	switch e {
+	case WorkspaceAppHealthDisabled,
+		WorkspaceAppHealthInitializing,
+		WorkspaceAppHealthHealthy,
+		WorkspaceAppHealthUnhealthy:
+		return true
+	}
+	return false
+}
+
+func AllWorkspaceAppHealthValues() []WorkspaceAppHealth {
+	return []WorkspaceAppHealth{
+		WorkspaceAppHealthDisabled,
+		WorkspaceAppHealthInitializing,
+		WorkspaceAppHealthHealthy,
+		WorkspaceAppHealthUnhealthy,
+	}
+}
+
 type WorkspaceTransition string
 
 const (
@@ -380,6 +1086,47 @@ func (e *WorkspaceTransition) Scan(src interface{}) error {
 	return nil
 }
 
+type NullWorkspaceTransition struct {
+	WorkspaceTransition WorkspaceTransition
+	Valid               bool // Valid is true if WorkspaceTransition is not NULL
+}
+
+// Scan implements the Scanner interface.
+func (ns *NullWorkspaceTransition) Scan(value interface{}) error {
+	if value == nil {
+		ns.WorkspaceTransition, ns.Valid = "", false
+		return nil
+	}
+	ns.Valid = true
+	return ns.WorkspaceTransition.Scan(value)
+}
+
+// Value implements the driver Valuer interface.
+func (ns NullWorkspaceTransition) Value() (driver.Value, error) {
+	if !ns.Valid {
+		return nil, nil
+	}
+	return ns.WorkspaceTransition, nil
+}
+
+func (e WorkspaceTransition) Valid() bool {
+	switch e {
+	case WorkspaceTransitionStart,
+		WorkspaceTransitionStop,
+		WorkspaceTransitionDelete:
+		return true
+	}
+	return false
+}
+
+func AllWorkspaceTransitionValues() []WorkspaceTransition {
+	return []WorkspaceTransition{
+		WorkspaceTransitionStart,
+		WorkspaceTransitionStop,
+		WorkspaceTransitionDelete,
+	}
+}
+
 type APIKey struct {
 	ID string `db:"id" json:"id"`
 	// hashed_secret contains a SHA256 hash of the key secret. This is considered a secret and MUST NOT be returned from the API as it is used for API key encryption in app proxying code.

coderd/database/querier.go

@@ -1,6 +1,6 @@
 // Code generated by sqlc. DO NOT EDIT.
 // versions:
-//   sqlc v1.13.0
+//   sqlc v1.16.0
 
 package database
 

coderd/database/queries.sql.go

@@ -1,6 +1,6 @@
 // Code generated by sqlc. DO NOT EDIT.
 // versions:
-//   sqlc v1.13.0
+//   sqlc v1.16.0
 
 package database
 
@@ -468,7 +468,7 @@ type GetAuditLogsOffsetRow struct {
 	UserUsername     sql.NullString  `db:"user_username" json:"user_username"`
 	UserEmail        sql.NullString  `db:"user_email" json:"user_email"`
 	UserCreatedAt    sql.NullTime    `db:"user_created_at" json:"user_created_at"`
-	UserStatus       UserStatus      `db:"user_status" json:"user_status"`
+	UserStatus       NullUserStatus  `db:"user_status" json:"user_status"`
 	UserRoles        []string        `db:"user_roles" json:"user_roles"`
 	UserAvatarUrl    sql.NullString  `db:"user_avatar_url" json:"user_avatar_url"`
 	Count            int64           `db:"count" json:"count"`

coderd/database/sqlc.yaml

@@ -55,3 +55,5 @@ sql:
         emit_interface: true
         emit_json_tags: true
         emit_db_tags: true
+        emit_enum_valid_method: true
+        emit_all_enum_values: true

coderd/httpmw/apikey_test.go

@@ -165,6 +165,7 @@ func TestAPIKey(t *testing.T) {
 			ID:           id,
 			HashedSecret: hashed[:],
 			UserID:       user.ID,
+			LoginType:    database.LoginTypePassword,
 			Scope:        database.APIKeyScopeAll,
 		})
 		require.NoError(t, err)
@@ -640,6 +641,7 @@ func createUser(ctx context.Context, t *testing.T, db database.Store, opts ...fu
 		CreatedAt:      time.Now(),
 		UpdatedAt:      time.Now(),
 		RBACRoles:      []string{},
+		LoginType:      database.LoginTypePassword,
 	}
 	for _, opt := range opts {
 		opt(&insert)

coderd/httpmw/organizationparam_test.go

@@ -42,6 +42,7 @@ func TestOrganizationParam(t *testing.T) {
 			Username:       username,
 			CreatedAt:      database.Now(),
 			UpdatedAt:      database.Now(),
+			LoginType:      database.LoginTypePassword,
 		})
 		require.NoError(t, err)
 		_, err = db.InsertAPIKey(r.Context(), database.InsertAPIKeyParams{

coderd/httpmw/templateparam_test.go

@@ -41,6 +41,7 @@ func TestTemplateParam(t *testing.T) {
 			Username:       username,
 			CreatedAt:      database.Now(),
 			UpdatedAt:      database.Now(),
+			LoginType:      database.LoginTypePassword,
 		})
 		require.NoError(t, err)
 
@@ -149,6 +150,7 @@ func TestTemplateParam(t *testing.T) {
 			ID:             uuid.New(),
 			OrganizationID: org.ID,
 			Name:           "moo",
+			Provisioner:    database.ProvisionerTypeEcho,
 		})
 		require.NoError(t, err)
 		chi.RouteContext(r.Context()).URLParams.Add("template", template.ID.String())

coderd/httpmw/templateversionparam_test.go

@@ -41,6 +41,7 @@ func TestTemplateVersionParam(t *testing.T) {
 			Username:       username,
 			CreatedAt:      database.Now(),
 			UpdatedAt:      database.Now(),
+			LoginType:      database.LoginTypePassword,
 		})
 		require.NoError(t, err)
 
@@ -77,6 +78,7 @@ func TestTemplateVersionParam(t *testing.T) {
 			ID:             uuid.New(),
 			OrganizationID: organization.ID,
 			Name:           "moo",
+			Provisioner:    database.ProvisionerTypeEcho,
 		})
 		require.NoError(t, err)
 

coderd/httpmw/userparam_test.go

@@ -32,9 +32,10 @@ func TestUserParam(t *testing.T) {
 		r.Header.Set(codersdk.SessionCustomHeader, fmt.Sprintf("%s-%s", id, secret))
 
 		user, err := db.InsertUser(r.Context(), database.InsertUserParams{
-			ID:       uuid.New(),
-			Email:    "admin@email.com",
-			Username: "admin",
+			ID:        uuid.New(),
+			Email:     "admin@email.com",
+			Username:  "admin",
+			LoginType: database.LoginTypePassword,
 		})
 		require.NoError(t, err)
 

coderd/httpmw/workspaceagentparam_test.go

@@ -41,6 +41,7 @@ func TestWorkspaceAgentParam(t *testing.T) {
 			Username:       username,
 			CreatedAt:      database.Now(),
 			UpdatedAt:      database.Now(),
+			LoginType:      database.LoginTypePassword,
 		})
 		require.NoError(t, err)
 
@@ -67,18 +68,23 @@ func TestWorkspaceAgentParam(t *testing.T) {
 			ID:          uuid.New(),
 			WorkspaceID: workspace.ID,
 			JobID:       uuid.New(),
+			Transition:  database.WorkspaceTransitionStart,
+			Reason:      database.BuildReasonInitiator,
 		})
 		require.NoError(t, err)
 
 		job, err := db.InsertProvisionerJob(context.Background(), database.InsertProvisionerJobParams{
-			ID:   build.JobID,
-			Type: database.ProvisionerJobTypeWorkspaceBuild,
+			ID:            build.JobID,
+			Type:          database.ProvisionerJobTypeWorkspaceBuild,
+			Provisioner:   database.ProvisionerTypeEcho,
+			StorageMethod: database.ProvisionerStorageMethodFile,
 		})
 		require.NoError(t, err)
 
 		resource, err := db.InsertWorkspaceResource(context.Background(), database.InsertWorkspaceResourceParams{
-			ID:    uuid.New(),
-			JobID: job.ID,
+			ID:         uuid.New(),
+			JobID:      job.ID,
+			Transition: database.WorkspaceTransitionStart,
 		})
 		require.NoError(t, err)
 

coderd/httpmw/workspacebuildparam_test.go

@@ -41,6 +41,7 @@ func TestWorkspaceBuildParam(t *testing.T) {
 			Username:       username,
 			CreatedAt:      database.Now(),
 			UpdatedAt:      database.Now(),
+			LoginType:      database.LoginTypePassword,
 		})
 		require.NoError(t, err)
 
@@ -123,6 +124,8 @@ func TestWorkspaceBuildParam(t *testing.T) {
 		workspaceBuild, err := db.InsertWorkspaceBuild(context.Background(), database.InsertWorkspaceBuildParams{
 			ID:          uuid.New(),
 			WorkspaceID: workspace.ID,
+			Transition:  database.WorkspaceTransitionStart,
+			Reason:      database.BuildReasonInitiator,
 		})
 		require.NoError(t, err)
 		chi.RouteContext(r.Context()).URLParams.Add("workspacebuild", workspaceBuild.ID.String())

coderd/httpmw/workspaceparam_test.go

@@ -44,6 +44,7 @@ func TestWorkspaceParam(t *testing.T) {
 			Username:       username,
 			CreatedAt:      database.Now(),
 			UpdatedAt:      database.Now(),
+			LoginType:      database.LoginTypePassword,
 		})
 		require.NoError(t, err)
 
@@ -356,6 +357,7 @@ func setupWorkspaceWithAgents(t testing.TB, cfg setupConfig) (database.Store, *h
 		Username:       username,
 		CreatedAt:      database.Now(),
 		UpdatedAt:      database.Now(),
+		LoginType:      database.LoginTypePassword,
 	})
 	require.NoError(t, err)
 
@@ -382,20 +384,25 @@ func setupWorkspaceWithAgents(t testing.TB, cfg setupConfig) (database.Store, *h
 		ID:          uuid.New(),
 		WorkspaceID: workspace.ID,
 		JobID:       uuid.New(),
+		Transition:  database.WorkspaceTransitionStart,
+		Reason:      database.BuildReasonInitiator,
 	})
 	require.NoError(t, err)
 
 	job, err := db.InsertProvisionerJob(context.Background(), database.InsertProvisionerJobParams{
-		ID:   build.JobID,
-		Type: database.ProvisionerJobTypeWorkspaceBuild,
+		ID:            build.JobID,
+		Type:          database.ProvisionerJobTypeWorkspaceBuild,
+		Provisioner:   database.ProvisionerTypeEcho,
+		StorageMethod: database.ProvisionerStorageMethodFile,
 	})
 	require.NoError(t, err)
 
 	for resourceName, agentNames := range cfg.Agents {
 		resource, err := db.InsertWorkspaceResource(context.Background(), database.InsertWorkspaceResourceParams{
-			ID:    uuid.New(),
-			JobID: job.ID,
-			Name:  resourceName,
+			ID:         uuid.New(),
+			JobID:      job.ID,
+			Name:       resourceName,
+			Transition: database.WorkspaceTransitionStart,
 		})
 		require.NoError(t, err)
 

coderd/httpmw/workspaceresourceparam_test.go

@@ -21,18 +21,23 @@ func TestWorkspaceResourceParam(t *testing.T) {
 	setup := func(db database.Store, jobType database.ProvisionerJobType) (*http.Request, database.WorkspaceResource) {
 		r := httptest.NewRequest("GET", "/", nil)
 		job, err := db.InsertProvisionerJob(context.Background(), database.InsertProvisionerJobParams{
-			ID:   uuid.New(),
-			Type: jobType,
+			ID:            uuid.New(),
+			Type:          jobType,
+			Provisioner:   database.ProvisionerTypeEcho,
+			StorageMethod: database.ProvisionerStorageMethodFile,
 		})
 		require.NoError(t, err)
 		workspaceBuild, err := db.InsertWorkspaceBuild(context.Background(), database.InsertWorkspaceBuildParams{
-			ID:    uuid.New(),
-			JobID: job.ID,
+			ID:         uuid.New(),
+			JobID:      job.ID,
+			Transition: database.WorkspaceTransitionStart,
+			Reason:     database.BuildReasonInitiator,
 		})
 		require.NoError(t, err)
 		resource, err := db.InsertWorkspaceResource(context.Background(), database.InsertWorkspaceResourceParams{
-			ID:    uuid.New(),
-			JobID: job.ID,
+			ID:         uuid.New(),
+			JobID:      job.ID,
+			Transition: database.WorkspaceTransitionStart,
 		})
 		require.NoError(t, err)
 

coderd/metricscache/metricscache_test.go

@@ -42,35 +42,36 @@ func TestCache_TemplateUsers(t *testing.T) {
 		want want
 	}{
 		{"empty", args{}, want{nil, 0}},
-		{"one hole", args{
-			rows: []database.InsertAgentStatParams{
+		{
+			"one hole", args{
+				rows: []database.InsertAgentStatParams{
+					{
+						CreatedAt: date(2022, 8, 27),
+						UserID:    zebra,
+					},
+					{
+						CreatedAt: date(2022, 8, 30),
+						UserID:    zebra,
+					},
+				},
+			}, want{[]codersdk.DAUEntry{
 				{
-					CreatedAt: date(2022, 8, 27),
-					UserID:    zebra,
+					Date:   date(2022, 8, 27),
+					Amount: 1,
 				},
 				{
-					CreatedAt: date(2022, 8, 30),
-					UserID:    zebra,
+					Date:   date(2022, 8, 28),
+					Amount: 0,
 				},
-			},
-		}, want{[]codersdk.DAUEntry{
-			{
-				Date:   date(2022, 8, 27),
-				Amount: 1,
-			},
-			{
-				Date:   date(2022, 8, 28),
-				Amount: 0,
-			},
-			{
-				Date:   date(2022, 8, 29),
-				Amount: 0,
-			},
-			{
-				Date:   date(2022, 8, 30),
-				Amount: 1,
-			},
-		}, 1},
+				{
+					Date:   date(2022, 8, 29),
+					Amount: 0,
+				},
+				{
+					Date:   date(2022, 8, 30),
+					Amount: 1,
+				},
+			}, 1},
 		},
 		{"no holes", args{
 			rows: []database.InsertAgentStatParams{
@@ -169,7 +170,8 @@ func TestCache_TemplateUsers(t *testing.T) {
 
 			templateID := uuid.New()
 			db.InsertTemplate(context.Background(), database.InsertTemplateParams{
-				ID: templateID,
+				ID:          templateID,
+				Provisioner: database.ProvisionerTypeEcho,
 			})
 
 			gotUniqueUsers, ok := cache.TemplateUniqueUsers(templateID)
@@ -233,46 +235,50 @@ func TestCache_BuildTime(t *testing.T) {
 		want want
 	}{
 		{"empty", args{}, want{-1, false}},
-		{"one/start", args{
-			rows: []jobParams{
-				{
-					startedAt:   clockTime(someDay, 10, 1, 0),
-					completedAt: clockTime(someDay, 10, 1, 10),
+		{
+			"one/start", args{
+				rows: []jobParams{
+					{
+						startedAt:   clockTime(someDay, 10, 1, 0),
+						completedAt: clockTime(someDay, 10, 1, 10),
+					},
 				},
-			},
-			transition: database.WorkspaceTransitionStart,
-		}, want{10 * 1000, true},
+				transition: database.WorkspaceTransitionStart,
+			}, want{10 * 1000, true},
 		},
-		{"two/stop", args{
-			rows: []jobParams{
-				{
-					startedAt:   clockTime(someDay, 10, 1, 0),
-					completedAt: clockTime(someDay, 10, 1, 10),
+		{
+			"two/stop", args{
+				rows: []jobParams{
+					{
+						startedAt:   clockTime(someDay, 10, 1, 0),
+						completedAt: clockTime(someDay, 10, 1, 10),
+					},
+					{
+						startedAt:   clockTime(someDay, 10, 1, 0),
+						completedAt: clockTime(someDay, 10, 1, 50),
+					},
 				},
-				{
-					startedAt:   clockTime(someDay, 10, 1, 0),
-					completedAt: clockTime(someDay, 10, 1, 50),
-				},
-			},
-			transition: database.WorkspaceTransitionStop,
-		}, want{50 * 1000, true},
+				transition: database.WorkspaceTransitionStop,
+			}, want{50 * 1000, true},
 		},
-		{"three/delete", args{
-			rows: []jobParams{
-				{
-					startedAt:   clockTime(someDay, 10, 1, 0),
-					completedAt: clockTime(someDay, 10, 1, 10),
+		{
+			"three/delete", args{
+				rows: []jobParams{
+					{
+						startedAt:   clockTime(someDay, 10, 1, 0),
+						completedAt: clockTime(someDay, 10, 1, 10),
+					},
+					{
+						startedAt:   clockTime(someDay, 10, 1, 0),
+						completedAt: clockTime(someDay, 10, 1, 50),
+					},
+					{
+						startedAt:   clockTime(someDay, 10, 1, 0),
+						completedAt: clockTime(someDay, 10, 1, 20),
+					},
 				},
-				{
-					startedAt:   clockTime(someDay, 10, 1, 0),
-					completedAt: clockTime(someDay, 10, 1, 50),
-				}, {
-					startedAt:   clockTime(someDay, 10, 1, 0),
-					completedAt: clockTime(someDay, 10, 1, 20),
-				},
-			},
-			transition: database.WorkspaceTransitionDelete,
-		}, want{20 * 1000, true},
+				transition: database.WorkspaceTransitionDelete,
+			}, want{20 * 1000, true},
 		},
 	}
 
@@ -290,7 +296,8 @@ func TestCache_BuildTime(t *testing.T) {
 			defer cache.Close()
 
 			template, err := db.InsertTemplate(ctx, database.InsertTemplateParams{
-				ID: uuid.New(),
+				ID:          uuid.New(),
+				Provisioner: database.ProvisionerTypeEcho,
 			})
 			require.NoError(t, err)
 
@@ -305,8 +312,10 @@ func TestCache_BuildTime(t *testing.T) {
 
 			for _, row := range tt.args.rows {
 				_, err := db.InsertProvisionerJob(ctx, database.InsertProvisionerJobParams{
-					ID:          uuid.New(),
-					Provisioner: database.ProvisionerTypeEcho,
+					ID:            uuid.New(),
+					Provisioner:   database.ProvisionerTypeEcho,
+					StorageMethod: database.ProvisionerStorageMethodFile,
+					Type:          database.ProvisionerJobTypeWorkspaceBuild,
 				})
 				require.NoError(t, err)
 
@@ -322,6 +331,7 @@ func TestCache_BuildTime(t *testing.T) {
 					TemplateVersionID: templateVersion.ID,
 					JobID:             job.ID,
 					Transition:        tt.args.transition,
+					Reason:            database.BuildReasonInitiator,
 				})
 				require.NoError(t, err)
 

coderd/parameter/compute_test.go

@@ -51,6 +51,7 @@ func TestCompute(t *testing.T) {
 			AllowOverrideSource:      opts.AllowOverrideSource,
 			AllowOverrideDestination: opts.AllowOverrideDestination,
 			DefaultDestinationScheme: opts.DefaultDestinationScheme,
+			ValidationTypeSystem:     database.ParameterTypeSystemNone,
 		})
 		require.NoError(t, err)
 		return param
@@ -61,10 +62,12 @@ func TestCompute(t *testing.T) {
 		db := databasefake.New()
 		scope := generateScope()
 		_, err := db.InsertParameterSchema(context.Background(), database.InsertParameterSchemaParams{
-			ID:                  uuid.New(),
-			JobID:               scope.TemplateImportJobID,
-			Name:                "hey",
-			DefaultSourceScheme: database.ParameterSourceSchemeNone,
+			ID:                       uuid.New(),
+			JobID:                    scope.TemplateImportJobID,
+			Name:                     "hey",
+			DefaultSourceScheme:      database.ParameterSourceSchemeNone,
+			DefaultDestinationScheme: database.ParameterDestinationSchemeNone,
+			ValidationTypeSystem:     database.ParameterTypeSystemNone,
 		})
 		require.NoError(t, err)
 		computed, err := parameter.Compute(context.Background(), db, scope, nil)

coderd/prometheusmetrics/prometheusmetrics_test.go

@@ -36,9 +36,10 @@ func TestActiveUsers(t *testing.T) {
 		Database: func() database.Store {
 			db := databasefake.New()
 			_, _ = db.InsertAPIKey(context.Background(), database.InsertAPIKeyParams{
-				UserID:   uuid.New(),
-				LastUsed: database.Now(),
-				Scope:    database.APIKeyScopeAll,
+				UserID:    uuid.New(),
+				LastUsed:  database.Now(),
+				LoginType: database.LoginTypePassword,
+				Scope:     database.APIKeyScopeAll,
 			})
 			return db
 		},
@@ -48,16 +49,18 @@ func TestActiveUsers(t *testing.T) {
 		Database: func() database.Store {
 			db := databasefake.New()
 			_, _ = db.InsertAPIKey(context.Background(), database.InsertAPIKeyParams{
-				UserID:   uuid.New(),
-				LastUsed: database.Now(),
-				Scope:    database.APIKeyScopeAll,
+				UserID:    uuid.New(),
+				LastUsed:  database.Now(),
+				LoginType: database.LoginTypePassword,
+				Scope:     database.APIKeyScopeAll,
 			})
 			// Because this API key hasn't been used in the past hour, this shouldn't
 			// add to the user count.
 			_, _ = db.InsertAPIKey(context.Background(), database.InsertAPIKeyParams{
-				UserID:   uuid.New(),
-				LastUsed: database.Now().Add(-2 * time.Hour),
-				Scope:    database.APIKeyScopeAll,
+				UserID:    uuid.New(),
+				LastUsed:  database.Now().Add(-2 * time.Hour),
+				LoginType: database.LoginTypePassword,
+				Scope:     database.APIKeyScopeAll,
 			})
 			return db
 		},
@@ -67,14 +70,16 @@ func TestActiveUsers(t *testing.T) {
 		Database: func() database.Store {
 			db := databasefake.New()
 			_, _ = db.InsertAPIKey(context.Background(), database.InsertAPIKeyParams{
-				UserID:   uuid.New(),
-				LastUsed: database.Now(),
-				Scope:    database.APIKeyScopeAll,
+				UserID:    uuid.New(),
+				LastUsed:  database.Now(),
+				LoginType: database.LoginTypePassword,
+				Scope:     database.APIKeyScopeAll,
 			})
 			_, _ = db.InsertAPIKey(context.Background(), database.InsertAPIKeyParams{
-				UserID:   uuid.New(),
-				LastUsed: database.Now(),
-				Scope:    database.APIKeyScopeAll,
+				UserID:    uuid.New(),
+				LastUsed:  database.Now(),
+				LoginType: database.LoginTypePassword,
+				Scope:     database.APIKeyScopeAll,
 			})
 			return db
 		},
@@ -102,50 +107,59 @@ func TestWorkspaces(t *testing.T) {
 	t.Parallel()
 
 	insertRunning := func(db database.Store) database.ProvisionerJob {
-		job, _ := db.InsertProvisionerJob(context.Background(), database.InsertProvisionerJobParams{
-			ID:          uuid.New(),
-			CreatedAt:   database.Now(),
-			UpdatedAt:   database.Now(),
-			Provisioner: database.ProvisionerTypeEcho,
+		job, err := db.InsertProvisionerJob(context.Background(), database.InsertProvisionerJobParams{
+			ID:            uuid.New(),
+			CreatedAt:     database.Now(),
+			UpdatedAt:     database.Now(),
+			Provisioner:   database.ProvisionerTypeEcho,
+			StorageMethod: database.ProvisionerStorageMethodFile,
+			Type:          database.ProvisionerJobTypeWorkspaceBuild,
 		})
-		_, _ = db.InsertWorkspaceBuild(context.Background(), database.InsertWorkspaceBuildParams{
+		require.NoError(t, err)
+		_, err = db.InsertWorkspaceBuild(context.Background(), database.InsertWorkspaceBuildParams{
 			ID:          uuid.New(),
 			WorkspaceID: uuid.New(),
 			JobID:       job.ID,
 			BuildNumber: 1,
+			Transition:  database.WorkspaceTransitionStart,
+			Reason:      database.BuildReasonInitiator,
 		})
+		require.NoError(t, err)
 		// This marks the job as started.
-		_, _ = db.AcquireProvisionerJob(context.Background(), database.AcquireProvisionerJobParams{
+		_, err = db.AcquireProvisionerJob(context.Background(), database.AcquireProvisionerJobParams{
 			StartedAt: sql.NullTime{
 				Time:  database.Now(),
 				Valid: true,
 			},
 			Types: []database.ProvisionerType{database.ProvisionerTypeEcho},
 		})
+		require.NoError(t, err)
 		return job
 	}
 
 	insertCanceled := func(db database.Store) {
 		job := insertRunning(db)
-		_ = db.UpdateProvisionerJobWithCancelByID(context.Background(), database.UpdateProvisionerJobWithCancelByIDParams{
+		err := db.UpdateProvisionerJobWithCancelByID(context.Background(), database.UpdateProvisionerJobWithCancelByIDParams{
 			ID: job.ID,
 			CanceledAt: sql.NullTime{
 				Time:  database.Now(),
 				Valid: true,
 			},
 		})
-		_ = db.UpdateProvisionerJobWithCompleteByID(context.Background(), database.UpdateProvisionerJobWithCompleteByIDParams{
+		require.NoError(t, err)
+		err = db.UpdateProvisionerJobWithCompleteByID(context.Background(), database.UpdateProvisionerJobWithCompleteByIDParams{
 			ID: job.ID,
 			CompletedAt: sql.NullTime{
 				Time:  database.Now(),
 				Valid: true,
 			},
 		})
+		require.NoError(t, err)
 	}
 
 	insertFailed := func(db database.Store) {
 		job := insertRunning(db)
-		_ = db.UpdateProvisionerJobWithCompleteByID(context.Background(), database.UpdateProvisionerJobWithCompleteByIDParams{
+		err := db.UpdateProvisionerJobWithCompleteByID(context.Background(), database.UpdateProvisionerJobWithCompleteByIDParams{
 			ID: job.ID,
 			CompletedAt: sql.NullTime{
 				Time:  database.Now(),
@@ -156,17 +170,19 @@ func TestWorkspaces(t *testing.T) {
 				Valid:  true,
 			},
 		})
+		require.NoError(t, err)
 	}
 
 	insertSuccess := func(db database.Store) {
 		job := insertRunning(db)
-		_ = db.UpdateProvisionerJobWithCompleteByID(context.Background(), database.UpdateProvisionerJobWithCompleteByIDParams{
+		err := db.UpdateProvisionerJobWithCompleteByID(context.Background(), database.UpdateProvisionerJobWithCompleteByIDParams{
 			ID: job.ID,
 			CompletedAt: sql.NullTime{
 				Time:  database.Now(),
 				Valid: true,
 			},
 		})
+		require.NoError(t, err)
 	}
 
 	for _, tc := range []struct {

coderd/provisionerdserver/provisionerdserver.go

@@ -535,13 +535,13 @@ func (server *Server) FailJob(ctx context.Context, failJob *proto.FailedJob) (*p
 	// if failed job is a workspace build, audit the outcome
 	if job.Type == database.ProvisionerJobTypeWorkspaceBuild {
 		auditor := server.Auditor.Load()
-		build, getBuildErr := server.Database.GetWorkspaceBuildByJobID(ctx, job.ID)
-		if getBuildErr != nil {
+		build, err := server.Database.GetWorkspaceBuildByJobID(ctx, job.ID)
+		if err != nil {
 			server.Logger.Error(ctx, "audit log - get build", slog.Error(err))
 		} else {
 			auditAction := auditActionFromTransition(build.Transition)
-			workspace, getWorkspaceErr := server.Database.GetWorkspaceByID(ctx, build.WorkspaceID)
-			if getWorkspaceErr != nil {
+			workspace, err := server.Database.GetWorkspaceByID(ctx, build.WorkspaceID)
+			if err != nil {
 				server.Logger.Error(ctx, "audit log - get workspace", slog.Error(err))
 			} else {
 				// We pass the below information to the Auditor so that it

coderd/provisionerdserver/provisionerdserver_test.go

@@ -51,9 +51,11 @@ func TestAcquireJob(t *testing.T) {
 		require.NoError(t, err)
 		require.Equal(t, &proto.AcquiredJob{}, job)
 		_, err = srv.Database.InsertProvisionerJob(context.Background(), database.InsertProvisionerJobParams{
-			ID:          uuid.New(),
-			InitiatorID: uuid.New(),
-			Provisioner: database.ProvisionerTypeEcho,
+			ID:            uuid.New(),
+			InitiatorID:   uuid.New(),
+			Provisioner:   database.ProvisionerTypeEcho,
+			StorageMethod: database.ProvisionerStorageMethodFile,
+			Type:          database.ProvisionerJobTypeTemplateVersionDryRun,
 		})
 		require.NoError(t, err)
 		job, err = srv.AcquireJob(context.Background(), nil)
@@ -62,18 +64,20 @@ func TestAcquireJob(t *testing.T) {
 	})
 	t.Run("NoJobs", func(t *testing.T) {
 		t.Parallel()
-		srv := setup(t)
+		srv := setup(t, false)
 		job, err := srv.AcquireJob(context.Background(), nil)
 		require.NoError(t, err)
 		require.Equal(t, &proto.AcquiredJob{}, job)
 	})
 	t.Run("InitiatorNotFound", func(t *testing.T) {
 		t.Parallel()
-		srv := setup(t)
+		srv := setup(t, false)
 		_, err := srv.Database.InsertProvisionerJob(context.Background(), database.InsertProvisionerJobParams{
-			ID:          uuid.New(),
-			InitiatorID: uuid.New(),
-			Provisioner: database.ProvisionerTypeEcho,
+			ID:            uuid.New(),
+			InitiatorID:   uuid.New(),
+			Provisioner:   database.ProvisionerTypeEcho,
+			StorageMethod: database.ProvisionerStorageMethodFile,
+			Type:          database.ProvisionerJobTypeTemplateVersionDryRun,
 		})
 		require.NoError(t, err)
 		_, err = srv.AcquireJob(context.Background(), nil)
@@ -81,16 +85,18 @@ func TestAcquireJob(t *testing.T) {
 	})
 	t.Run("WorkspaceBuildJob", func(t *testing.T) {
 		t.Parallel()
-		srv := setup(t)
+		srv := setup(t, false)
 		ctx := context.Background()
 		user, err := srv.Database.InsertUser(context.Background(), database.InsertUserParams{
-			ID:       uuid.New(),
-			Username: "testing",
+			ID:        uuid.New(),
+			Username:  "testing",
+			LoginType: database.LoginTypePassword,
 		})
 		require.NoError(t, err)
 		template, err := srv.Database.InsertTemplate(ctx, database.InsertTemplateParams{
-			ID:   uuid.New(),
-			Name: "template",
+			ID:          uuid.New(),
+			Name:        "template",
+			Provisioner: database.ProvisionerTypeEcho,
 		})
 		require.NoError(t, err)
 		version, err := srv.Database.InsertTemplateVersion(ctx, database.InsertTemplateVersionParams{
@@ -116,6 +122,7 @@ func TestAcquireJob(t *testing.T) {
 			JobID:             uuid.New(),
 			TemplateVersionID: version.ID,
 			Transition:        database.WorkspaceTransitionStart,
+			Reason:            database.BuildReasonInitiator,
 		})
 		require.NoError(t, err)
 
@@ -182,11 +189,12 @@ func TestAcquireJob(t *testing.T) {
 	})
 	t.Run("TemplateVersionDryRun", func(t *testing.T) {
 		t.Parallel()
-		srv := setup(t)
+		srv := setup(t, false)
 		ctx := context.Background()
 		user, err := srv.Database.InsertUser(ctx, database.InsertUserParams{
-			ID:       uuid.New(),
-			Username: "testing",
+			ID:        uuid.New(),
+			Username:  "testing",
+			LoginType: database.LoginTypePassword,
 		})
 		require.NoError(t, err)
 		version, err := srv.Database.InsertTemplateVersion(ctx, database.InsertTemplateVersionParams{
@@ -242,11 +250,12 @@ func TestAcquireJob(t *testing.T) {
 	})
 	t.Run("TemplateVersionImport", func(t *testing.T) {
 		t.Parallel()
-		srv := setup(t)
+		srv := setup(t, false)
 		ctx := context.Background()
 		user, err := srv.Database.InsertUser(ctx, database.InsertUserParams{
-			ID:       uuid.New(),
-			Username: "testing",
+			ID:        uuid.New(),
+			Username:  "testing",
+			LoginType: database.LoginTypePassword,
 		})
 		require.NoError(t, err)
 
@@ -294,7 +303,7 @@ func TestUpdateJob(t *testing.T) {
 	ctx := context.Background()
 	t.Run("NotFound", func(t *testing.T) {
 		t.Parallel()
-		srv := setup(t)
+		srv := setup(t, false)
 		_, err := srv.UpdateJob(ctx, &proto.UpdateJobRequest{
 			JobId: "hello",
 		})
@@ -307,9 +316,12 @@ func TestUpdateJob(t *testing.T) {
 	})
 	t.Run("NotRunning", func(t *testing.T) {
 		t.Parallel()
-		srv := setup(t)
+		srv := setup(t, false)
 		job, err := srv.Database.InsertProvisionerJob(ctx, database.InsertProvisionerJobParams{
-			ID: uuid.New(),
+			ID:            uuid.New(),
+			Provisioner:   database.ProvisionerTypeEcho,
+			StorageMethod: database.ProvisionerStorageMethodFile,
+			Type:          database.ProvisionerJobTypeTemplateVersionDryRun,
 		})
 		require.NoError(t, err)
 		_, err = srv.UpdateJob(ctx, &proto.UpdateJobRequest{
@@ -320,10 +332,12 @@ func TestUpdateJob(t *testing.T) {
 	// This test prevents runners from updating jobs they don't own!
 	t.Run("NotOwner", func(t *testing.T) {
 		t.Parallel()
-		srv := setup(t)
+		srv := setup(t, false)
 		job, err := srv.Database.InsertProvisionerJob(ctx, database.InsertProvisionerJobParams{
-			ID:          uuid.New(),
-			Provisioner: database.ProvisionerTypeEcho,
+			ID:            uuid.New(),
+			Provisioner:   database.ProvisionerTypeEcho,
+			StorageMethod: database.ProvisionerStorageMethodFile,
+			Type:          database.ProvisionerJobTypeTemplateVersionDryRun,
 		})
 		require.NoError(t, err)
 		_, err = srv.Database.AcquireProvisionerJob(ctx, database.AcquireProvisionerJobParams{
@@ -342,8 +356,10 @@ func TestUpdateJob(t *testing.T) {
 
 	setupJob := func(t *testing.T, srv *provisionerdserver.Server) uuid.UUID {
 		job, err := srv.Database.InsertProvisionerJob(ctx, database.InsertProvisionerJobParams{
-			ID:          uuid.New(),
-			Provisioner: database.ProvisionerTypeEcho,
+			ID:            uuid.New(),
+			Provisioner:   database.ProvisionerTypeEcho,
+			Type:          database.ProvisionerJobTypeTemplateVersionImport,
+			StorageMethod: database.ProvisionerStorageMethodFile,
 		})
 		require.NoError(t, err)
 		_, err = srv.Database.AcquireProvisionerJob(ctx, database.AcquireProvisionerJobParams{
@@ -359,7 +375,7 @@ func TestUpdateJob(t *testing.T) {
 
 	t.Run("Success", func(t *testing.T) {
 		t.Parallel()
-		srv := setup(t)
+		srv := setup(t, false)
 		job := setupJob(t, srv)
 		_, err := srv.UpdateJob(ctx, &proto.UpdateJobRequest{
 			JobId: job.String(),
@@ -369,7 +385,7 @@ func TestUpdateJob(t *testing.T) {
 
 	t.Run("Logs", func(t *testing.T) {
 		t.Parallel()
-		srv := setup(t)
+		srv := setup(t, false)
 		job := setupJob(t, srv)
 
 		published := make(chan struct{})
@@ -394,7 +410,7 @@ func TestUpdateJob(t *testing.T) {
 	})
 	t.Run("Readme", func(t *testing.T) {
 		t.Parallel()
-		srv := setup(t)
+		srv := setup(t, false)
 		job := setupJob(t, srv)
 		version, err := srv.Database.InsertTemplateVersion(ctx, database.InsertTemplateVersionParams{
 			ID:    uuid.New(),
@@ -418,7 +434,7 @@ func TestFailJob(t *testing.T) {
 	ctx := context.Background()
 	t.Run("NotFound", func(t *testing.T) {
 		t.Parallel()
-		srv := setup(t)
+		srv := setup(t, false)
 		_, err := srv.FailJob(ctx, &proto.FailedJob{
 			JobId: "hello",
 		})
@@ -432,10 +448,12 @@ func TestFailJob(t *testing.T) {
 	// This test prevents runners from updating jobs they don't own!
 	t.Run("NotOwner", func(t *testing.T) {
 		t.Parallel()
-		srv := setup(t)
+		srv := setup(t, false)
 		job, err := srv.Database.InsertProvisionerJob(ctx, database.InsertProvisionerJobParams{
-			ID:          uuid.New(),
-			Provisioner: database.ProvisionerTypeEcho,
+			ID:            uuid.New(),
+			Provisioner:   database.ProvisionerTypeEcho,
+			StorageMethod: database.ProvisionerStorageMethodFile,
+			Type:          database.ProvisionerJobTypeTemplateVersionImport,
 		})
 		require.NoError(t, err)
 		_, err = srv.Database.AcquireProvisionerJob(ctx, database.AcquireProvisionerJobParams{
@@ -453,10 +471,12 @@ func TestFailJob(t *testing.T) {
 	})
 	t.Run("AlreadyCompleted", func(t *testing.T) {
 		t.Parallel()
-		srv := setup(t)
+		srv := setup(t, false)
 		job, err := srv.Database.InsertProvisionerJob(ctx, database.InsertProvisionerJobParams{
-			ID:          uuid.New(),
-			Provisioner: database.ProvisionerTypeEcho,
+			ID:            uuid.New(),
+			Provisioner:   database.ProvisionerTypeEcho,
+			Type:          database.ProvisionerJobTypeTemplateVersionImport,
+			StorageMethod: database.ProvisionerStorageMethodFile,
 		})
 		require.NoError(t, err)
 		_, err = srv.Database.AcquireProvisionerJob(ctx, database.AcquireProvisionerJobParams{
@@ -482,19 +502,32 @@ func TestFailJob(t *testing.T) {
 	})
 	t.Run("WorkspaceBuild", func(t *testing.T) {
 		t.Parallel()
-		srv := setup(t)
-		build, err := srv.Database.InsertWorkspaceBuild(ctx, database.InsertWorkspaceBuildParams{
+		// Ignore log errors because we get:
+		//
+		//	(*Server).FailJob       audit log - get build {"error": "sql: no rows in result set"}
+		ignoreLogErrors := true
+		srv := setup(t, ignoreLogErrors)
+		workspace, err := srv.Database.InsertWorkspace(ctx, database.InsertWorkspaceParams{
 			ID: uuid.New(),
 		})
 		require.NoError(t, err)
+		build, err := srv.Database.InsertWorkspaceBuild(ctx, database.InsertWorkspaceBuildParams{
+			ID:          uuid.New(),
+			WorkspaceID: workspace.ID,
+			Transition:  database.WorkspaceTransitionStart,
+			Reason:      database.BuildReasonInitiator,
+		})
+		require.NoError(t, err)
 		input, err := json.Marshal(provisionerdserver.WorkspaceProvisionJob{
 			WorkspaceBuildID: build.ID,
 		})
 		require.NoError(t, err)
 		job, err := srv.Database.InsertProvisionerJob(ctx, database.InsertProvisionerJobParams{
-			ID:          uuid.New(),
-			Provisioner: database.ProvisionerTypeEcho,
-			Input:       input,
+			ID:            uuid.New(),
+			Input:         input,
+			Provisioner:   database.ProvisionerTypeEcho,
+			Type:          database.ProvisionerJobTypeWorkspaceBuild,
+			StorageMethod: database.ProvisionerStorageMethodFile,
 		})
 		require.NoError(t, err)
 		_, err = srv.Database.AcquireProvisionerJob(ctx, database.AcquireProvisionerJobParams{
@@ -541,7 +574,7 @@ func TestCompleteJob(t *testing.T) {
 	ctx := context.Background()
 	t.Run("NotFound", func(t *testing.T) {
 		t.Parallel()
-		srv := setup(t)
+		srv := setup(t, false)
 		_, err := srv.CompleteJob(ctx, &proto.CompletedJob{
 			JobId: "hello",
 		})
@@ -555,10 +588,12 @@ func TestCompleteJob(t *testing.T) {
 	// This test prevents runners from updating jobs they don't own!
 	t.Run("NotOwner", func(t *testing.T) {
 		t.Parallel()
-		srv := setup(t)
+		srv := setup(t, false)
 		job, err := srv.Database.InsertProvisionerJob(ctx, database.InsertProvisionerJobParams{
-			ID:          uuid.New(),
-			Provisioner: database.ProvisionerTypeEcho,
+			ID:            uuid.New(),
+			Provisioner:   database.ProvisionerTypeEcho,
+			StorageMethod: database.ProvisionerStorageMethodFile,
+			Type:          database.ProvisionerJobTypeWorkspaceBuild,
 		})
 		require.NoError(t, err)
 		_, err = srv.Database.AcquireProvisionerJob(ctx, database.AcquireProvisionerJobParams{
@@ -576,11 +611,13 @@ func TestCompleteJob(t *testing.T) {
 	})
 	t.Run("TemplateImport", func(t *testing.T) {
 		t.Parallel()
-		srv := setup(t)
+		srv := setup(t, false)
 		job, err := srv.Database.InsertProvisionerJob(ctx, database.InsertProvisionerJobParams{
-			ID:          uuid.New(),
-			Provisioner: database.ProvisionerTypeEcho,
-			Input:       []byte(`{"template_version_id": "` + uuid.NewString() + `"}`),
+			ID:            uuid.New(),
+			Provisioner:   database.ProvisionerTypeEcho,
+			Input:         []byte(`{"template_version_id": "` + uuid.NewString() + `"}`),
+			StorageMethod: database.ProvisionerStorageMethodFile,
+			Type:          database.ProvisionerJobTypeWorkspaceBuild,
 		})
 		require.NoError(t, err)
 		_, err = srv.Database.AcquireProvisionerJob(ctx, database.AcquireProvisionerJobParams{
@@ -607,7 +644,7 @@ func TestCompleteJob(t *testing.T) {
 	})
 	t.Run("WorkspaceBuild", func(t *testing.T) {
 		t.Parallel()
-		srv := setup(t)
+		srv := setup(t, false)
 		workspace, err := srv.Database.InsertWorkspace(ctx, database.InsertWorkspaceParams{
 			ID: uuid.New(),
 		})
@@ -616,6 +653,7 @@ func TestCompleteJob(t *testing.T) {
 			ID:          uuid.New(),
 			WorkspaceID: workspace.ID,
 			Transition:  database.WorkspaceTransitionDelete,
+			Reason:      database.BuildReasonInitiator,
 		})
 		require.NoError(t, err)
 		input, err := json.Marshal(provisionerdserver.WorkspaceProvisionJob{
@@ -623,9 +661,11 @@ func TestCompleteJob(t *testing.T) {
 		})
 		require.NoError(t, err)
 		job, err := srv.Database.InsertProvisionerJob(ctx, database.InsertProvisionerJobParams{
-			ID:          uuid.New(),
-			Provisioner: database.ProvisionerTypeEcho,
-			Input:       input,
+			ID:            uuid.New(),
+			Provisioner:   database.ProvisionerTypeEcho,
+			Input:         input,
+			Type:          database.ProvisionerJobTypeWorkspaceBuild,
+			StorageMethod: database.ProvisionerStorageMethodFile,
 		})
 		require.NoError(t, err)
 		_, err = srv.Database.AcquireProvisionerJob(ctx, database.AcquireProvisionerJobParams{
@@ -674,10 +714,12 @@ func TestCompleteJob(t *testing.T) {
 
 	t.Run("TemplateDryRun", func(t *testing.T) {
 		t.Parallel()
-		srv := setup(t)
+		srv := setup(t, false)
 		job, err := srv.Database.InsertProvisionerJob(ctx, database.InsertProvisionerJobParams{
-			ID:          uuid.New(),
-			Provisioner: database.ProvisionerTypeEcho,
+			ID:            uuid.New(),
+			Provisioner:   database.ProvisionerTypeEcho,
+			Type:          database.ProvisionerJobTypeTemplateVersionDryRun,
+			StorageMethod: database.ProvisionerStorageMethodFile,
 		})
 		require.NoError(t, err)
 		_, err = srv.Database.AcquireProvisionerJob(ctx, database.AcquireProvisionerJobParams{
@@ -797,14 +839,14 @@ func TestInsertWorkspaceResource(t *testing.T) {
 	})
 }
 
-func setup(t *testing.T) *provisionerdserver.Server {
+func setup(t *testing.T, ignoreLogErrors bool) *provisionerdserver.Server {
 	t.Helper()
 	db := databasefake.New()
 	pubsub := database.NewPubsubInMemory()
 
 	return &provisionerdserver.Server{
 		ID:           uuid.New(),
-		Logger:       slogtest.Make(t, nil),
+		Logger:       slogtest.Make(t, &slogtest.Options{IgnoreErrors: ignoreLogErrors}),
 		AccessURL:    &url.URL{},
 		Provisioners: []database.ProvisionerType{database.ProvisionerTypeEcho},
 		Database:     db,

coderd/telemetry/telemetry_test.go

@@ -11,6 +11,7 @@ import (
 
 	"github.com/go-chi/chi"
 	"github.com/google/uuid"
+	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"go.uber.org/goleak"
 
@@ -30,64 +31,82 @@ func TestTelemetry(t *testing.T) {
 	t.Parallel()
 	t.Run("Snapshot", func(t *testing.T) {
 		t.Parallel()
+
+		var err error
+
 		db := databasefake.New()
+
 		ctx := context.Background()
-		_, err := db.InsertAPIKey(ctx, database.InsertAPIKeyParams{
-			ID:       uuid.NewString(),
-			LastUsed: database.Now(),
-			Scope:    database.APIKeyScopeAll,
+		_, err = db.InsertAPIKey(ctx, database.InsertAPIKeyParams{
+			ID:        uuid.NewString(),
+			LastUsed:  database.Now(),
+			Scope:     database.APIKeyScopeAll,
+			LoginType: database.LoginTypePassword,
 		})
-		require.NoError(t, err)
+		assert.NoError(t, err)
 		_, err = db.InsertParameterSchema(ctx, database.InsertParameterSchemaParams{
-			ID:        uuid.New(),
-			CreatedAt: database.Now(),
+			ID:                       uuid.New(),
+			CreatedAt:                database.Now(),
+			DefaultSourceScheme:      database.ParameterSourceSchemeNone,
+			DefaultDestinationScheme: database.ParameterDestinationSchemeNone,
+			ValidationTypeSystem:     database.ParameterTypeSystemNone,
 		})
-		require.NoError(t, err)
+		assert.NoError(t, err)
 		_, err = db.InsertProvisionerJob(ctx, database.InsertProvisionerJobParams{
-			ID:        uuid.New(),
-			CreatedAt: database.Now(),
+			ID:            uuid.New(),
+			CreatedAt:     database.Now(),
+			Provisioner:   database.ProvisionerTypeTerraform,
+			StorageMethod: database.ProvisionerStorageMethodFile,
+			Type:          database.ProvisionerJobTypeTemplateVersionDryRun,
 		})
-		require.NoError(t, err)
+		assert.NoError(t, err)
 		_, err = db.InsertTemplate(ctx, database.InsertTemplateParams{
-			ID:        uuid.New(),
-			CreatedAt: database.Now(),
+			ID:          uuid.New(),
+			CreatedAt:   database.Now(),
+			Provisioner: database.ProvisionerTypeTerraform,
 		})
-		require.NoError(t, err)
+		assert.NoError(t, err)
 		_, err = db.InsertTemplateVersion(ctx, database.InsertTemplateVersionParams{
 			ID:        uuid.New(),
 			CreatedAt: database.Now(),
 		})
-		require.NoError(t, err)
+		assert.NoError(t, err)
 		_, err = db.InsertUser(ctx, database.InsertUserParams{
 			ID:        uuid.New(),
 			CreatedAt: database.Now(),
+			LoginType: database.LoginTypePassword,
 		})
-		require.NoError(t, err)
+		assert.NoError(t, err)
 		_, err = db.InsertWorkspace(ctx, database.InsertWorkspaceParams{
 			ID:        uuid.New(),
 			CreatedAt: database.Now(),
 		})
-		require.NoError(t, err)
+		assert.NoError(t, err)
 		_, err = db.InsertWorkspaceApp(ctx, database.InsertWorkspaceAppParams{
-			ID:        uuid.New(),
-			CreatedAt: database.Now(),
+			ID:           uuid.New(),
+			CreatedAt:    database.Now(),
+			SharingLevel: database.AppSharingLevelOwner,
+			Health:       database.WorkspaceAppHealthDisabled,
 		})
-		require.NoError(t, err)
+		assert.NoError(t, err)
 		_, err = db.InsertWorkspaceAgent(ctx, database.InsertWorkspaceAgentParams{
 			ID:        uuid.New(),
 			CreatedAt: database.Now(),
 		})
-		require.NoError(t, err)
+		assert.NoError(t, err)
 		_, err = db.InsertWorkspaceBuild(ctx, database.InsertWorkspaceBuildParams{
-			ID:        uuid.New(),
-			CreatedAt: database.Now(),
+			ID:         uuid.New(),
+			CreatedAt:  database.Now(),
+			Transition: database.WorkspaceTransitionStart,
+			Reason:     database.BuildReasonAutostart,
 		})
-		require.NoError(t, err)
+		assert.NoError(t, err)
 		_, err = db.InsertWorkspaceResource(ctx, database.InsertWorkspaceResourceParams{
-			ID:        uuid.New(),
-			CreatedAt: database.Now(),
+			ID:         uuid.New(),
+			CreatedAt:  database.Now(),
+			Transition: database.WorkspaceTransitionStart,
 		})
-		require.NoError(t, err)
+		assert.NoError(t, err)
 		_, err = db.InsertLicense(ctx, database.InsertLicenseParams{
 			UploadedAt: database.Now(),
 			JWT:        "",
@@ -97,7 +116,7 @@ func TestTelemetry(t *testing.T) {
 				Valid: true,
 			},
 		})
-		require.NoError(t, err)
+		assert.NoError(t, err)
 		snapshot := collectSnapshot(t, db)
 		require.Len(t, snapshot.ParameterSchemas, 1)
 		require.Len(t, snapshot.ProvisionerJobs, 1)
@@ -118,6 +137,7 @@ func TestTelemetry(t *testing.T) {
 			ID:        uuid.New(),
 			Email:     "kyle@coder.com",
 			CreatedAt: database.Now(),
+			LoginType: database.LoginTypePassword,
 		})
 		require.NoError(t, err)
 		snapshot := collectSnapshot(t, db)

coderd/workspaceapps_internal_test.go

@@ -35,6 +35,8 @@ func TestAPIKeyEncryption(t *testing.T) {
 		_, err := db.InsertAPIKey(ctx, database.InsertAPIKeyParams{
 			ID:           keyID,
 			HashedSecret: hashedSecret,
+			LoginType:    database.LoginTypePassword,
+			Scope:        database.APIKeyScopeAll,
 		})
 		require.NoError(t, err)
 	}

dogfood/Dockerfile

@@ -53,7 +53,7 @@ RUN mkdir --parents "$GOPATH" && \
 	# charts and values files
 	go install github.com/norwoodj/helm-docs/cmd/helm-docs@v1.5.0 && \
 	# sqlc for Go code generation
-	go install github.com/kyleconroy/sqlc/cmd/sqlc@v1.10.0 && \
+	go install github.com/kyleconroy/sqlc/cmd/sqlc@v1.16.0 && \
 	# gcr-cleaner-cli used by CI to prune unused images
 	go install github.com/sethvargo/gcr-cleaner/cmd/gcr-cleaner-cli@v0.5.1 && \
 	# ruleguard for checking custom rules, without needing to run all of

enterprise/coderd/license/license_test.go

@@ -134,10 +134,12 @@ func TestEntitlements(t *testing.T) {
 		t.Parallel()
 		db := databasefake.New()
 		db.InsertUser(context.Background(), database.InsertUserParams{
-			Username: "test1",
+			Username:  "test1",
+			LoginType: database.LoginTypePassword,
 		})
 		db.InsertUser(context.Background(), database.InsertUserParams{
-			Username: "test2",
+			Username:  "test2",
+			LoginType: database.LoginTypePassword,
 		})
 		db.InsertLicense(context.Background(), database.InsertLicenseParams{
 			JWT: coderdenttest.GenerateLicense(t, coderdenttest.LicenseOptions{