create-protobase 0.23.13 → 0.24.0

package/dist/templates/erp/db/migrations/012_jobs.sql

@@ -0,0 +1,531 @@
+-- The jobs schema this version of Protobase needs, written by `protobase migration`.
+-- Applied with the project's other migrations; edit or remove statements the project handles differently.
+
+SELECT pg_advisory_xact_lock(('x' || encode(sha224((current_database() || '.pgboss.jobs')::bytea), 'hex'))::bit(64)::bigint);
+CREATE SCHEMA IF NOT EXISTS jobs;
+
+    CREATE TYPE jobs.job_state AS ENUM (
+      'created',
+      'retry',
+      'active',
+      'completed',
+      'cancelled',
+      'failed'
+    )
+  ;
+
+    CREATE FUNCTION jobs.job_now()
+    RETURNS timestamp with time zone AS
+    $$
+      SELECT pg_catalog.now();
+    $$
+    LANGUAGE sql STABLE;
+  ;
+
+    CREATE TABLE jobs.version (
+      version int primary key,
+      cron_on timestamp with time zone,
+      bam_on timestamp with time zone,
+      flow_on timestamp with time zone,
+      reindex_on timestamp with time zone,
+      monitor_backoff_on timestamp with time zone
+    )
+  ;
+
+    CREATE TABLE jobs.queue (
+      name text NOT NULL,
+      policy text NOT NULL,
+      retry_limit int NOT NULL,
+      retry_delay int NOT NULL,
+      retry_backoff bool NOT NULL,
+      retry_delay_max int,
+      expire_seconds int NOT NULL,
+      retention_seconds int NOT NULL,
+      deletion_seconds int NOT NULL,
+      dead_letter text REFERENCES jobs.queue (name) CHECK (dead_letter IS DISTINCT FROM name),
+      partition bool NOT NULL,
+      table_name text NOT NULL,
+      deferred_count int NOT NULL default 0,
+      blocked_count int NOT NULL default 0,
+      queued_count int NOT NULL default 0,
+      ready_count int NOT NULL default 0,
+      warning_queued int NOT NULL default 0,
+      active_count int NOT NULL default 0,
+      failed_count int NOT NULL default 0,
+      total_count int NOT NULL default 0,
+      created_delta int NOT NULL default 0,
+      completed_delta int NOT NULL default 0,
+      failed_delta int NOT NULL default 0,
+      delta_on timestamp with time zone,
+      delta_seconds int,
+      wait_bins int[],
+      run_bins int[],
+      ready_oldest_seconds int,
+      ready_history int[] NOT NULL default '{}',
+      heartbeat_seconds int,
+      notify bool NOT NULL DEFAULT false,
+      singletons_active text[],
+      monitor_claim_on timestamp with time zone,
+      monitor_on timestamp with time zone,
+      maintain_on timestamp with time zone,
+      created_on timestamp with time zone not null default now(),
+      updated_on timestamp with time zone not null default now(),
+      PRIMARY KEY (name)
+    )
+  ;
+
+    CREATE TABLE jobs.schedule (
+      name text REFERENCES jobs.queue ON DELETE CASCADE,
+      key text not null DEFAULT '',
+      kind text not null DEFAULT 'cron' CHECK (kind IN ('cron', 'rrule')),
+      cron text not null,
+      timezone text DEFAULT 'UTC',
+      data jsonb,
+      options jsonb,
+      created_on timestamp with time zone not null default now(),
+      updated_on timestamp with time zone not null default now(),
+      last_job_id uuid,
+      PRIMARY KEY (name, key)
+    )
+  ;
+
+    CREATE TABLE jobs.subscription (
+      event text not null,
+      name text not null REFERENCES jobs.queue ON DELETE CASCADE,
+      created_on timestamp with time zone not null default now(),
+      updated_on timestamp with time zone not null default now(),
+      PRIMARY KEY(event, name)
+    )
+  ;
+
+    CREATE TABLE jobs.bam (
+      id uuid PRIMARY KEY default gen_random_uuid(),
+      name text NOT NULL,
+      version int NOT NULL,
+      status text NOT NULL DEFAULT 'pending',
+      queue text,
+      table_name text NOT NULL,
+      command text NOT NULL,
+      error text,
+      created_on timestamp with time zone NOT NULL DEFAULT clock_timestamp(),
+      started_on timestamp with time zone,
+      completed_on timestamp with time zone
+    )
+  ;
+
+    CREATE FUNCTION jobs.job_table_format(command text, table_name text)
+    RETURNS text AS
+    $$
+      SELECT format(
+        regexp_replace(
+          regexp_replace(command, '\.job\y', '.%1$I', 'g'),
+          '\yjob_i(\d+)', '%1$s_i\1', 'g'
+        ),
+        table_name
+      );
+    $$
+    LANGUAGE sql IMMUTABLE;
+  ;
+
+    CREATE FUNCTION jobs.job_table_run(command text, tbl_name text DEFAULT NULL, queue_name text DEFAULT NULL)
+    RETURNS VOID AS
+    $$
+    DECLARE
+      tbl RECORD;
+    BEGIN
+      IF queue_name IS NOT NULL THEN
+        SELECT table_name INTO tbl_name FROM jobs.queue WHERE name = queue_name;
+      END IF;
+
+      IF tbl_name IS NOT NULL THEN
+        EXECUTE jobs.job_table_format(command, tbl_name);
+        RETURN;
+      END IF;
+
+      EXECUTE jobs.job_table_format(command, 'job_common');
+
+      FOR tbl IN SELECT table_name FROM jobs.queue WHERE partition = true
+      LOOP
+        EXECUTE jobs.job_table_format(command, tbl.table_name);
+      END LOOP;
+    END;
+    $$
+    LANGUAGE plpgsql;
+  ;
+
+    CREATE FUNCTION jobs.job_table_run_async(command_name text, version int, command text, tbl_name text DEFAULT NULL, queue_name text DEFAULT NULL)
+    RETURNS VOID AS
+    $$
+    BEGIN
+      IF queue_name IS NOT NULL THEN
+        SELECT table_name INTO tbl_name FROM jobs.queue WHERE name = queue_name;
+      END IF;
+
+      IF tbl_name IS NOT NULL THEN
+        INSERT INTO jobs.bam (name, version, status, queue, table_name, command)
+        VALUES (
+          command_name,
+          version,
+          'pending',
+          queue_name,
+          tbl_name,
+          jobs.job_table_format(command, tbl_name)
+        );
+        RETURN;
+      END IF;
+
+      INSERT INTO jobs.bam (name, version, status, queue, table_name, command)
+      SELECT
+        command_name,
+        version,
+        'pending',
+        NULL,
+        'job_common',
+        jobs.job_table_format(command, 'job_common')
+      UNION ALL
+      SELECT
+        command_name,
+        version,
+        'pending',
+        queue.name,
+        queue.table_name,
+        jobs.job_table_format(command, queue.table_name)
+      FROM jobs.queue
+      WHERE partition = true;
+    END;
+    $$
+    LANGUAGE plpgsql;
+  ;
+
+    CREATE TABLE jobs.job (
+      id uuid not null default gen_random_uuid(),
+      name text not null,
+      priority integer not null default(0),
+      data jsonb,
+      state jobs.job_state not null default 'created',
+      retry_limit integer not null default 2,
+      retry_count integer not null default 0,
+      retry_delay integer not null default 0,
+      retry_backoff boolean not null default false,
+      retry_delay_max integer,
+      expire_seconds int not null default 900,
+      deletion_seconds int not null default 604800,
+      singleton_key text,
+      singleton_on timestamp without time zone,
+      group_id text,
+      group_tier text,
+      start_after timestamp with time zone not null default now(),
+      created_on timestamp with time zone not null default now(),
+      started_on timestamp with time zone,
+      completed_on timestamp with time zone,
+      keep_until timestamp with time zone NOT NULL default now() + interval '1209600',
+      output jsonb,
+      dead_letter text,
+      policy text,
+      heartbeat_on timestamp with time zone,
+      heartbeat_seconds int,
+      blocked boolean not null default false,
+      blocking boolean not null default false,
+      pending_dependencies int not null default 0,
+      source_name text,
+      source_id uuid,
+      source_created_on timestamp with time zone,
+      source_retry_count int,
+      source_output jsonb,
+      source_root_id uuid,
+      trace_context jsonb,
+      upsert_by_key bool
+    ) PARTITION BY LIST (name)
+  ;
+ALTER TABLE jobs.job ADD PRIMARY KEY (name, id);
+
+    CREATE TABLE jobs.job_common (LIKE jobs.job INCLUDING GENERATED INCLUDING DEFAULTS);
+
+    SELECT jobs.job_table_run($cmd$ALTER TABLE jobs.job ADD PRIMARY KEY (name, id)$cmd$, 'job_common');
+    SELECT jobs.job_table_run($cmd$ALTER TABLE jobs.job ADD CONSTRAINT q_fkey FOREIGN KEY (name) REFERENCES jobs.queue (name) ON DELETE RESTRICT DEFERRABLE INITIALLY DEFERRED$cmd$, 'job_common');
+    SELECT jobs.job_table_run($cmd$ALTER TABLE jobs.job ADD CONSTRAINT dlq_fkey FOREIGN KEY (dead_letter) REFERENCES jobs.queue (name) ON DELETE RESTRICT DEFERRABLE INITIALLY DEFERRED$cmd$, 'job_common');
+    SELECT jobs.job_table_run($cmd$CREATE UNIQUE INDEX job_i1 ON jobs.job (name, COALESCE(singleton_key, '')) WHERE state = 'created' AND policy = 'short'$cmd$, 'job_common');
+    SELECT jobs.job_table_run($cmd$CREATE UNIQUE INDEX job_i2 ON jobs.job (name, COALESCE(singleton_key, '')) WHERE state = 'active' AND policy = 'singleton'$cmd$, 'job_common');
+    SELECT jobs.job_table_run($cmd$CREATE UNIQUE INDEX job_i3 ON jobs.job (name, state, COALESCE(singleton_key, '')) WHERE state <= 'active' AND policy = 'stately'$cmd$, 'job_common');
+    SELECT jobs.job_table_run($cmd$CREATE UNIQUE INDEX job_i6 ON jobs.job (name, COALESCE(singleton_key, '')) WHERE state <= 'active' AND policy = 'exclusive'$cmd$, 'job_common');
+    SELECT jobs.job_table_run($cmd$CREATE UNIQUE INDEX job_i8 ON jobs.job (name, singleton_key) WHERE state IN ('active', 'retry', 'failed') AND policy = 'key_strict_fifo'$cmd$, 'job_common');
+    SELECT jobs.job_table_run($cmd$CREATE INDEX job_i10 ON jobs.job (name, singleton_key, state DESC, created_on, id) INCLUDE (start_after) WHERE state < 'active' AND NOT blocked AND policy = 'key_strict_fifo'$cmd$, 'job_common');
+    SELECT jobs.job_table_run($cmd$ALTER TABLE jobs.job ADD CONSTRAINT job_key_strict_fifo_singleton_key_check CHECK (NOT (policy = 'key_strict_fifo' AND singleton_key IS NULL))$cmd$, 'job_common');
+    SELECT jobs.job_table_run($cmd$CREATE UNIQUE INDEX job_i4 ON jobs.job (name, singleton_on, COALESCE(singleton_key, '')) WHERE state <> 'cancelled' AND singleton_on IS NOT NULL$cmd$, 'job_common');
+    SELECT jobs.job_table_run($cmd$CREATE INDEX job_i11 ON jobs.job (name, priority DESC, created_on, start_after) WHERE state < 'active' AND NOT blocked$cmd$, 'job_common');
+    SELECT jobs.job_table_run($cmd$CREATE INDEX job_i7 ON jobs.job (name, group_id) WHERE state = 'active' AND group_id IS NOT NULL$cmd$, 'job_common');
+    SELECT jobs.job_table_run($cmd$CREATE INDEX job_i9 ON jobs.job (name, id) WHERE blocking AND state = 'completed'$cmd$, 'job_common');
+    SELECT jobs.job_table_run($cmd$CREATE INDEX job_i12 ON jobs.job (source_root_id) WHERE source_root_id IS NOT NULL$cmd$, 'job_common');
+    SELECT jobs.job_table_run($cmd$CREATE UNIQUE INDEX job_i13 ON jobs.job (name, singleton_key) WHERE state = 'created' AND upsert_by_key$cmd$, 'job_common');
+
+    ALTER TABLE jobs.job ATTACH PARTITION jobs.job_common DEFAULT;
+  ;
+
+    CREATE TABLE jobs.warning (
+      id uuid PRIMARY KEY default gen_random_uuid(),
+      type text NOT NULL,
+      message text NOT NULL,
+      data jsonb,
+      created_on timestamp with time zone NOT NULL DEFAULT now()
+    )
+  ;
+CREATE INDEX warning_i1 ON jobs.warning (created_on DESC);
+
+    CREATE TABLE jobs.queue_stats (
+      id uuid NOT NULL DEFAULT gen_random_uuid(),
+      name text NOT NULL,
+      deferred_count int NOT NULL DEFAULT 0,
+      queued_count   int NOT NULL DEFAULT 0,
+      ready_count    int NOT NULL DEFAULT 0,
+      active_count   int NOT NULL DEFAULT 0,
+      failed_count   int NOT NULL DEFAULT 0,
+      total_count    int NOT NULL DEFAULT 0,
+      created_delta   int,
+      completed_delta int,
+      failed_delta    int,
+      delta_seconds   int,
+      delta_on        timestamptz,
+      wait_bins       int[],
+      run_bins        int[],
+      ready_oldest_seconds int,
+      captured_on timestamptz NOT NULL DEFAULT now(),
+      PRIMARY KEY (id, captured_on)
+    ) PARTITION BY RANGE (captured_on)
+  ;
+CREATE INDEX queue_stats_i1 ON jobs.queue_stats (name, captured_on DESC) INCLUDE (deferred_count, queued_count, ready_count, active_count, failed_count, total_count);
+
+    DO $$
+    DECLARE
+      d date;
+      i int;
+      part_name text;
+    BEGIN
+      FOR i IN 0..1 LOOP
+        d := (jobs.job_now() AT TIME ZONE 'UTC')::date + i;
+        part_name := 'queue_stats_' || to_char(d, 'YYYYMMDD');
+        IF NOT EXISTS (
+          SELECT 1 FROM pg_class c
+          JOIN pg_namespace n ON n.oid = c.relnamespace
+          WHERE n.nspname = 'jobs' AND c.relname = part_name
+        ) THEN
+          EXECUTE format(
+            'CREATE TABLE jobs.%I PARTITION OF jobs.queue_stats FOR VALUES FROM (%L) TO (%L)',
+            part_name,
+            to_char(d, 'YYYY-MM-DD') || ' 00:00:00+00',
+            to_char(d + 1, 'YYYY-MM-DD') || ' 00:00:00+00'
+          );
+        END IF;
+      END LOOP;
+    END;
+    $$
+  ;
+
+    CREATE TABLE jobs.job_dependency (
+      child_name text NOT NULL,
+      child_id uuid NOT NULL,
+      parent_name text NOT NULL,
+      parent_id uuid NOT NULL,
+      PRIMARY KEY (child_name, child_id, parent_name, parent_id)
+    )
+  ;
+CREATE INDEX IF NOT EXISTS job_dep_parent_idx ON jobs.job_dependency (parent_name, parent_id);
+
+    CREATE TABLE jobs.instance (
+      id uuid PRIMARY KEY,
+      name text,
+      host text NOT NULL,
+      pid int NOT NULL,
+      version text NOT NULL,
+      node_version text NOT NULL,
+      application_name text,
+      heartbeat_seconds int NOT NULL,
+      supervise bool NOT NULL,
+      schedule bool NOT NULL,
+      migrate bool NOT NULL,
+      persist_queue_stats bool NOT NULL,
+      persist_warnings bool NOT NULL,
+      pool_max int,
+      pool_total int,
+      pool_idle int,
+      pool_waiting int,
+      workers jsonb NOT NULL DEFAULT '[]'::jsonb,
+      metrics jsonb,
+      config jsonb NOT NULL DEFAULT '{}'::jsonb,
+      crash_restarts int NOT NULL DEFAULT 0,
+      crash_restarts_since timestamptz,
+      started_on timestamptz NOT NULL DEFAULT now(),
+      heartbeat_on timestamptz NOT NULL DEFAULT now(),
+      stopped_on timestamptz
+    )
+  ;
+
+    CREATE FUNCTION jobs.create_queue(queue_name text, options jsonb)
+    RETURNS VOID AS
+    $$
+    DECLARE
+      tablename varchar := CASE WHEN options->>'partition' = 'true'
+                            THEN 'j' || encode(sha224(queue_name::bytea), 'hex')
+                            ELSE 'job_common'
+                            END;
+      queue_created_on timestamptz;
+    BEGIN
+
+      WITH q as (
+        INSERT INTO jobs.queue (
+          name,
+          policy,
+          retry_limit,
+          retry_delay,
+          retry_backoff,
+          retry_delay_max,
+          expire_seconds,
+          retention_seconds,
+          deletion_seconds,
+          warning_queued,
+          dead_letter,
+          partition,
+          table_name,
+          heartbeat_seconds,
+          notify,
+          created_on,
+          updated_on
+        )
+        VALUES (
+          queue_name,
+          options->>'policy',
+          COALESCE((options->>'retryLimit')::int, 2),
+          COALESCE((options->>'retryDelay')::int, 0),
+          COALESCE((options->>'retryBackoff')::bool, false),
+          (options->>'retryDelayMax')::int,
+          COALESCE((options->>'expireInSeconds')::int, 900),
+          COALESCE((options->>'retentionSeconds')::int, 1209600),
+          COALESCE((options->>'deleteAfterSeconds')::int, 604800),
+          COALESCE((options->>'warningQueueSize')::int, 0),
+          options->>'deadLetter',
+          COALESCE((options->>'partition')::bool, false),
+          tablename,
+          (options->>'heartbeatSeconds')::int,
+          COALESCE((options->>'notify')::bool, false),
+          jobs.job_now(),
+          jobs.job_now()
+        )
+        ON CONFLICT DO NOTHING
+        RETURNING created_on
+      )
+      SELECT created_on into queue_created_on from q;
+
+      IF queue_created_on IS NULL OR options->>'partition' IS DISTINCT FROM 'true' THEN
+        RETURN;
+      END IF;
+
+      EXECUTE format('CREATE TABLE jobs.%I (LIKE jobs.job INCLUDING DEFAULTS)', tablename);
+
+      EXECUTE jobs.job_table_format($cmd$ALTER TABLE jobs.job ADD PRIMARY KEY (name, id)$cmd$, tablename);
+      EXECUTE jobs.job_table_format($cmd$ALTER TABLE jobs.job ADD CONSTRAINT q_fkey FOREIGN KEY (name) REFERENCES jobs.queue (name) ON DELETE RESTRICT DEFERRABLE INITIALLY DEFERRED$cmd$, tablename);
+      EXECUTE jobs.job_table_format($cmd$ALTER TABLE jobs.job ADD CONSTRAINT dlq_fkey FOREIGN KEY (dead_letter) REFERENCES jobs.queue (name) ON DELETE RESTRICT DEFERRABLE INITIALLY DEFERRED$cmd$, tablename);
+
+      EXECUTE jobs.job_table_format($cmd$CREATE INDEX job_i11 ON jobs.job (name, priority DESC, created_on, start_after) WHERE state < 'active' AND NOT blocked$cmd$, tablename);
+      EXECUTE jobs.job_table_format($cmd$CREATE UNIQUE INDEX job_i4 ON jobs.job (name, singleton_on, COALESCE(singleton_key, '')) WHERE state <> 'cancelled' AND singleton_on IS NOT NULL$cmd$, tablename);
+      EXECUTE jobs.job_table_format($cmd$CREATE INDEX job_i7 ON jobs.job (name, group_id) WHERE state = 'active' AND group_id IS NOT NULL$cmd$, tablename);
+      EXECUTE jobs.job_table_format($cmd$CREATE INDEX job_i9 ON jobs.job (name, id) WHERE blocking AND state = 'completed'$cmd$, tablename);
+      EXECUTE jobs.job_table_format($cmd$CREATE INDEX job_i12 ON jobs.job (source_root_id) WHERE source_root_id IS NOT NULL$cmd$, tablename);
+      EXECUTE jobs.job_table_format($cmd$CREATE UNIQUE INDEX job_i13 ON jobs.job (name, singleton_key) WHERE state = 'created' AND upsert_by_key$cmd$, tablename);
+
+      IF options->>'policy' = 'short' THEN
+        EXECUTE jobs.job_table_format($cmd$CREATE UNIQUE INDEX job_i1 ON jobs.job (name, COALESCE(singleton_key, '')) WHERE state = 'created' AND policy = 'short'$cmd$, tablename);
+      ELSIF options->>'policy' = 'singleton' THEN
+        EXECUTE jobs.job_table_format($cmd$CREATE UNIQUE INDEX job_i2 ON jobs.job (name, COALESCE(singleton_key, '')) WHERE state = 'active' AND policy = 'singleton'$cmd$, tablename);
+      ELSIF options->>'policy' = 'stately' THEN
+        EXECUTE jobs.job_table_format($cmd$CREATE UNIQUE INDEX job_i3 ON jobs.job (name, state, COALESCE(singleton_key, '')) WHERE state <= 'active' AND policy = 'stately'$cmd$, tablename);
+      ELSIF options->>'policy' = 'exclusive' THEN
+        EXECUTE jobs.job_table_format($cmd$CREATE UNIQUE INDEX job_i6 ON jobs.job (name, COALESCE(singleton_key, '')) WHERE state <= 'active' AND policy = 'exclusive'$cmd$, tablename);
+      ELSIF options->>'policy' = 'key_strict_fifo' THEN
+        EXECUTE jobs.job_table_format($cmd$CREATE UNIQUE INDEX job_i8 ON jobs.job (name, singleton_key) WHERE state IN ('active', 'retry', 'failed') AND policy = 'key_strict_fifo'$cmd$, tablename);
+        EXECUTE jobs.job_table_format($cmd$CREATE INDEX job_i10 ON jobs.job (name, singleton_key, state DESC, created_on, id) INCLUDE (start_after) WHERE state < 'active' AND NOT blocked AND policy = 'key_strict_fifo'$cmd$, tablename);
+        EXECUTE jobs.job_table_format($cmd$ALTER TABLE jobs.job ADD CONSTRAINT job_key_strict_fifo_singleton_key_check CHECK (NOT (policy = 'key_strict_fifo' AND singleton_key IS NULL))$cmd$, tablename);
+      END IF;
+
+      EXECUTE format('ALTER TABLE jobs.%I ADD CONSTRAINT cjc CHECK (name=%L)', tablename, queue_name);
+      EXECUTE format('ALTER TABLE jobs.job ATTACH PARTITION jobs.%I FOR VALUES IN (%L)', tablename, queue_name);
+    END;
+    $$
+    LANGUAGE plpgsql;
+  ;
+
+    CREATE FUNCTION jobs.delete_queue(queue_name text)
+    RETURNS VOID AS
+    $$
+    DECLARE
+      v_table varchar;
+      v_partition bool;
+    BEGIN
+      
+      SELECT table_name, partition
+      FROM jobs.queue
+      WHERE name = queue_name
+      INTO v_table, v_partition;
+
+      IF v_partition THEN
+        EXECUTE format('DROP TABLE IF EXISTS jobs.%I', v_table);
+      ELSE
+        EXECUTE format('DELETE FROM jobs.%I WHERE name = %L', v_table, queue_name);
+      END IF;
+    
+      DELETE FROM jobs.queue WHERE name = queue_name;
+    END;
+    $$
+    LANGUAGE plpgsql;
+  ;
+INSERT INTO jobs.version(version) VALUES ('45');
+
+create or replace function jobs.enqueue(
+  job_name text,
+  payload jsonb default null,
+  run_at timestamptz default null,
+  key text default null,
+  group_key text default null,
+  priority integer default 0
+) returns uuid
+language plpgsql as $$
+declare
+  queue jobs.queue;
+  start timestamptz := coalesce(run_at, jobs.job_now());
+  job_id uuid;
+begin
+  if key is not null and group_key is not null then
+    raise exception 'Job "%": an ordered job takes a group_key and no key', job_name;
+  end if;
+  perform jobs.create_queue(job_name, jsonb_build_object('policy', case when group_key is null then 'standard' else 'key_strict_fifo' end));
+  select * into queue from jobs.queue where name = job_name;
+  if (queue.policy = 'key_strict_fifo') <> (group_key is not null) then
+    raise exception 'Job "%" %', job_name, case when group_key is null then 'is ordered: pass its group_key' else 'is not ordered: it takes no group_key' end;
+  end if;
+  if key is not null then
+    select id into job_id from jobs.job
+    where name = job_name and singleton_key = key and state < 'active'
+    order by created_on desc limit 1;
+    if found then
+      return job_id;
+    end if;
+  end if;
+  execute format(
+    'insert into jobs.%I (name, data, priority, start_after, singleton_key, retry_limit, retry_delay, retry_backoff,
+       retry_delay_max, expire_seconds, deletion_seconds, keep_until, policy, dead_letter, heartbeat_seconds, upsert_by_key)
+     values ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $4 + $12 * interval ''1s'', $13, $14, $15, $16)
+     on conflict do nothing
+     returning id',
+    queue.table_name)
+  using job_name, payload, priority, start, coalesce(key, group_key), queue.retry_limit, queue.retry_delay,
+    queue.retry_backoff, queue.retry_delay_max, queue.expire_seconds, queue.deletion_seconds, queue.retention_seconds,
+    queue.policy, queue.dead_letter, queue.heartbeat_seconds, key is not null
+  into job_id;
+  -- A concurrent enqueue of the same key inserted first: its job is the one waiting.
+  if job_id is null and key is not null then
+    select id into job_id from jobs.job
+    where name = job_name and singleton_key = key and state < 'active'
+    order by created_on desc limit 1;
+  end if;
+  return job_id;
+end
+$$;
+comment on function jobs.enqueue(text, jsonb, timestamptz, text, text, integer) is 'Protobase jobs 1';

package/dist/templates/erp/db/migrations/013_jobs.sql

@@ -0,0 +1,98 @@
+-- The jobs schema this version of Protobase needs, written by `protobase migration`.
+-- Applied with the project's other migrations; edit or remove statements the project handles differently.
+
+create or replace function jobs.enqueue(
+  job_name text,
+  payload jsonb default null,
+  run_at timestamptz default null,
+  key text default null,
+  group_key text default null,
+  priority integer default 0
+) returns uuid
+language plpgsql as $$
+declare
+  queue jobs.queue;
+  start timestamptz := coalesce(run_at, jobs.job_now());
+  job_id uuid;
+begin
+  if key is not null and group_key is not null then
+    raise exception 'Job "%": an ordered job takes a group_key and no key', job_name;
+  end if;
+  perform jobs.create_queue(job_name, jsonb_build_object('policy', case when group_key is null then 'standard' else 'key_strict_fifo' end));
+  select * into queue from jobs.queue where name = job_name;
+  if (queue.policy = 'key_strict_fifo') <> (group_key is not null) then
+    raise exception 'Job "%" %', job_name, case when group_key is null then 'is ordered: pass its group_key' else 'is not ordered: it takes no group_key' end;
+  end if;
+  if key is not null then
+    select id into job_id from jobs.job
+    where name = job_name and singleton_key = key and state < 'active'
+    order by created_on desc limit 1;
+    if found then
+      return job_id;
+    end if;
+  end if;
+  execute format(
+    'insert into jobs.%I (name, data, priority, start_after, singleton_key, retry_limit, retry_delay, retry_backoff,
+       retry_delay_max, expire_seconds, deletion_seconds, keep_until, policy, dead_letter, heartbeat_seconds, upsert_by_key)
+     values ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $4 + $12 * interval ''1s'', $13, $14, $15, $16)
+     on conflict do nothing
+     returning id',
+    queue.table_name)
+  using job_name, payload, priority, start, coalesce(key, group_key), queue.retry_limit, queue.retry_delay,
+    queue.retry_backoff, queue.retry_delay_max, queue.expire_seconds, queue.deletion_seconds, queue.retention_seconds,
+    queue.policy, queue.dead_letter, queue.heartbeat_seconds, key is not null
+  into job_id;
+  -- A concurrent enqueue of the same key inserted first: its job is the one waiting.
+  if job_id is null and key is not null then
+    select id into job_id from jobs.job
+    where name = job_name and singleton_key = key and state < 'active'
+    order by created_on desc limit 1;
+  end if;
+  return job_id;
+end
+$$;
+comment on function jobs.enqueue(text, jsonb, timestamptz, text, text, integer) is 'Protobase jobs 2';
+
+create or replace function jobs.next_due() returns timestamptz
+language sql stable as $$
+  select min(due) from (
+    select j.start_after as due from jobs.job j
+    where j.state < 'active' and not j.blocked
+      and not (j.policy = 'key_strict_fifo' and exists (
+        select 1 from jobs.job h where h.name = j.name and h.singleton_key = j.singleton_key and h.state = 'failed'))
+    union all
+    select started_on + expire_seconds * interval '1s' from jobs.job where state = 'active'
+  ) jobs
+$$;
+comment on function jobs.next_due() is 'Protobase jobs 2';
+
+create index if not exists job_failed_i on jobs.job (completed_on) where state = 'failed';
+drop view if exists jobs.failed;
+create view jobs.failed as
+select id, name, data as payload, retry_count + 1 as attempts,
+  coalesce(output ->> 'message', output -> 'value' ->> 'message', output ->> 'value') as error,
+  output, completed_on as failed_at, created_on as created_at, singleton_key as key, false as retry
+from jobs.job where state = 'failed';
+create or replace function jobs.failed_retry() returns trigger
+language plpgsql as $$
+begin
+  if new.retry then
+    update jobs.job
+    set state = 'retry', retry_limit = retry_limit + 1, completed_on = null,
+      start_after = greatest(start_after, jobs.job_now()), keep_until = greatest(keep_until, jobs.job_now() + interval '14 days')
+    where name = old.name and id = old.id and state = 'failed';
+  end if;
+  return new;
+end
+$$;
+comment on function jobs.failed_retry() is 'Protobase jobs 2';
+create or replace function jobs.failed_delete() returns trigger
+language plpgsql as $$
+begin
+  delete from jobs.job where name = old.name and id = old.id and state = 'failed';
+  return old;
+end
+$$;
+comment on function jobs.failed_delete() is 'Protobase jobs 2';
+create trigger failed_retry instead of update on jobs.failed for each row execute function jobs.failed_retry();
+create trigger failed_delete instead of delete on jobs.failed for each row execute function jobs.failed_delete();