feat: claim prebuilds based on workspace parameters instead of preset id (coder#19279)

Closes coder#18356.

This change finds and selects a matching preset if one was not chosen
during workspace creation. This solidifies the relationship between
presets and parameters.

When a workspace is created without in explicitly chosen preset, it will
now still be eligible to claim a prebuilt workspace if one is available.

Author: SasSwart

coderd/database/dbauthz/dbauthz.go

@@ -1837,6 +1837,14 @@ func (q *querier) FetchVolumesResourceMonitorsUpdatedAfter(ctx context.Context,
 	return q.db.FetchVolumesResourceMonitorsUpdatedAfter(ctx, updatedAt)
 }
 
+func (q *querier) FindMatchingPresetID(ctx context.Context, arg database.FindMatchingPresetIDParams) (uuid.UUID, error) {
+	_, err := q.GetTemplateVersionByID(ctx, arg.TemplateVersionID)
+	if err != nil {
+		return uuid.Nil, err
+	}
+	return q.db.FindMatchingPresetID(ctx, arg)
+}
+
 func (q *querier) GetAPIKeyByID(ctx context.Context, id string) (database.APIKey, error) {
 	return fetch(q.log, q.auth, q.db.GetAPIKeyByID)(ctx, id)
 }

coderd/database/dbauthz/dbauthz_test.go

@@ -4965,6 +4965,22 @@ func (s *MethodTestSuite) TestPrebuilds() {
 			template, policy.ActionUse,
 		).Errors(sql.ErrNoRows)
 	}))
+	s.Run("FindMatchingPresetID", s.Mocked(func(dbm *dbmock.MockStore, faker *gofakeit.Faker, check *expects) {
+		t1 := testutil.Fake(s.T(), faker, database.Template{})
+		tv := testutil.Fake(s.T(), faker, database.TemplateVersion{TemplateID: uuid.NullUUID{UUID: t1.ID, Valid: true}})
+		dbm.EXPECT().FindMatchingPresetID(gomock.Any(), database.FindMatchingPresetIDParams{
+			TemplateVersionID: tv.ID,
+			ParameterNames:    []string{"test"},
+			ParameterValues:   []string{"test"},
+		}).Return(uuid.Nil, nil).AnyTimes()
+		dbm.EXPECT().GetTemplateVersionByID(gomock.Any(), tv.ID).Return(tv, nil).AnyTimes()
+		dbm.EXPECT().GetTemplateByID(gomock.Any(), t1.ID).Return(t1, nil).AnyTimes()
+		check.Args(database.FindMatchingPresetIDParams{
+			TemplateVersionID: tv.ID,
+			ParameterNames:    []string{"test"},
+			ParameterValues:   []string{"test"},
+		}).Asserts(tv.RBACObject(t1), policy.ActionRead).Returns(uuid.Nil)
+	}))
 	s.Run("GetPrebuildMetrics", s.Subtest(func(_ database.Store, check *expects) {
 		check.Args().
 			Asserts(rbac.ResourceWorkspace.All(), policy.ActionRead)

coderd/database/dbmetrics/querymetrics.go

@@ -245,3 +245,30 @@ INNER JOIN organizations o ON o.id = w.organization_id
 WHERE NOT t.deleted AND wpb.build_number = 1
 GROUP BY t.name, tvp.name, o.name
 ORDER BY t.name, tvp.name, o.name;
+
+-- name: FindMatchingPresetID :one
+-- FindMatchingPresetID finds a preset ID that is the largest exact subset of the provided parameters.
+-- It returns the preset ID if a match is found, or NULL if no match is found.
+-- The query finds presets where all preset parameters are present in the provided parameters,
+-- and returns the preset with the most parameters (largest subset).
+WITH provided_params AS (
+	SELECT
+		unnest(@parameter_names::text[]) AS name,
+		unnest(@parameter_values::text[]) AS value
+),
+preset_matches AS (
+	SELECT
+		tvp.id AS template_version_preset_id,
+		COALESCE(COUNT(tvpp.name), 0) AS total_preset_params,
+		COALESCE(COUNT(pp.name), 0) AS matching_params
+	FROM template_version_presets tvp
+	LEFT JOIN template_version_preset_parameters tvpp ON tvpp.template_version_preset_id = tvp.id
+	LEFT JOIN provided_params pp ON pp.name = tvpp.name AND pp.value = tvpp.value
+	WHERE tvp.template_version_id = @template_version_id
+	GROUP BY tvp.id
+)
+SELECT pm.template_version_preset_id
+FROM preset_matches pm
+WHERE pm.total_preset_params = pm.matching_params  -- All preset parameters must match
+ORDER BY pm.total_preset_params DESC               -- Return the preset with the most parameters
+LIMIT 1;

coderd/database/dbmock/dbmock.go

@@ -0,0 +1,42 @@
+package prebuilds
+
+import (
+	"context"
+	"database/sql"
+	"errors"
+
+	"github.com/google/uuid"
+	"golang.org/x/xerrors"
+
+	"github.com/coder/coder/v2/coderd/database"
+)
+
+// FindMatchingPresetID finds a preset ID that matches the provided parameters.
+// It returns the preset ID if a match is found, or uuid.Nil if no match is found.
+// The function performs a bidirectional comparison to ensure all parameters match exactly.
+func FindMatchingPresetID(
+	ctx context.Context,
+	store database.Store,
+	templateVersionID uuid.UUID,
+	parameterNames []string,
+	parameterValues []string,
+) (uuid.UUID, error) {
+	if len(parameterNames) != len(parameterValues) {
+		return uuid.Nil, xerrors.New("parameter names and values must have the same length")
+	}
+
+	result, err := store.FindMatchingPresetID(ctx, database.FindMatchingPresetIDParams{
+		TemplateVersionID: templateVersionID,
+		ParameterNames:    parameterNames,
+		ParameterValues:   parameterValues,
+	})
+	if err != nil {
+		// Handle the case where no matching preset is found (no rows returned)
+		if errors.Is(err, sql.ErrNoRows) {
+			return uuid.Nil, nil
+		}
+		return uuid.Nil, xerrors.Errorf("find matching preset ID: %w", err)
+	}
+
+	return result, nil
+}