add cron job key

backend/controller/dal/dal.go

@@ -494,6 +494,7 @@ func (d *DAL) CreateDeployment(ctx context.Context, language string, moduleSchem
 		// Start time must be calculated by the caller rather than generated by db
 		// This ensures that nextExecution is after start time, otherwise the job will never be triggered
 		err := tx.CreateCronJob(ctx, sql.CreateCronJobParams{
+			Key:           job.Key,
 			DeploymentKey: deploymentKey,
 			ModuleName:    job.Ref.Module,
 			Verb:          job.Ref.Name,
@@ -923,7 +924,7 @@ const (
 )
 
 type CronJob struct {
-	id            int64
+	Key           model.CronJobKey
 	DeploymentKey model.DeploymentKey
 	Ref           schema.Ref
 	Schedule      string
@@ -940,7 +941,7 @@ type AttemptedCronJob struct {
 
 func cronJobFromRow(row sql.GetCronJobsRow) CronJob {
 	return CronJob{
-		id:            row.ID,
+		Key:           row.Key,
 		DeploymentKey: row.DeploymentKey,
 		Ref:           schema.Ref{Module: row.Module, Name: row.Verb},
 		Schedule:      row.Schedule,
@@ -965,7 +966,7 @@ func (d *DAL) StartCronJobs(ctx context.Context, jobs []CronJob) (attemptedJobs
 	if len(jobs) == 0 {
 		return nil, nil
 	}
-	rows, err := d.db.StartCronJobs(ctx, slices.Map(jobs, func(job CronJob) int64 { return job.id }))
+	rows, err := d.db.StartCronJobs(ctx, slices.Map(jobs, func(job CronJob) string { return job.Key.String() }))
 	if err != nil {
 		return nil, translatePGError(err)
 	}
@@ -974,7 +975,7 @@ func (d *DAL) StartCronJobs(ctx context.Context, jobs []CronJob) (attemptedJobs
 	for _, row := range rows {
 		job := AttemptedCronJob{
 			CronJob: CronJob{
-				id:            row.ID,
+				Key:           row.Key,
 				DeploymentKey: row.DeploymentKey,
 				Ref:           schema.Ref{Module: row.Module, Name: row.Verb},
 				Schedule:      row.Schedule,
@@ -991,7 +992,7 @@ func (d *DAL) StartCronJobs(ctx context.Context, jobs []CronJob) (attemptedJobs
 }
 
 func (d *DAL) EndCronJob(ctx context.Context, job CronJob, next time.Time) (CronJob, error) {
-	row, err := d.db.EndCronJob(ctx, next, job.id, job.StartTime)
+	row, err := d.db.EndCronJob(ctx, next, job.Key, job.StartTime)
 	if err != nil {
 		return CronJob{}, translatePGError(err)
 	}

backend/controller/sql/queries.sql

@@ -281,14 +281,16 @@ SELECT COUNT(*)
 FROM rows;
 
 -- name: GetCronJobs :many
-SELECT j.id as id, d.key as deployment_key, j.module_name as module, j.verb, j.schedule, j.start_time, j.next_execution, j.state
+SELECT j.key as key, d.key as deployment_key, j.module_name as module, j.verb, j.schedule, j.start_time, j.next_execution, j.state
 FROM cron_jobs j
   INNER JOIN deployments d on j.deployment_id = d.id
 WHERE d.min_replicas > 0;
 
 -- name: CreateCronJob :exec
-INSERT INTO cron_jobs (deployment_id, module_name, verb, schedule, start_time, next_execution)
-  VALUES ((SELECT id FROM deployments WHERE key = sqlc.arg('deployment_key')::deployment_key LIMIT 1),
+INSERT INTO cron_jobs (key, deployment_id, module_name, verb, schedule, start_time, next_execution)
+  VALUES (
+    sqlc.arg('key')::cron_job_key,
+    (SELECT id FROM deployments WHERE key = sqlc.arg('deployment_key')::deployment_key LIMIT 1),
     sqlc.arg('module_name')::TEXT,
     sqlc.arg('verb')::TEXT,
     sqlc.arg('schedule')::TEXT,
@@ -300,39 +302,39 @@ WITH updates AS (
   UPDATE cron_jobs
   SET state = 'executing',
     start_time = (NOW() AT TIME ZONE 'utc')::TIMESTAMPTZ
-  WHERE id = ANY (sqlc.arg('ids'))
+  WHERE key = ANY (sqlc.arg('keys'))
     AND state = 'idle'
     AND start_time < next_execution
     AND (next_execution AT TIME ZONE 'utc') < (NOW() AT TIME ZONE 'utc')::TIMESTAMPTZ
-  RETURNING id, state, start_time, next_execution)
-SELECT j.id as id, d.key as deployment_key, j.module_name as module, j.verb, j.schedule,
+  RETURNING id, key, state, start_time, next_execution)
+SELECT j.key as key, d.key as deployment_key, j.module_name as module, j.verb, j.schedule,
   COALESCE(u.start_time, j.start_time) as start_time, 
   COALESCE(u.next_execution, j.next_execution) as next_execution, 
   COALESCE(u.state, j.state) as state,
   d.min_replicas > 0 as has_min_replicas,
-  CASE WHEN u.id IS NULL THEN FALSE ELSE TRUE END as updated
+  CASE WHEN u.key IS NULL THEN FALSE ELSE TRUE END as updated
 FROM cron_jobs j
   INNER JOIN deployments d on j.deployment_id = d.id
   LEFT JOIN updates u on j.id = u.id
-WHERE j.id = ANY (sqlc.arg('ids'));
+WHERE j.key = ANY (sqlc.arg('keys'));
 
 -- name: EndCronJob :one
 WITH j AS (
 UPDATE cron_jobs
   SET state = 'idle',
     next_execution = sqlc.arg('next_execution')::TIMESTAMPTZ
-  WHERE id = sqlc.arg('id')::BIGINT
+  WHERE key = sqlc.arg('key')::cron_job_key
     AND state = 'executing'
     AND start_time = sqlc.arg('start_time')::TIMESTAMPTZ
   RETURNING *
 )
-SELECT j.id as id, d.key as deployment_key, j.module_name as module, j.verb, j.schedule, j.start_time, j.next_execution, j.state
+SELECT j.key as key, d.key as deployment_key, j.module_name as module, j.verb, j.schedule, j.start_time, j.next_execution, j.state
   FROM j
   INNER JOIN deployments d on j.deployment_id = d.id
   LIMIT 1;
 
 -- name: GetStaleCronJobs :many
-SELECT j.id as id, d.key as deployment_key, j.module_name as module, j.verb, j.schedule, j.start_time, j.next_execution, j.state
+SELECT j.key as key, d.key as deployment_key, j.module_name as module, j.verb, j.schedule, j.start_time, j.next_execution, j.state
 FROM cron_jobs j
   INNER JOIN deployments d on j.deployment_id = d.id
 WHERE state = 'executing'

backend/controller/sql/schema/001_init.sql

@@ -237,9 +237,12 @@ CREATE TYPE cron_job_state AS ENUM (
     'executing'
 );
 
+CREATE DOMAIN cron_job_key AS VARCHAR;
+
 CREATE TABLE cron_jobs
 (
     id             BIGINT      NOT NULL GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY,
+    key            cron_job_key UNIQUE NOT NULL,
     deployment_id  BIGINT      NOT NULL REFERENCES deployments (id) ON DELETE CASCADE,
     verb           VARCHAR     NOT NULL,	
     schedule       VARCHAR	   NOT NULL,
@@ -252,6 +255,7 @@ CREATE TABLE cron_jobs
 );
 
 CREATE INDEX cron_jobs_executing_start_time_idx ON cron_jobs (start_time) WHERE state = 'executing';
+CREATE UNIQUE INDEX cron_jobs_key_idx ON cron_jobs (key);
 
 CREATE TYPE event_type AS ENUM (
     'call',

backend/controller/sql/types.go

@@ -13,12 +13,16 @@ import (
 type NullTime = optional.Option[time.Time]
 type NullDuration = optional.Option[time.Duration]
 type NullRunnerKey = optional.Option[model.RunnerKey]
+type NullCronJobKey = optional.Option[model.CronJobKey]
 type NullDeploymentKey = optional.Option[model.DeploymentKey]
 type NullRequestKey = optional.Option[model.RequestKey]
 
 var _ sql.Scanner = (*NullRunnerKey)(nil)
 var _ driver.Valuer = (*NullRunnerKey)(nil)
 
+var _ sql.Scanner = (*NullCronJobKey)(nil)
+var _ driver.Valuer = (*NullCronJobKey)(nil)
+
 var _ sql.Scanner = (*NullDeploymentKey)(nil)
 var _ driver.Valuer = (*NullDeploymentKey)(nil)
 

internal/model/cron_job_key.go

@@ -0,0 +1,31 @@
+package model
+
+import (
+	"errors"
+	"strings"
+)
+
+type CronJobKey = KeyType[CronJobPayload, *CronJobPayload]
+
+func NewCronJobKey(module, verb string) CronJobKey {
+	return newKey[CronJobPayload](strings.Join([]string{module, verb}, "-"))
+}
+
+func ParseCronJobKey(key string) (CronJobKey, error) { return parseKey[CronJobPayload](key) }
+
+type CronJobPayload struct {
+	Ref string
+}
+
+var _ KeyPayload = (*CronJobPayload)(nil)
+
+func (d *CronJobPayload) Kind() string   { return "crn" }
+func (d *CronJobPayload) String() string { return d.Ref }
+func (d *CronJobPayload) Parse(parts []string) error {
+	if len(parts) == 0 {
+		return errors.New("expected <module>-<verb> but got empty string")
+	}
+	d.Ref = strings.Join(parts, "-")
+	return nil
+}
+func (d *CronJobPayload) RandomBytes() int { return 10 }