Jun 24, 2025 · Jun 18, 2025 · Jun 18, 2025 · Jun 18, 2025 · Jun 19, 2025 · Jun 19, 2025
diff --git a/cli/testdata/coder_list_--output_json.golden b/cli/testdata/coder_list_--output_json.golden
        "available": 0,
        "most_recently_seen": null
      },
      "template_version_preset_id": null
      "template_version_preset_id": null,
      "has_ai_task": false
    },
    "latest_app_status": null,
    "outdated": false,
diff --git a/coderd/database/dbauthz/dbauthz.go b/coderd/database/dbauthz/dbauthz.go
 return update(q.log, q.auth, fetch, q.db.UpdateTemplateScheduleByID)(ctx, arg)
 }

 func (q *querier) UpdateTemplateVersionAITaskByJobID(ctx context.Context, arg database.UpdateTemplateVersionAITaskByJobIDParams) error {
 // An actor is allowed to update the template version AI task flag if they are authorized to update the template.
 tv, err := q.db.GetTemplateVersionByJobID(ctx, arg.JobID)
 if err != nil {
 return err
 }
 var obj rbac.Objecter
 if !tv.TemplateID.Valid {
 obj = rbac.ResourceTemplate.InOrg(tv.OrganizationID)
 } else {
 tpl, err := q.db.GetTemplateByID(ctx, tv.TemplateID.UUID)
 if err != nil {
 return err
 }
 obj = tpl
 }
 if err := q.authorizeContext(ctx, policy.ActionUpdate, obj); err != nil {
 return err
 }
 return q.db.UpdateTemplateVersionAITaskByJobID(ctx, arg)
 }

 func (q *querier) UpdateTemplateVersionByID(ctx context.Context, arg database.UpdateTemplateVersionByIDParams) error {
 // An actor is allowed to update the template version if they are authorized to update the template.
 tv, err := q.db.GetTemplateVersionByID(ctx, arg.ID)
 return update(q.log, q.auth, fetch, q.db.UpdateWorkspaceAutostart)(ctx, arg)
 }

 func (q *querier) UpdateWorkspaceBuildAITaskByID(ctx context.Context, arg database.UpdateWorkspaceBuildAITaskByIDParams) error {
 build, err := q.db.GetWorkspaceBuildByID(ctx, arg.ID)
 if err != nil {
 return err
 }

 workspace, err := q.db.GetWorkspaceByID(ctx, build.WorkspaceID)
 if err != nil {
 return err
 }

 err = q.authorizeContext(ctx, policy.ActionUpdate, workspace.RBACObject())
 if err != nil {
 return err
 }
 return q.db.UpdateWorkspaceBuildAITaskByID(ctx, arg)
 }

 // UpdateWorkspaceBuildCostByID is used by the provisioning system to update the cost of a workspace build.
 func (q *querier) UpdateWorkspaceBuildCostByID(ctx context.Context, arg database.UpdateWorkspaceBuildCostByIDParams) error {
 if err := q.authorizeContext(ctx, policy.ActionUpdate, rbac.ResourceSystem); err != nil {
diff --git a/coderd/database/dbauthz/dbauthz_test.go b/coderd/database/dbauthz/dbauthz_test.go
 ID: t1.ID,
 }).Asserts(t1, policy.ActionUpdate)
 }))
 s.Run("UpdateTemplateVersionAITaskByJobID", s.Subtest(func(db database.Store, check *expects) {
 dbtestutil.DisableForeignKeysAndTriggers(s.T(), db)
 o := dbgen.Organization(s.T(), db, database.Organization{})
 u := dbgen.User(s.T(), db, database.User{})
 _ = dbgen.OrganizationMember(s.T(), db, database.OrganizationMember{OrganizationID: o.ID, UserID: u.ID})
 t := dbgen.Template(s.T(), db, database.Template{OrganizationID: o.ID, CreatedBy: u.ID})
 job := dbgen.ProvisionerJob(s.T(), db, nil, database.ProvisionerJob{OrganizationID: o.ID})
 _ = dbgen.TemplateVersion(s.T(), db, database.TemplateVersion{
 OrganizationID: o.ID,
 CreatedBy:      u.ID,
 JobID:          job.ID,
 TemplateID:     uuid.NullUUID{UUID: t.ID, Valid: true},
 })
 check.Args(database.UpdateTemplateVersionAITaskByJobIDParams{
 JobID:     job.ID,
 HasAITask: sql.NullBool{Bool: true, Valid: true},
 }).Asserts(t, policy.ActionUpdate)
 }))
 s.Run("UpdateTemplateWorkspacesLastUsedAt", s.Subtest(func(db database.Store, check *expects) {
 dbtestutil.DisableForeignKeysAndTriggers(s.T(), db)
 t1 := dbgen.Template(s.T(), db, database.Template{})
 Deadline:  b.Deadline,
 }).Asserts(w, policy.ActionUpdate)
 }))
 s.Run("UpdateWorkspaceBuildAITaskByID", s.Subtest(func(db database.Store, check *expects) {
 u := dbgen.User(s.T(), db, database.User{})
 o := dbgen.Organization(s.T(), db, database.Organization{})
 tpl := dbgen.Template(s.T(), db, database.Template{
 OrganizationID: o.ID,
 CreatedBy:      u.ID,
 })
 tv := dbgen.TemplateVersion(s.T(), db, database.TemplateVersion{
 TemplateID:     uuid.NullUUID{UUID: tpl.ID, Valid: true},
 OrganizationID: o.ID,
 CreatedBy:      u.ID,
 })
 w := dbgen.Workspace(s.T(), db, database.WorkspaceTable{
 TemplateID:     tpl.ID,
 OrganizationID: o.ID,
 OwnerID:        u.ID,
 })
 j := dbgen.ProvisionerJob(s.T(), db, nil, database.ProvisionerJob{
 Type: database.ProvisionerJobTypeWorkspaceBuild,
 })
 b := dbgen.WorkspaceBuild(s.T(), db, database.WorkspaceBuild{
 JobID:             j.ID,
 WorkspaceID:       w.ID,
 TemplateVersionID: tv.ID,
 })
 res := dbgen.WorkspaceResource(s.T(), db, database.WorkspaceResource{JobID: b.JobID})
 agt := dbgen.WorkspaceAgent(s.T(), db, database.WorkspaceAgent{ResourceID: res.ID})
 app := dbgen.WorkspaceApp(s.T(), db, database.WorkspaceApp{AgentID: agt.ID})
 check.Args(database.UpdateWorkspaceBuildAITaskByIDParams{
 HasAITask:    sql.NullBool{Bool: true, Valid: true},
 SidebarAppID: uuid.NullUUID{UUID: app.ID, Valid: true},
 ID:           b.ID,
 }).Asserts(w, policy.ActionUpdate)
 }))
 s.Run("SoftDeleteWorkspaceByID", s.Subtest(func(db database.Store, check *expects) {
 u := dbgen.User(s.T(), db, database.User{})
 o := dbgen.Organization(s.T(), db, database.Organization{})
diff --git a/coderd/database/dbgen/dbgen.go b/coderd/database/dbgen/dbgen.go
 t.Helper()

 buildID := takeFirst(orig.ID, uuid.New())
 jobID := takeFirst(orig.JobID, uuid.New())
 hasAITask := takeFirst(orig.HasAITask, sql.NullBool{})
 sidebarAppID := takeFirst(orig.AITaskSidebarAppID, uuid.NullUUID{})
 var build database.WorkspaceBuild
 err := db.InTx(func(db database.Store) error {
 err := db.InsertWorkspaceBuild(genCtx, database.InsertWorkspaceBuildParams{
 BuildNumber:       takeFirst(orig.BuildNumber, 1),
 Transition:        takeFirst(orig.Transition, database.WorkspaceTransitionStart),
 InitiatorID:       takeFirst(orig.InitiatorID, uuid.New()),
 JobID:takeFirst(orig.JobID, uuid.New()),
 JobID:jobID,
 ProvisionerState:  takeFirstSlice(orig.ProvisionerState, []byte{}),
 Deadline:          takeFirst(orig.Deadline, dbtime.Now().Add(time.Hour)),
 MaxDeadline:       takeFirst(orig.MaxDeadline, time.Time{}),
 UUID:  uuid.UUID{},
 Valid: false,
 }),
 HasAITask: orig.HasAITask,
 })
 if err != nil {
 return err
 require.NoError(t, err)
 }

 if hasAITask.Valid {
 require.NoError(t, db.UpdateWorkspaceBuildAITaskByID(genCtx, database.UpdateWorkspaceBuildAITaskByIDParams{
 HasAITask:    hasAITask,
 SidebarAppID: sidebarAppID,
 UpdatedAt:    dbtime.Now(),
 ID:           buildID,
 }))
 }

 build, err = db.GetWorkspaceBuildByID(genCtx, buildID)
 if err != nil {
 return err

 func TemplateVersion(t testing.TB, db database.Store, orig database.TemplateVersion) database.TemplateVersion {
 var version database.TemplateVersion
 hasAITask := takeFirst(orig.HasAITask, sql.NullBool{})
 jobID := takeFirst(orig.JobID, uuid.New())
 err := db.InTx(func(db database.Store) error {
 versionID := takeFirst(orig.ID, uuid.New())
 err := db.InsertTemplateVersion(genCtx, database.InsertTemplateVersionParams{
 Name:            takeFirst(orig.Name, testutil.GetRandomName(t)),
 Message:         orig.Message,
 Readme:          takeFirst(orig.Readme, testutil.GetRandomName(t)),
 JobID:takeFirst(orig.JobID, uuid.New()),
 JobID:jobID,
 CreatedBy:       takeFirst(orig.CreatedBy, uuid.New()),
 SourceExampleID: takeFirst(orig.SourceExampleID, sql.NullString{}),
 HasAITask:       orig.HasAITask,
 })
 if err != nil {
 return err
 }

 if hasAITask.Valid {
 require.NoError(t, db.UpdateTemplateVersionAITaskByJobID(genCtx, database.UpdateTemplateVersionAITaskByJobIDParams{
 JobID:     jobID,
 HasAITask: hasAITask,
 UpdatedAt: dbtime.Now(),
 }))
 }

 version, err = db.GetTemplateVersionByID(genCtx, versionID)
 if err != nil {
 return err
diff --git a/coderd/database/dbmem/dbmem.go b/coderd/database/dbmem/dbmem.go
 JobID:           arg.JobID,
 CreatedBy:       arg.CreatedBy,
 SourceExampleID: arg.SourceExampleID,
 HasAITask:       arg.HasAITask,
 }
 q.templateVersions = append(q.templateVersions, version)
 return nil
 MaxDeadline:             arg.MaxDeadline,
 Reason:                  arg.Reason,
 TemplateVersionPresetID: arg.TemplateVersionPresetID,
 HasAITask:               arg.HasAITask,
 }
 q.workspaceBuilds = append(q.workspaceBuilds, workspaceBuild)
 return nil
 return sql.ErrNoRows
 }

 func (q *FakeQuerier) UpdateTemplateVersionAITaskByJobID(_ context.Context, arg database.UpdateTemplateVersionAITaskByJobIDParams) error {
 if err := validateDatabaseType(arg); err != nil {
 return err
 }

 q.mutex.Lock()
 defer q.mutex.Unlock()

 for index, templateVersion := range q.templateVersions {
 if templateVersion.JobID != arg.JobID {
 continue
 }
 templateVersion.HasAITask = arg.HasAITask
 templateVersion.UpdatedAt = arg.UpdatedAt
 q.templateVersions[index] = templateVersion
 return nil
 }
 return sql.ErrNoRows
 }

 func (q *FakeQuerier) UpdateTemplateVersionByID(_ context.Context, arg database.UpdateTemplateVersionByIDParams) error {
 if err := validateDatabaseType(arg); err != nil {
 return err
 return sql.ErrNoRows
 }

 func (q *FakeQuerier) UpdateWorkspaceBuildAITaskByID(_ context.Context, arg database.UpdateWorkspaceBuildAITaskByIDParams) error {
 if arg.HasAITask.Bool && !arg.SidebarAppID.Valid {
 return xerrors.Errorf("ai_task_sidebar_app_id is required when has_ai_task is true")
 }
 if !arg.HasAITask.Valid && arg.SidebarAppID.Valid {
 return xerrors.Errorf("ai_task_sidebar_app_id is can only be set when has_ai_task is true")
 }

 err := validateDatabaseType(arg)
 if err != nil {
 return err
 }

 q.mutex.Lock()
 defer q.mutex.Unlock()

 for index, workspaceBuild := range q.workspaceBuilds {
 if workspaceBuild.ID != arg.ID {
 continue
 }
 workspaceBuild.HasAITask = arg.HasAITask
 workspaceBuild.AITaskSidebarAppID = arg.SidebarAppID
 workspaceBuild.UpdatedAt = dbtime.Now()
 q.workspaceBuilds[index] = workspaceBuild
 return nil
 }
 return sql.ErrNoRows
 }

 func (q *FakeQuerier) UpdateWorkspaceBuildCostByID(_ context.Context, arg database.UpdateWorkspaceBuildCostByIDParams) error {
 if err := validateDatabaseType(arg); err != nil {
 return err
diff --git a/coderd/database/dbmetrics/querymetrics.go b/coderd/database/dbmetrics/querymetrics.go
diff --git a/coderd/database/dbmock/dbmock.go b/coderd/database/dbmock/dbmock.go
diff --git a/coderd/database/dump.sql b/coderd/database/dump.sql
diff --git a/coderd/database/foreign_key_constraint.go b/coderd/database/foreign_key_constraint.go
Original file line number	Diff line number	Diff line change
Expand Up		@@ -68,7 +68,8 @@
		"available": 0,
		"most_recently_seen": null
		},
		"template_version_preset_id": null
		"template_version_preset_id": null,
		"has_ai_task": false
		},
		"latest_app_status": null,
		"outdated": false,
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -4518,6 +4518,28 @@ func (q *querier) UpdateTemplateScheduleByID(ctx context.Context, arg database.U
		return update(q.log, q.auth, fetch, q.db.UpdateTemplateScheduleByID)(ctx, arg)
		}

		func (q *querier) UpdateTemplateVersionAITaskByJobID(ctx context.Context, arg database.UpdateTemplateVersionAITaskByJobIDParams) error {
		// An actor is allowed to update the template version AI task flag if they are authorized to update the template.
		tv, err := q.db.GetTemplateVersionByJobID(ctx, arg.JobID)
		if err != nil {
		return err
		}
		var obj rbac.Objecter
		if !tv.TemplateID.Valid {
		obj = rbac.ResourceTemplate.InOrg(tv.OrganizationID)
		} else {
		tpl, err := q.db.GetTemplateByID(ctx, tv.TemplateID.UUID)
		if err != nil {
		return err
		}
		obj = tpl
		}
		if err := q.authorizeContext(ctx, policy.ActionUpdate, obj); err != nil {
		return err
		}
		return q.db.UpdateTemplateVersionAITaskByJobID(ctx, arg)
		}

		func (q *querier) UpdateTemplateVersionByID(ctx context.Context, arg database.UpdateTemplateVersionByIDParams) error {
		// An actor is allowed to update the template version if they are authorized to update the template.
		tv, err := q.db.GetTemplateVersionByID(ctx, arg.ID)
Expand DownExpand Up		@@ -4874,6 +4896,24 @@ func (q *querier) UpdateWorkspaceAutostart(ctx context.Context, arg database.Upd
		return update(q.log, q.auth, fetch, q.db.UpdateWorkspaceAutostart)(ctx, arg)
		}

		func (q *querier) UpdateWorkspaceBuildAITaskByID(ctx context.Context, arg database.UpdateWorkspaceBuildAITaskByIDParams) error {
		build, err := q.db.GetWorkspaceBuildByID(ctx, arg.ID)
		if err != nil {
		return err
		}

		workspace, err := q.db.GetWorkspaceByID(ctx, build.WorkspaceID)
		if err != nil {
		return err
		}

		err = q.authorizeContext(ctx, policy.ActionUpdate, workspace.RBACObject())
		if err != nil {
		return err
		}
		return q.db.UpdateWorkspaceBuildAITaskByID(ctx, arg)
		}

		// UpdateWorkspaceBuildCostByID is used by the provisioning system to update the cost of a workspace build.
		func (q *querier) UpdateWorkspaceBuildCostByID(ctx context.Context, arg database.UpdateWorkspaceBuildCostByIDParams) error {
		if err := q.authorizeContext(ctx, policy.ActionUpdate, rbac.ResourceSystem); err != nil {
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -1391,6 +1391,24 @@ func (s *MethodTestSuite) TestTemplate() {
		ID: t1.ID,
		}).Asserts(t1, policy.ActionUpdate)
		}))
		s.Run("UpdateTemplateVersionAITaskByJobID", s.Subtest(func(db database.Store, check *expects) {
		dbtestutil.DisableForeignKeysAndTriggers(s.T(), db)
		o := dbgen.Organization(s.T(), db, database.Organization{})
		u := dbgen.User(s.T(), db, database.User{})
		_ = dbgen.OrganizationMember(s.T(), db, database.OrganizationMember{OrganizationID: o.ID, UserID: u.ID})
		t := dbgen.Template(s.T(), db, database.Template{OrganizationID: o.ID, CreatedBy: u.ID})
		job := dbgen.ProvisionerJob(s.T(), db, nil, database.ProvisionerJob{OrganizationID: o.ID})
		_ = dbgen.TemplateVersion(s.T(), db, database.TemplateVersion{
		OrganizationID: o.ID,
		CreatedBy: u.ID,
		JobID: job.ID,
		TemplateID: uuid.NullUUID{UUID: t.ID, Valid: true},
		})
		check.Args(database.UpdateTemplateVersionAITaskByJobIDParams{
		JobID: job.ID,
		HasAITask: sql.NullBool{Bool: true, Valid: true},
		}).Asserts(t, policy.ActionUpdate)
		}))
		s.Run("UpdateTemplateWorkspacesLastUsedAt", s.Subtest(func(db database.Store, check *expects) {
		dbtestutil.DisableForeignKeysAndTriggers(s.T(), db)
		t1 := dbgen.Template(s.T(), db, database.Template{})
Expand DownExpand Up		@@ -3050,6 +3068,40 @@ func (s *MethodTestSuite) TestWorkspace() {
		Deadline: b.Deadline,
		}).Asserts(w, policy.ActionUpdate)
		}))
		s.Run("UpdateWorkspaceBuildAITaskByID", s.Subtest(func(db database.Store, check *expects) {
		u := dbgen.User(s.T(), db, database.User{})
		o := dbgen.Organization(s.T(), db, database.Organization{})
		tpl := dbgen.Template(s.T(), db, database.Template{
		OrganizationID: o.ID,
		CreatedBy: u.ID,
		})
		tv := dbgen.TemplateVersion(s.T(), db, database.TemplateVersion{
		TemplateID: uuid.NullUUID{UUID: tpl.ID, Valid: true},
		OrganizationID: o.ID,
		CreatedBy: u.ID,
		})
		w := dbgen.Workspace(s.T(), db, database.WorkspaceTable{
		TemplateID: tpl.ID,
		OrganizationID: o.ID,
		OwnerID: u.ID,
		})
		j := dbgen.ProvisionerJob(s.T(), db, nil, database.ProvisionerJob{
		Type: database.ProvisionerJobTypeWorkspaceBuild,
		})
		b := dbgen.WorkspaceBuild(s.T(), db, database.WorkspaceBuild{
		JobID: j.ID,
		WorkspaceID: w.ID,
		TemplateVersionID: tv.ID,
		})
		res := dbgen.WorkspaceResource(s.T(), db, database.WorkspaceResource{JobID: b.JobID})
		agt := dbgen.WorkspaceAgent(s.T(), db, database.WorkspaceAgent{ResourceID: res.ID})
		app := dbgen.WorkspaceApp(s.T(), db, database.WorkspaceApp{AgentID: agt.ID})
		check.Args(database.UpdateWorkspaceBuildAITaskByIDParams{
		HasAITask: sql.NullBool{Bool: true, Valid: true},
		SidebarAppID: uuid.NullUUID{UUID: app.ID, Valid: true},
		ID: b.ID,
		}).Asserts(w, policy.ActionUpdate)
		}))
		s.Run("SoftDeleteWorkspaceByID", s.Subtest(func(db database.Store, check *expects) {
		u := dbgen.User(s.T(), db, database.User{})
		o := dbgen.Organization(s.T(), db, database.Organization{})
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -390,6 +390,9 @@ func WorkspaceBuild(t testing.TB, db database.Store, orig database.WorkspaceBuil
		t.Helper()

		buildID := takeFirst(orig.ID, uuid.New())
		jobID := takeFirst(orig.JobID, uuid.New())
		hasAITask := takeFirst(orig.HasAITask, sql.NullBool{})
		sidebarAppID := takeFirst(orig.AITaskSidebarAppID, uuid.NullUUID{})
		var build database.WorkspaceBuild
		err := db.InTx(func(db database.Store) error {
		err := db.InsertWorkspaceBuild(genCtx, database.InsertWorkspaceBuildParams{
Expand All		@@ -401,7 +404,7 @@ func WorkspaceBuild(t testing.TB, db database.Store, orig database.WorkspaceBuil
		BuildNumber: takeFirst(orig.BuildNumber, 1),
		Transition: takeFirst(orig.Transition, database.WorkspaceTransitionStart),
		InitiatorID: takeFirst(orig.InitiatorID, uuid.New()),
		JobID:takeFirst(orig.JobID, uuid.New()),
		JobID:jobID,
		ProvisionerState: takeFirstSlice(orig.ProvisionerState, []byte{}),
		Deadline: takeFirst(orig.Deadline, dbtime.Now().Add(time.Hour)),
		MaxDeadline: takeFirst(orig.MaxDeadline, time.Time{}),
Expand All		@@ -410,7 +413,6 @@ func WorkspaceBuild(t testing.TB, db database.Store, orig database.WorkspaceBuil
		UUID: uuid.UUID{},
		Valid: false,
		}),
		HasAITask: orig.HasAITask,
		})
		if err != nil {
		return err
Expand All		@@ -424,6 +426,15 @@ func WorkspaceBuild(t testing.TB, db database.Store, orig database.WorkspaceBuil
		require.NoError(t, err)
		}

		if hasAITask.Valid {
		require.NoError(t, db.UpdateWorkspaceBuildAITaskByID(genCtx, database.UpdateWorkspaceBuildAITaskByIDParams{
		HasAITask: hasAITask,
		SidebarAppID: sidebarAppID,
		UpdatedAt: dbtime.Now(),
		ID: buildID,
		}))
		}

		build, err = db.GetWorkspaceBuildByID(genCtx, buildID)
		if err != nil {
		return err
Expand DownExpand Up		@@ -971,6 +982,8 @@ func ExternalAuthLink(t testing.TB, db database.Store, orig database.ExternalAut

		func TemplateVersion(t testing.TB, db database.Store, orig database.TemplateVersion) database.TemplateVersion {
		var version database.TemplateVersion
		hasAITask := takeFirst(orig.HasAITask, sql.NullBool{})
		jobID := takeFirst(orig.JobID, uuid.New())
		err := db.InTx(func(db database.Store) error {
		versionID := takeFirst(orig.ID, uuid.New())
		err := db.InsertTemplateVersion(genCtx, database.InsertTemplateVersionParams{
Expand All		@@ -982,15 +995,22 @@ func TemplateVersion(t testing.TB, db database.Store, orig database.TemplateVers
		Name: takeFirst(orig.Name, testutil.GetRandomName(t)),
		Message: orig.Message,
		Readme: takeFirst(orig.Readme, testutil.GetRandomName(t)),
		JobID:takeFirst(orig.JobID, uuid.New()),
		JobID:jobID,
		CreatedBy: takeFirst(orig.CreatedBy, uuid.New()),
		SourceExampleID: takeFirst(orig.SourceExampleID, sql.NullString{}),
		HasAITask: orig.HasAITask,
		})
		if err != nil {
		return err
		}

		if hasAITask.Valid {
		require.NoError(t, db.UpdateTemplateVersionAITaskByJobID(genCtx, database.UpdateTemplateVersionAITaskByJobIDParams{
		JobID: jobID,
		HasAITask: hasAITask,
		UpdatedAt: dbtime.Now(),
		}))
		}

		version, err = db.GetTemplateVersionByID(genCtx, versionID)
		if err != nil {
		return err
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -9465,7 +9465,6 @@ func (q *FakeQuerier) InsertTemplateVersion(_ context.Context, arg database.Inse
		JobID: arg.JobID,
		CreatedBy: arg.CreatedBy,
		SourceExampleID: arg.SourceExampleID,
		HasAITask: arg.HasAITask,
		}
		q.templateVersions = append(q.templateVersions, version)
		return nil
Expand DownExpand Up		@@ -10103,7 +10102,6 @@ func (q *FakeQuerier) InsertWorkspaceBuild(_ context.Context, arg database.Inser
		MaxDeadline: arg.MaxDeadline,
		Reason: arg.Reason,
		TemplateVersionPresetID: arg.TemplateVersionPresetID,
		HasAITask: arg.HasAITask,
		}
		q.workspaceBuilds = append(q.workspaceBuilds, workspaceBuild)
		return nil
Expand DownExpand Up		@@ -11308,6 +11306,26 @@ func (q *FakeQuerier) UpdateTemplateScheduleByID(_ context.Context, arg database
		return sql.ErrNoRows
		}

		func (q *FakeQuerier) UpdateTemplateVersionAITaskByJobID(_ context.Context, arg database.UpdateTemplateVersionAITaskByJobIDParams) error {
		if err := validateDatabaseType(arg); err != nil {
		return err
		}

		q.mutex.Lock()
		defer q.mutex.Unlock()

		for index, templateVersion := range q.templateVersions {
		if templateVersion.JobID != arg.JobID {
		continue
		}
		templateVersion.HasAITask = arg.HasAITask
		templateVersion.UpdatedAt = arg.UpdatedAt
		q.templateVersions[index] = templateVersion
		return nil
		}
		return sql.ErrNoRows
		}

		func (q *FakeQuerier) UpdateTemplateVersionByID(_ context.Context, arg database.UpdateTemplateVersionByIDParams) error {
		if err := validateDatabaseType(arg); err != nil {
		return err
Expand DownExpand Up		@@ -12003,6 +12021,35 @@ func (q *FakeQuerier) UpdateWorkspaceAutostart(_ context.Context, arg database.U
		return sql.ErrNoRows
		}

		func (q *FakeQuerier) UpdateWorkspaceBuildAITaskByID(_ context.Context, arg database.UpdateWorkspaceBuildAITaskByIDParams) error {
		if arg.HasAITask.Bool && !arg.SidebarAppID.Valid {
		return xerrors.Errorf("ai_task_sidebar_app_id is required when has_ai_task is true")
		}
		if !arg.HasAITask.Valid && arg.SidebarAppID.Valid {
		return xerrors.Errorf("ai_task_sidebar_app_id is can only be set when has_ai_task is true")
		}

		err := validateDatabaseType(arg)
		if err != nil {
		return err
		}

		q.mutex.Lock()
		defer q.mutex.Unlock()

		for index, workspaceBuild := range q.workspaceBuilds {
		if workspaceBuild.ID != arg.ID {
		continue
		}
		workspaceBuild.HasAITask = arg.HasAITask
		workspaceBuild.AITaskSidebarAppID = arg.SidebarAppID
		workspaceBuild.UpdatedAt = dbtime.Now()
		q.workspaceBuilds[index] = workspaceBuild
		return nil
		}
		return sql.ErrNoRows
		}

		func (q *FakeQuerier) UpdateWorkspaceBuildCostByID(_ context.Context, arg database.UpdateWorkspaceBuildCostByIDParams) error {
		if err := validateDatabaseType(arg); err != nil {
		return err
Expand Down