@workglow/supabase 0.2.28

package/dist/job-queue/node.js

@@ -0,0 +1,765 @@
+// src/job-queue/SupabaseQueueStorage.ts
+import { createServiceToken, deepEqual, makeFingerprint, uuid4 } from "@workglow/util";
+import { PollingSubscriptionManager } from "@workglow/storage";
+import { JobStatus } from "@workglow/job-queue";
+var SUPABASE_QUEUE_STORAGE = createServiceToken("jobqueue.storage.supabase");
+
+class SupabaseQueueStorage {
+  queueName;
+  scope = "cluster";
+  client;
+  prefixes;
+  prefixValues;
+  tableName;
+  realtimeChannel = null;
+  pollingManager = null;
+  constructor(client, queueName, options) {
+    this.queueName = queueName;
+    this.client = client;
+    this.prefixes = options?.prefixes ?? [];
+    this.prefixValues = options?.prefixValues ?? {};
+    if (this.prefixes.length > 0) {
+      const prefixNames = this.prefixes.map((p) => p.name).join("_");
+      this.tableName = `job_queue_${prefixNames}`;
+    } else {
+      this.tableName = "job_queue";
+    }
+  }
+  getPrefixColumnType(type) {
+    return type === "uuid" ? "UUID" : "INTEGER";
+  }
+  buildPrefixColumnsSql() {
+    if (this.prefixes.length === 0)
+      return "";
+    return this.prefixes.map((p) => `${p.name} ${this.getPrefixColumnType(p.type)} NOT NULL`).join(`,
+      `) + `,
+      `;
+  }
+  getPrefixColumnNames() {
+    return this.prefixes.map((p) => p.name);
+  }
+  applyPrefixFilters(query) {
+    let result = query;
+    for (const prefix of this.prefixes) {
+      result = result.eq(prefix.name, this.prefixValues[prefix.name]);
+    }
+    return result;
+  }
+  getPrefixInsertValues() {
+    const values = {};
+    for (const prefix of this.prefixes) {
+      values[prefix.name] = this.prefixValues[prefix.name];
+    }
+    return values;
+  }
+  buildPrefixWhereSql() {
+    if (this.prefixes.length === 0) {
+      return "";
+    }
+    const conditions = this.prefixes.map((p) => {
+      const value = this.prefixValues[p.name];
+      if (p.type === "uuid") {
+        const validated = this.validateSqlValue(String(value), `prefix "${p.name}"`);
+        return `${p.name} = '${this.escapeSqlString(validated)}'`;
+      }
+      const numValue = Number(value ?? 0);
+      if (!Number.isFinite(numValue)) {
+        throw new Error(`Invalid numeric prefix value for "${p.name}": ${value}`);
+      }
+      return `${p.name} = ${numValue}`;
+    }).join(" AND ");
+    return " AND " + conditions;
+  }
+  static SAFE_SQL_VALUE_RE = /^[a-zA-Z0-9_\-.:]+$/;
+  validateSqlValue(value, context) {
+    if (!SupabaseQueueStorage.SAFE_SQL_VALUE_RE.test(value)) {
+      throw new Error(`Unsafe value for ${context}: "${value}". Values must match /^[a-zA-Z0-9_\\-.:]+$/.`);
+    }
+    return value;
+  }
+  escapeSqlString(value) {
+    return value.replace(/'/g, "''");
+  }
+  async setupDatabase() {
+    const createTypeSql = `CREATE TYPE job_status AS ENUM (${Object.values(JobStatus).map((v) => `'${v}'`).join(",")})`;
+    const { error: typeError } = await this.client.rpc("exec_sql", { query: createTypeSql });
+    if (typeError && typeError.code !== "42710") {
+      throw typeError;
+    }
+    const prefixColumnsSql = this.buildPrefixColumnsSql();
+    const prefixColumnNames = this.getPrefixColumnNames();
+    const prefixIndexPrefix = prefixColumnNames.length > 0 ? prefixColumnNames.join(", ") + ", " : "";
+    const indexSuffix = prefixColumnNames.length > 0 ? "_" + prefixColumnNames.join("_") : "";
+    const createTableSql = `
+    CREATE TABLE IF NOT EXISTS ${this.tableName} (
+      id SERIAL NOT NULL,
+      ${prefixColumnsSql}fingerprint text NOT NULL,
+      queue text NOT NULL,
+      job_run_id text NOT NULL,
+      status job_status NOT NULL default 'PENDING',
+      input jsonb NOT NULL,
+      output jsonb,
+      run_attempts integer default 0,
+      max_retries integer default 20,
+      run_after timestamp with time zone DEFAULT now(),
+      last_ran_at timestamp with time zone,
+      created_at timestamp with time zone DEFAULT now(),
+      deadline_at timestamp with time zone,
+      completed_at timestamp with time zone,
+      error text,
+      error_code text,
+      progress real DEFAULT 0,
+      progress_message text DEFAULT '',
+      progress_details jsonb,
+      worker_id text
+    )`;
+    const { error: tableError } = await this.client.rpc("exec_sql", { query: createTableSql });
+    if (tableError) {
+      if (tableError.code !== "42P07") {
+        throw tableError;
+      }
+    }
+    const indexes = [
+      `CREATE INDEX IF NOT EXISTS job_fetcher${indexSuffix}_idx ON ${this.tableName} (${prefixIndexPrefix}id, status, run_after)`,
+      `CREATE INDEX IF NOT EXISTS job_queue_fetcher${indexSuffix}_idx ON ${this.tableName} (${prefixIndexPrefix}queue, status, run_after)`,
+      `CREATE INDEX IF NOT EXISTS jobs_fingerprint${indexSuffix}_unique_idx ON ${this.tableName} (${prefixIndexPrefix}queue, fingerprint, status)`
+    ];
+    for (const indexSql of indexes) {
+      await this.client.rpc("exec_sql", { query: indexSql });
+    }
+  }
+  async add(job) {
+    const now = new Date().toISOString();
+    job.queue = this.queueName;
+    job.job_run_id = job.job_run_id ?? uuid4();
+    job.fingerprint = await makeFingerprint(job.input);
+    job.status = JobStatus.PENDING;
+    job.progress = 0;
+    job.progress_message = "";
+    job.progress_details = null;
+    job.created_at = now;
+    job.run_after = now;
+    const prefixInsertValues = this.getPrefixInsertValues();
+    const { data, error } = await this.client.from(this.tableName).insert({
+      ...prefixInsertValues,
+      queue: job.queue,
+      fingerprint: job.fingerprint,
+      input: job.input,
+      run_after: job.run_after,
+      created_at: job.created_at,
+      deadline_at: job.deadline_at,
+      max_retries: job.max_retries,
+      job_run_id: job.job_run_id,
+      progress: job.progress,
+      progress_message: job.progress_message,
+      progress_details: job.progress_details
+    }).select("id").single();
+    if (error)
+      throw error;
+    if (!data)
+      throw new Error("Failed to add to queue");
+    job.id = data.id;
+    return job.id;
+  }
+  async get(id) {
+    let query = this.client.from(this.tableName).select("*").eq("id", id).eq("queue", this.queueName);
+    query = this.applyPrefixFilters(query);
+    const { data, error } = await query.single();
+    if (error) {
+      if (error.code === "PGRST116")
+        return;
+      throw error;
+    }
+    return data;
+  }
+  async peek(status = JobStatus.PENDING, num = 100) {
+    num = Number(num) || 100;
+    let query = this.client.from(this.tableName).select("*").eq("queue", this.queueName).eq("status", status);
+    query = this.applyPrefixFilters(query);
+    const { data, error } = await query.order("run_after", { ascending: true }).limit(num);
+    if (error)
+      throw error;
+    return data ?? [];
+  }
+  async next(workerId) {
+    const prefixConditions = this.buildPrefixWhereSql();
+    const validatedQueueName = this.validateSqlValue(this.queueName, "queueName");
+    const validatedWorkerId = this.validateSqlValue(workerId, "workerId");
+    const escapedQueueName = this.escapeSqlString(validatedQueueName);
+    const escapedWorkerId = this.escapeSqlString(validatedWorkerId);
+    const sql = `
+      UPDATE ${this.tableName}
+      SET status = '${JobStatus.PROCESSING}', last_ran_at = NOW() AT TIME ZONE 'UTC', worker_id = '${escapedWorkerId}'
+      WHERE id = (
+        SELECT id
+        FROM ${this.tableName}
+        WHERE queue = '${escapedQueueName}'
+        AND status = '${JobStatus.PENDING}'
+        ${prefixConditions}
+        AND run_after <= NOW() AT TIME ZONE 'UTC'
+        ORDER BY run_after ASC
+        FOR UPDATE SKIP LOCKED
+        LIMIT 1
+      )
+      RETURNING *`;
+    const { data, error } = await this.client.rpc("exec_sql", { query: sql });
+    if (error)
+      throw error;
+    if (!data || !Array.isArray(data) || data.length === 0) {
+      return;
+    }
+    return data[0];
+  }
+  async size(status = JobStatus.PENDING) {
+    let query = this.client.from(this.tableName).select("*", { count: "exact", head: true }).eq("queue", this.queueName).eq("status", status);
+    query = this.applyPrefixFilters(query);
+    const { count, error } = await query;
+    if (error)
+      throw error;
+    return count ?? 0;
+  }
+  async getAllJobs() {
+    let query = this.client.from(this.tableName).select("*").eq("queue", this.queueName);
+    query = this.applyPrefixFilters(query);
+    const { data, error } = await query;
+    if (error)
+      throw error;
+    return data ?? [];
+  }
+  async complete(jobDetails) {
+    const now = new Date().toISOString();
+    if (jobDetails.status === JobStatus.DISABLED) {
+      let query2 = this.client.from(this.tableName).update({
+        status: jobDetails.status,
+        progress: 100,
+        progress_message: "",
+        progress_details: null,
+        completed_at: now,
+        last_ran_at: now
+      }).eq("id", jobDetails.id).eq("queue", this.queueName);
+      query2 = this.applyPrefixFilters(query2);
+      const { error: error2 } = await query2;
+      if (error2)
+        throw error2;
+      return;
+    }
+    let getQuery = this.client.from(this.tableName).select("run_attempts, max_retries").eq("id", jobDetails.id).eq("queue", this.queueName);
+    getQuery = this.applyPrefixFilters(getQuery);
+    const { data: current, error: getError } = await getQuery.single();
+    if (getError)
+      throw getError;
+    const currentAttempts = current?.run_attempts ?? 0;
+    const maxRetries = current?.max_retries ?? jobDetails.max_retries ?? 10;
+    const nextAttempts = currentAttempts + 1;
+    if (jobDetails.status === JobStatus.PENDING) {
+      if (nextAttempts > maxRetries) {
+        let failQuery = this.client.from(this.tableName).update({
+          status: JobStatus.FAILED,
+          error: "Max retries reached",
+          error_code: "MAX_RETRIES_REACHED",
+          progress: 100,
+          progress_message: "",
+          progress_details: null,
+          completed_at: now,
+          last_ran_at: now
+        }).eq("id", jobDetails.id).eq("queue", this.queueName);
+        failQuery = this.applyPrefixFilters(failQuery);
+        const { error: failError } = await failQuery;
+        if (failError)
+          throw failError;
+        return;
+      }
+      let query2 = this.client.from(this.tableName).update({
+        error: jobDetails.error ?? null,
+        error_code: jobDetails.error_code ?? null,
+        status: jobDetails.status,
+        run_after: jobDetails.run_after,
+        progress: 0,
+        progress_message: "",
+        progress_details: null,
+        run_attempts: nextAttempts,
+        last_ran_at: now
+      }).eq("id", jobDetails.id).eq("queue", this.queueName);
+      query2 = this.applyPrefixFilters(query2);
+      const { error: error2 } = await query2;
+      if (error2)
+        throw error2;
+      return;
+    }
+    if (jobDetails.status === JobStatus.COMPLETED || jobDetails.status === JobStatus.FAILED) {
+      let query2 = this.client.from(this.tableName).update({
+        output: jobDetails.output ?? null,
+        error: jobDetails.error ?? null,
+        error_code: jobDetails.error_code ?? null,
+        status: jobDetails.status,
+        progress: 100,
+        progress_message: "",
+        progress_details: null,
+        run_attempts: nextAttempts,
+        completed_at: now,
+        last_ran_at: now
+      }).eq("id", jobDetails.id).eq("queue", this.queueName);
+      query2 = this.applyPrefixFilters(query2);
+      const { error: error2 } = await query2;
+      if (error2)
+        throw error2;
+      return;
+    }
+    let query = this.client.from(this.tableName).update({
+      status: jobDetails.status,
+      output: jobDetails.output ?? null,
+      error: jobDetails.error ?? null,
+      error_code: jobDetails.error_code ?? null,
+      run_after: jobDetails.run_after ?? null,
+      run_attempts: nextAttempts,
+      last_ran_at: now
+    }).eq("id", jobDetails.id).eq("queue", this.queueName);
+    query = this.applyPrefixFilters(query);
+    const { error } = await query;
+    if (error)
+      throw error;
+  }
+  async release(jobId) {
+    let query = this.client.from(this.tableName).update({
+      status: JobStatus.PENDING,
+      worker_id: null,
+      progress: 0,
+      progress_message: "",
+      progress_details: null
+    }).eq("id", jobId).eq("queue", this.queueName);
+    query = this.applyPrefixFilters(query);
+    const { error } = await query;
+    if (error)
+      throw error;
+  }
+  async deleteAll() {
+    let query = this.client.from(this.tableName).delete().eq("queue", this.queueName);
+    query = this.applyPrefixFilters(query);
+    const { error } = await query;
+    if (error)
+      throw error;
+  }
+  async outputForInput(input) {
+    const fingerprint = await makeFingerprint(input);
+    let query = this.client.from(this.tableName).select("output").eq("fingerprint", fingerprint).eq("queue", this.queueName).eq("status", JobStatus.COMPLETED);
+    query = this.applyPrefixFilters(query);
+    const { data, error } = await query.single();
+    if (error) {
+      if (error.code === "PGRST116")
+        return null;
+      throw error;
+    }
+    return data?.output ?? null;
+  }
+  async abort(jobId) {
+    let query = this.client.from(this.tableName).update({ status: JobStatus.ABORTING }).eq("id", jobId).eq("queue", this.queueName);
+    query = this.applyPrefixFilters(query);
+    const { error } = await query;
+    if (error)
+      throw error;
+  }
+  async getByRunId(job_run_id) {
+    let query = this.client.from(this.tableName).select("*").eq("job_run_id", job_run_id).eq("queue", this.queueName);
+    query = this.applyPrefixFilters(query);
+    const { data, error } = await query;
+    if (error)
+      throw error;
+    return data ?? [];
+  }
+  async saveProgress(jobId, progress, message, details) {
+    let query = this.client.from(this.tableName).update({
+      progress,
+      progress_message: message,
+      progress_details: details
+    }).eq("id", jobId).eq("queue", this.queueName);
+    query = this.applyPrefixFilters(query);
+    const { error } = await query;
+    if (error)
+      throw error;
+  }
+  async delete(jobId) {
+    let query = this.client.from(this.tableName).delete().eq("id", jobId).eq("queue", this.queueName);
+    query = this.applyPrefixFilters(query);
+    const { error } = await query;
+    if (error)
+      throw error;
+  }
+  async deleteJobsByStatusAndAge(status, olderThanMs) {
+    const cutoffDate = new Date(Date.now() - olderThanMs).toISOString();
+    let query = this.client.from(this.tableName).delete().eq("queue", this.queueName).eq("status", status).not("completed_at", "is", null).lte("completed_at", cutoffDate);
+    query = this.applyPrefixFilters(query);
+    const { error } = await query;
+    if (error)
+      throw error;
+  }
+  matchesPrefixFilter(job, prefixFilter) {
+    if (!job)
+      return false;
+    if (job.queue !== this.queueName) {
+      return false;
+    }
+    if (prefixFilter && Object.keys(prefixFilter).length === 0) {
+      return true;
+    }
+    const filterValues = prefixFilter ?? this.prefixValues;
+    if (Object.keys(filterValues).length === 0) {
+      return true;
+    }
+    for (const [key, value] of Object.entries(filterValues)) {
+      if (job[key] !== value) {
+        return false;
+      }
+    }
+    return true;
+  }
+  isCustomPrefixFilter(prefixFilter) {
+    if (prefixFilter === undefined) {
+      return false;
+    }
+    if (Object.keys(prefixFilter).length === 0) {
+      return true;
+    }
+    const instanceKeys = Object.keys(this.prefixValues);
+    const filterKeys = Object.keys(prefixFilter);
+    if (instanceKeys.length !== filterKeys.length) {
+      return true;
+    }
+    for (const key of instanceKeys) {
+      if (this.prefixValues[key] !== prefixFilter[key]) {
+        return true;
+      }
+    }
+    return false;
+  }
+  async getAllJobsWithFilter(prefixFilter) {
+    let query = this.client.from(this.tableName).select("*").eq("queue", this.queueName);
+    for (const [key, value] of Object.entries(prefixFilter)) {
+      query = query.eq(key, value);
+    }
+    const { data, error } = await query;
+    if (error)
+      throw error;
+    return data ?? [];
+  }
+  subscribeToChanges(callback, options) {
+    return this.subscribeToChangesWithRealtime(callback, options?.prefixFilter);
+  }
+  subscribeToChangesWithRealtime(callback, prefixFilter) {
+    const channelName = `queue-${this.tableName}-${this.queueName}-${Date.now()}`;
+    this.realtimeChannel = this.client.channel(channelName).on("postgres_changes", {
+      event: "*",
+      schema: "public",
+      table: this.tableName,
+      filter: `queue=eq.${this.queueName}`
+    }, (payload) => {
+      const newJob = payload.new;
+      const oldJob = payload.old;
+      const newMatches = this.matchesPrefixFilter(newJob, prefixFilter);
+      const oldMatches = this.matchesPrefixFilter(oldJob, prefixFilter);
+      if (!newMatches && !oldMatches) {
+        return;
+      }
+      callback({
+        type: payload.eventType.toUpperCase(),
+        old: oldJob && Object.keys(oldJob).length > 0 ? oldJob : undefined,
+        new: newJob && Object.keys(newJob).length > 0 ? newJob : undefined
+      });
+    }).subscribe();
+    return () => {
+      if (this.realtimeChannel) {
+        this.client.removeChannel(this.realtimeChannel);
+        this.realtimeChannel = null;
+      }
+    };
+  }
+  getPollingManager() {
+    if (!this.pollingManager) {
+      this.pollingManager = new PollingSubscriptionManager(async () => {
+        const jobs = await this.getAllJobs();
+        return new Map(jobs.map((j) => [j.id, j]));
+      }, (a, b) => deepEqual(a, b), {
+        insert: (item) => ({ type: "INSERT", new: item }),
+        update: (oldItem, newItem) => ({ type: "UPDATE", old: oldItem, new: newItem }),
+        delete: (item) => ({ type: "DELETE", old: item })
+      });
+    }
+    return this.pollingManager;
+  }
+  subscribeWithCustomPrefixFilterPolling(callback, prefixFilter, intervalMs) {
+    let lastKnownJobs = new Map;
+    let cancelled = false;
+    const poll = async () => {
+      if (cancelled)
+        return;
+      try {
+        const currentJobs = await this.getAllJobsWithFilter(prefixFilter);
+        if (cancelled)
+          return;
+        const currentMap = new Map(currentJobs.map((j) => [j.id, j]));
+        for (const [id, job] of currentMap) {
+          const old = lastKnownJobs.get(id);
+          if (!old) {
+            callback({ type: "INSERT", new: job });
+          } else if (!deepEqual(old, job)) {
+            callback({ type: "UPDATE", old, new: job });
+          }
+        }
+        for (const [id, job] of lastKnownJobs) {
+          if (!currentMap.has(id)) {
+            callback({ type: "DELETE", old: job });
+          }
+        }
+        lastKnownJobs = currentMap;
+      } catch {}
+    };
+    const intervalId = setInterval(poll, intervalMs);
+    poll();
+    return () => {
+      cancelled = true;
+      clearInterval(intervalId);
+    };
+  }
+  subscribeToChangesWithPolling(callback, options) {
+    const intervalMs = options?.pollingIntervalMs ?? 1000;
+    if (this.isCustomPrefixFilter(options?.prefixFilter)) {
+      return this.subscribeWithCustomPrefixFilterPolling(callback, options.prefixFilter, intervalMs);
+    }
+    const manager = this.getPollingManager();
+    return manager.subscribe(callback, { intervalMs });
+  }
+}
+// src/job-queue/SupabaseRateLimiterStorage.ts
+import { createServiceToken as createServiceToken2 } from "@workglow/util";
+var SUPABASE_RATE_LIMITER_STORAGE = createServiceToken2("ratelimiter.storage.supabase");
+
+class SupabaseRateLimiterStorage {
+  scope = "cluster";
+  client;
+  prefixes;
+  prefixValues;
+  executionTableName;
+  nextAvailableTableName;
+  constructor(client, options) {
+    this.client = client;
+    this.prefixes = options?.prefixes ?? [];
+    this.prefixValues = options?.prefixValues ?? {};
+    if (this.prefixes.length > 0) {
+      const prefixNames = this.prefixes.map((p) => p.name).join("_");
+      this.executionTableName = `rate_limit_executions_${prefixNames}`;
+      this.nextAvailableTableName = `rate_limit_next_available_${prefixNames}`;
+    } else {
+      this.executionTableName = "rate_limit_executions";
+      this.nextAvailableTableName = "rate_limit_next_available";
+    }
+  }
+  getPrefixColumnType(type) {
+    return type === "uuid" ? "UUID" : "INTEGER";
+  }
+  buildPrefixColumnsSql() {
+    if (this.prefixes.length === 0)
+      return "";
+    return this.prefixes.map((p) => `${p.name} ${this.getPrefixColumnType(p.type)} NOT NULL`).join(`,
+        `) + `,
+        `;
+  }
+  getPrefixColumnNames() {
+    return this.prefixes.map((p) => p.name);
+  }
+  applyPrefixFilters(query) {
+    let result = query;
+    for (const prefix of this.prefixes) {
+      result = result.eq(prefix.name, this.prefixValues[prefix.name]);
+    }
+    return result;
+  }
+  getPrefixInsertValues() {
+    const values = {};
+    for (const prefix of this.prefixes) {
+      values[prefix.name] = this.prefixValues[prefix.name];
+    }
+    return values;
+  }
+  async setupDatabase() {
+    const prefixColumnsSql = this.buildPrefixColumnsSql();
+    const prefixColumnNames = this.getPrefixColumnNames();
+    const prefixIndexPrefix = prefixColumnNames.length > 0 ? prefixColumnNames.join(", ") + ", " : "";
+    const indexSuffix = prefixColumnNames.length > 0 ? "_" + prefixColumnNames.join("_") : "";
+    const createExecTableSql = `
+      CREATE TABLE IF NOT EXISTS ${this.executionTableName} (
+        id SERIAL PRIMARY KEY,
+        ${prefixColumnsSql}queue_name TEXT NOT NULL,
+        executed_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
+      )
+    `;
+    const { error: execTableError } = await this.client.rpc("exec_sql", {
+      query: createExecTableSql
+    });
+    if (execTableError && execTableError.code !== "42P07") {
+      throw execTableError;
+    }
+    const createExecIndexSql = `
+      CREATE INDEX IF NOT EXISTS rate_limit_exec_queue${indexSuffix}_idx 
+        ON ${this.executionTableName} (${prefixIndexPrefix}queue_name, executed_at)
+    `;
+    await this.client.rpc("exec_sql", { query: createExecIndexSql });
+    const primaryKeyColumns = prefixColumnNames.length > 0 ? `${prefixColumnNames.join(", ")}, queue_name` : "queue_name";
+    const createNextTableSql = `
+      CREATE TABLE IF NOT EXISTS ${this.nextAvailableTableName} (
+        ${prefixColumnsSql}queue_name TEXT NOT NULL,
+        next_available_at TIMESTAMP WITH TIME ZONE,
+        PRIMARY KEY (${primaryKeyColumns})
+      )
+    `;
+    const { error: nextTableError } = await this.client.rpc("exec_sql", {
+      query: createNextTableSql
+    });
+    if (nextTableError && nextTableError.code !== "42P07") {
+      throw nextTableError;
+    }
+    const fnName = this.atomicReserveFunctionName();
+    const prefixSig = this.prefixes.map((p) => `${p.name} ${this.getPrefixColumnType(p.type)}`).join(", ");
+    const prefixSigPrefix = prefixSig ? prefixSig + ", " : "";
+    const prefixWhere = this.prefixes.length > 0 ? " AND " + this.prefixes.map((p) => `${p.name} = _${p.name}`).join(" AND ") : "";
+    const prefixInsertCols = this.prefixes.length > 0 ? this.prefixes.map((p) => p.name).join(", ") + ", " : "";
+    const prefixInsertVals = this.prefixes.length > 0 ? this.prefixes.map((p) => `_${p.name}`).join(", ") + ", " : "";
+    const lockKeyParts = [
+      `'${this.executionTableName}'`,
+      ...this.prefixes.map((p) => `_${p.name}::text`),
+      `_queue_name::text`
+    ];
+    const lockKeyExpr = `hashtextextended(${lockKeyParts.join(" || '|' || ")}, 0)`;
+    const createFnSql = `
+      CREATE OR REPLACE FUNCTION ${fnName}(
+        ${prefixSigPrefix}_queue_name TEXT, _window_start TIMESTAMPTZ, _max_exec INT
+      ) RETURNS BIGINT AS $fn$
+      DECLARE
+        _count INT;
+        _next TIMESTAMPTZ;
+        _new_id BIGINT;
+      BEGIN
+        PERFORM pg_advisory_xact_lock(${lockKeyExpr});
+        SELECT COUNT(*) INTO _count FROM ${this.executionTableName}
+          WHERE queue_name = _queue_name AND executed_at > _window_start${prefixWhere};
+        IF _count >= _max_exec THEN RETURN NULL; END IF;
+        SELECT next_available_at INTO _next FROM ${this.nextAvailableTableName}
+          WHERE queue_name = _queue_name${prefixWhere};
+        IF _next IS NOT NULL AND _next > NOW() THEN RETURN NULL; END IF;
+        INSERT INTO ${this.executionTableName} (${prefixInsertCols}queue_name)
+          VALUES (${prefixInsertVals}_queue_name)
+          RETURNING id INTO _new_id;
+        RETURN _new_id;
+      END;
+      $fn$ LANGUAGE plpgsql;
+    `;
+    const { error: fnError } = await this.client.rpc("exec_sql", { query: createFnSql });
+    if (fnError) {
+      throw fnError;
+    }
+  }
+  atomicReserveFunctionName() {
+    return `${this.executionTableName}_try_reserve`.slice(0, 63);
+  }
+  async tryReserveExecution(queueName, maxExecutions, windowMs) {
+    const args = {
+      _queue_name: queueName,
+      _window_start: new Date(Date.now() - windowMs).toISOString(),
+      _max_exec: maxExecutions
+    };
+    for (const p of this.prefixes) {
+      args[`_${p.name}`] = this.prefixValues[p.name];
+    }
+    const { data, error } = await this.client.rpc(this.atomicReserveFunctionName(), args);
+    if (error)
+      throw error;
+    if (data === null || data === undefined)
+      return null;
+    if (Array.isArray(data)) {
+      if (data.length === 0)
+        return null;
+      const first = Object.values(data[0])[0];
+      return first ?? null;
+    }
+    return data;
+  }
+  async releaseExecution(queueName, token) {
+    if (token === null || token === undefined)
+      return;
+    let del = this.client.from(this.executionTableName).delete().eq("id", token).eq("queue_name", queueName);
+    del = this.applyPrefixFilters(del);
+    const { error: delError } = await del;
+    if (delError)
+      throw delError;
+  }
+  async recordExecution(queueName) {
+    const prefixInsertValues = this.getPrefixInsertValues();
+    const { error } = await this.client.from(this.executionTableName).insert({
+      ...prefixInsertValues,
+      queue_name: queueName
+    });
+    if (error)
+      throw error;
+  }
+  async getExecutionCount(queueName, windowStartTime) {
+    let query = this.client.from(this.executionTableName).select("*", { count: "exact", head: true }).eq("queue_name", queueName).gt("executed_at", windowStartTime);
+    query = this.applyPrefixFilters(query);
+    const { count, error } = await query;
+    if (error)
+      throw error;
+    return count ?? 0;
+  }
+  async getOldestExecutionAtOffset(queueName, offset) {
+    let query = this.client.from(this.executionTableName).select("executed_at").eq("queue_name", queueName);
+    query = this.applyPrefixFilters(query);
+    const { data, error } = await query.order("executed_at", { ascending: true }).range(offset, offset);
+    if (error)
+      throw error;
+    if (!data || data.length === 0)
+      return;
+    return new Date(data[0].executed_at).toISOString();
+  }
+  async getNextAvailableTime(queueName) {
+    let query = this.client.from(this.nextAvailableTableName).select("next_available_at").eq("queue_name", queueName);
+    query = this.applyPrefixFilters(query);
+    const { data, error } = await query.single();
+    if (error) {
+      if (error.code === "PGRST116")
+        return;
+      throw error;
+    }
+    if (!data?.next_available_at)
+      return;
+    return new Date(data.next_available_at).toISOString();
+  }
+  async setNextAvailableTime(queueName, nextAvailableAt) {
+    const prefixInsertValues = this.getPrefixInsertValues();
+    const { error } = await this.client.from(this.nextAvailableTableName).upsert({
+      ...prefixInsertValues,
+      queue_name: queueName,
+      next_available_at: nextAvailableAt
+    }, {
+      onConflict: this.prefixes.length > 0 ? `${this.getPrefixColumnNames().join(",")},queue_name` : "queue_name"
+    });
+    if (error)
+      throw error;
+  }
+  async clear(queueName) {
+    let execQuery = this.client.from(this.executionTableName).delete().eq("queue_name", queueName);
+    execQuery = this.applyPrefixFilters(execQuery);
+    const { error: execError } = await execQuery;
+    if (execError)
+      throw execError;
+    let nextQuery = this.client.from(this.nextAvailableTableName).delete().eq("queue_name", queueName);
+    nextQuery = this.applyPrefixFilters(nextQuery);
+    const { error: nextError } = await nextQuery;
+    if (nextError)
+      throw nextError;
+  }
+}
+export {
+  SupabaseRateLimiterStorage,
+  SupabaseQueueStorage,
+  SUPABASE_RATE_LIMITER_STORAGE,
+  SUPABASE_QUEUE_STORAGE
+};
+
+//# debugId=FFFCF982F7410DEF64756E2164756E21