@sonamu-kit/tasks 0.1.3 → 0.3.0

package/src/database/backend.ts

@@ -1,6 +1,9 @@
 import { getLogger } from "@logtape/logtape";
 import { camelize } from "inflection";
-import knex, { type Knex } from "knex";
+import knex from "knex";
+import { type Knex } from "knex";
+
+import { DEFAULT_NAMESPACE_ID } from "../backend";
 import {
   type Backend,
   type CancelWorkflowRunParams,
@@ -9,7 +12,6 @@ import {
   type CompleteWorkflowRunParams,
   type CreateStepAttemptParams,
   type CreateWorkflowRunParams,
-  DEFAULT_NAMESPACE_ID,
   type ExtendWorkflowRunLeaseParams,
   type FailStepAttemptParams,
   type FailWorkflowRunParams,
@@ -18,13 +20,17 @@ import {
   type ListStepAttemptsParams,
   type ListWorkflowRunsParams,
   type PaginatedResponse,
+  type PauseWorkflowRunParams,
+  type ResumeWorkflowRunParams,
   type SleepWorkflowRunParams,
 } from "../backend";
-import { DEFAULT_RETRY_POLICY } from "../core/retry";
-import type { StepAttempt } from "../core/step";
-import type { WorkflowRun } from "../core/workflow";
+import { mergeRetryPolicy } from "../core/retry";
+import { type SerializableRetryPolicy } from "../core/retry";
+import { type StepAttempt } from "../core/step";
+import { type WorkflowRun } from "../core/workflow";
 import { DEFAULT_SCHEMA, migrate } from "./base";
-import { type OnSubscribed, PostgresPubSub } from "./pubsub";
+import { PostgresPubSub } from "./pubsub";
+import { type OnSubscribed } from "./pubsub";
 
 export const DEFAULT_LISTEN_CHANNEL = "new_tasks" as const;
 const DEFAULT_PAGINATION_PAGE_SIZE = 100 as const;
@@ -155,6 +161,8 @@ export class BackendPostgres implements Backend {
     await this.pubsub?.destroy();
     this.pubsub = null;
     await this.knex.destroy();
+    this._knex = null;
+    this.initialized = false;
   }
 
   async createWorkflowRun(params: CreateWorkflowRunParams): Promise<WorkflowRun> {
@@ -167,6 +175,12 @@ export class BackendPostgres implements Backend {
       version: params.version,
     });
 
+    // config에 retryPolicy를 포함시킵니다.
+    const configWithRetryPolicy = {
+      ...(typeof params.config === "object" && params.config !== null ? params.config : {}),
+      retryPolicy: params.retryPolicy ?? undefined,
+    };
+
     const qb = this.knex
       .withSchema(DEFAULT_SCHEMA)
       .table("workflow_runs")
@@ -177,7 +191,7 @@ export class BackendPostgres implements Backend {
         version: params.version,
         status: "pending",
         idempotency_key: params.idempotencyKey,
-        config: params.config,
+        config: JSON.stringify(configWithRetryPolicy),
         context: params.context,
         input: params.input,
         attempts: 0,
@@ -247,6 +261,8 @@ export class BackendPostgres implements Backend {
     });
     const limit = params.limit ?? DEFAULT_PAGINATION_PAGE_SIZE;
     const { after, before } = params;
+    const order = params.order ?? "asc";
+    const reverseOrder = order === "asc" ? "desc" : "asc";
 
     let cursor: Cursor | null = null;
     if (after) {
@@ -255,10 +271,10 @@ export class BackendPostgres implements Backend {
       cursor = decodeCursor(before);
     }
 
-    const qb = this.buildListWorkflowRunsWhere(params, cursor);
+    const qb = this.buildListWorkflowRunsWhere(params, cursor, order);
     const rows = await qb
-      .orderBy("created_at", before ? "desc" : "asc")
-      .orderBy("id", before ? "desc" : "asc")
+      .orderBy("created_at", before ? reverseOrder : order)
+      .orderBy("id", before ? reverseOrder : order)
       .limit(limit + 1);
 
     return this.processPaginationResults(
@@ -269,7 +285,11 @@ export class BackendPostgres implements Backend {
     );
   }
 
-  private buildListWorkflowRunsWhere(params: ListWorkflowRunsParams, cursor: Cursor | null) {
+  private buildListWorkflowRunsWhere(
+    params: ListWorkflowRunsParams,
+    cursor: Cursor | null,
+    order: "asc" | "desc",
+  ) {
     const { after } = params;
     const qb = this.knex
       .withSchema(DEFAULT_SCHEMA)
@@ -277,13 +297,28 @@ export class BackendPostgres implements Backend {
       .where("namespace_id", this.namespaceId);
 
     if (cursor) {
-      const operator = after ? ">" : "<";
-      return qb.whereRaw(`("created_at", "id") ${operator} (?, ?)`, [
+      // asc: after → ">", before → "<"
+      // desc: after → "<", before → ">"
+      const operator = (order === "asc") === !!after ? ">" : "<";
+      qb.whereRaw(`("created_at", "id") ${operator} (?, ?)`, [
         cursor.createdAt.toISOString(),
         cursor.id,
       ]);
     }
 
+    if (params.status && params.status.length > 0) {
+      qb.whereIn("status", params.status);
+    }
+    if (params.workflowName) {
+      qb.where("workflow_name", params.workflowName);
+    }
+    if (params.createdAfter) {
+      qb.where("created_at", ">=", params.createdAfter);
+    }
+    if (params.createdBefore) {
+      qb.where("created_at", "<=", params.createdBefore);
+    }
+
     return qb;
   }
 
@@ -375,6 +410,11 @@ export class BackendPostgres implements Backend {
       .returning("*");
 
     if (!updated) {
+      const wr = await this.getWorkflowRun({ workflowRunId: params.workflowRunId });
+      if (wr && (wr.status === "paused" || wr.status === "canceled")) {
+        throw new Error("Workflow run is paused or canceled");
+      }
+
       logger.error("Failed to extend lease for workflow run: {params}", { params });
       throw new Error("Failed to extend lease for workflow run");
     }
@@ -459,8 +499,60 @@ export class BackendPostgres implements Backend {
       throw new Error("Backend not initialized");
     }
 
-    const { workflowRunId, error } = params;
-    const { initialIntervalMs, backoffCoefficient, maximumIntervalMs } = DEFAULT_RETRY_POLICY;
+    const { workflowRunId, error, forceComplete, customDelayMs } = params;
+
+    logger.info("Failing workflow run: {workflowRunId}, {workerId}, {error}", {
+      workflowRunId: params.workflowRunId,
+      workerId: params.workerId,
+      error: params.error,
+    });
+
+    const workflowRun = await this.knex
+      .withSchema(DEFAULT_SCHEMA)
+      .table("workflow_runs")
+      .where("namespace_id", this.namespaceId)
+      .where("id", workflowRunId)
+      .first();
+
+    if (!workflowRun) {
+      throw new Error("Workflow run not found");
+    }
+
+    const config =
+      typeof workflowRun.config === "string" ? JSON.parse(workflowRun.config) : workflowRun.config;
+    const savedRetryPolicy: SerializableRetryPolicy | undefined = config?.retryPolicy;
+    const retryPolicy = mergeRetryPolicy(savedRetryPolicy);
+
+    const { initialIntervalMs, backoffCoefficient, maximumIntervalMs, maxAttempts } = retryPolicy;
+
+    const currentAttempts = workflowRun.attempts ?? 0;
+    const shouldForceComplete = forceComplete || currentAttempts >= maxAttempts;
+
+    if (shouldForceComplete) {
+      const [updated] = await this.knex
+        .withSchema(DEFAULT_SCHEMA)
+        .table("workflow_runs")
+        .where("namespace_id", this.namespaceId)
+        .where("id", workflowRunId)
+        .where("status", "running")
+        .where("worker_id", params.workerId)
+        .update({
+          status: "failed",
+          available_at: null,
+          finished_at: this.knex.fn.now(),
+          error: JSON.stringify(error),
+          worker_id: null,
+          started_at: null,
+          updated_at: this.knex.fn.now(),
+        })
+        .returning("*");
+
+      if (!updated) {
+        logger.error("Failed to mark workflow run failed: {params}", { params });
+        throw new Error("Failed to mark workflow run failed");
+      }
+      return updated;
+    }
 
     // this beefy query updates a workflow's status, available_at, and
     // finished_at based on the workflow's deadline and retry policy
@@ -468,15 +560,11 @@ export class BackendPostgres implements Backend {
     // if the next retry would exceed the deadline, the run is marked as
     // 'failed' and finalized, otherwise, the run is rescheduled with an updated
     // 'available_at' timestamp for the next retry
-    const retryIntervalExpr = `LEAST(${initialIntervalMs} * POWER(${backoffCoefficient}, "attempts" - 1), ${maximumIntervalMs}) * INTERVAL '1 millisecond'`;
+    const retryIntervalExpr = customDelayMs
+      ? `${customDelayMs} * INTERVAL '1 millisecond'`
+      : `LEAST(${initialIntervalMs} * POWER(${backoffCoefficient}, "attempts" - 1), ${maximumIntervalMs}) * INTERVAL '1 millisecond'`;
     const deadlineExceededCondition = `"deadline_at" IS NOT NULL AND NOW() + (${retryIntervalExpr}) >= "deadline_at"`;
 
-    logger.info("Failing workflow run: {workflowRunId}, {workerId}, {error}", {
-      workflowRunId: params.workflowRunId,
-      workerId: params.workerId,
-      error: params.error,
-    });
-
     const [updated] = await this.knex
       .withSchema(DEFAULT_SCHEMA)
       .table("workflow_runs")
@@ -521,7 +609,7 @@ export class BackendPostgres implements Backend {
       .table("workflow_runs")
       .where("namespace_id", this.namespaceId)
       .where("id", params.workflowRunId)
-      .whereIn("status", ["pending", "running", "sleeping"])
+      .whereIn("status", ["pending", "running", "sleeping", "paused"])
       .update({
         status: "canceled",
         worker_id: null,
@@ -564,6 +652,111 @@ export class BackendPostgres implements Backend {
     return updated;
   }
 
+  async pauseWorkflowRun(params: PauseWorkflowRunParams): Promise<WorkflowRun> {
+    if (!this.initialized) {
+      throw new Error("Backend not initialized");
+    }
+
+    logger.info("Pausing workflow run: {workflowRunId}", { workflowRunId: params.workflowRunId });
+
+    const [updated] = await this.knex
+      .withSchema(DEFAULT_SCHEMA)
+      .table("workflow_runs")
+      .where("namespace_id", this.namespaceId)
+      .where("id", params.workflowRunId)
+      .whereIn("status", ["pending", "running", "sleeping"])
+      .update({
+        status: "paused",
+        worker_id: null,
+        available_at: null,
+        updated_at: this.knex.fn.now(),
+      })
+      .returning("*");
+
+    if (!updated) {
+      const existing = await this.getWorkflowRun({
+        workflowRunId: params.workflowRunId,
+      });
+      if (!existing) {
+        throw new Error(`Workflow run ${params.workflowRunId} does not exist`);
+      }
+
+      // 이미 paused이면 멱등하게 반환합니다.
+      if (existing.status === "paused") {
+        return existing;
+      }
+
+      // 터미널 상태에서는 pause할 수 없습니다.
+      // 'succeeded' status is deprecated
+      if (["succeeded", "completed", "failed", "canceled"].includes(existing.status)) {
+        logger.error("Cannot pause workflow run: {params} with status {status}", {
+          params,
+          status: existing.status,
+        });
+        throw new Error(
+          `Cannot pause workflow run ${params.workflowRunId} with status ${existing.status}`,
+        );
+      }
+
+      logger.error("Failed to pause workflow run: {params}", { params });
+      throw new Error("Failed to pause workflow run");
+    }
+
+    return updated;
+  }
+
+  async resumeWorkflowRun(params: ResumeWorkflowRunParams): Promise<WorkflowRun> {
+    if (!this.initialized) {
+      throw new Error("Backend not initialized");
+    }
+
+    logger.info("Resuming workflow run: {workflowRunId}", { workflowRunId: params.workflowRunId });
+
+    const [updated] = await this.knex
+      .withSchema(DEFAULT_SCHEMA)
+      .table("workflow_runs")
+      .where("namespace_id", this.namespaceId)
+      .where("id", params.workflowRunId)
+      .where("status", "paused")
+      .update({
+        status: "pending",
+        available_at: this.knex.fn.now(),
+        updated_at: this.knex.fn.now(),
+      })
+      .returning("*");
+
+    if (!updated) {
+      const existing = await this.getWorkflowRun({
+        workflowRunId: params.workflowRunId,
+      });
+      if (!existing) {
+        throw new Error(`Workflow run ${params.workflowRunId} does not exist`);
+      }
+
+      // 이미 pending/running이면 멱등하게 반환합니다.
+      if (existing.status === "pending" || existing.status === "running") {
+        return existing;
+      }
+
+      // 터미널 상태에서는 resume할 수 없습니다.
+      // 'succeeded' status is deprecated
+      if (["succeeded", "completed", "failed", "canceled"].includes(existing.status)) {
+        logger.error("Cannot resume workflow run: {params} with status {status}", {
+          params,
+          status: existing.status,
+        });
+        throw new Error(
+          `Cannot resume workflow run ${params.workflowRunId} with status ${existing.status}`,
+        );
+      }
+
+      logger.error("Failed to resume workflow run: {params}", { params });
+      throw new Error("Failed to resume workflow run");
+    }
+
+    return updated;
+  }
+
   async createStepAttempt(params: CreateStepAttemptParams): Promise<StepAttempt> {
     if (!this.initialized) {
       throw new Error("Backend not initialized");
@@ -631,6 +824,8 @@ export class BackendPostgres implements Backend {
 
     const limit = params.limit ?? DEFAULT_PAGINATION_PAGE_SIZE;
     const { after, before } = params;
+    const order = params.order ?? "asc";
+    const reverseOrder = order === "asc" ? "desc" : "asc";
 
     let cursor: Cursor | null = null;
     if (after) {
@@ -639,10 +834,10 @@ export class BackendPostgres implements Backend {
       cursor = decodeCursor(before);
     }
 
-    const qb = this.buildListStepAttemptsWhere(params, cursor);
+    const qb = this.buildListStepAttemptsWhere(params, cursor, order);
     const rows = await qb
-      .orderBy("created_at", before ? "desc" : "asc")
-      .orderBy("id", before ? "desc" : "asc")
+      .orderBy("created_at", before ? reverseOrder : order)
+      .orderBy("id", before ? reverseOrder : order)
       .limit(limit + 1);
 
     return this.processPaginationResults(
@@ -653,7 +848,11 @@ export class BackendPostgres implements Backend {
     );
   }
 
-  private buildListStepAttemptsWhere(params: ListStepAttemptsParams, cursor: Cursor | null) {
+  private buildListStepAttemptsWhere(
+    params: ListStepAttemptsParams,
+    cursor: Cursor | null,
+    order: "asc" | "desc",
+  ) {
     const { after } = params;
     const qb = this.knex
       .withSchema(DEFAULT_SCHEMA)
@@ -662,7 +861,9 @@ export class BackendPostgres implements Backend {
       .where("workflow_run_id", params.workflowRunId);
 
     if (cursor) {
-      const operator = after ? ">" : "<";
+      // asc: after → ">", before → "<"
+      // desc: after → "<", before → ">"
+      const operator = (order === "asc") === !!after ? ">" : "<";
       return qb.whereRaw(`("created_at", "id") ${operator} (?, ?)`, [
         cursor.createdAt.toISOString(),
         cursor.id,
@@ -713,8 +914,10 @@ export class BackendPostgres implements Backend {
     };
   }
 
-  // NOTE: 실제 서비스에서 이게 안 되는 것 같은데, 쿼리 등을 체크할 필요가 있음.
-  async completeStepAttempt(params: CompleteStepAttemptParams): Promise<StepAttempt> {
+  // WHERE 조건에 wr.status='running', sa.status='running'이 포함되어 있어,
+  // 외부에서 워크플로우 상태가 변경된 경우(pause/cancel) null을 반환합니다.
+  // 예상하지 못한 이유로 실패한 경우에는 에러를 로깅합니다.
+  async completeStepAttempt(params: CompleteStepAttemptParams): Promise<StepAttempt | null> {
     if (!this.initialized) {
       throw new Error("Backend not initialized");
     }
@@ -747,14 +950,13 @@ export class BackendPostgres implements Backend {
       .returning("sa.*");
 
     if (!updated) {
-      logger.error("Failed to mark step attempt completed: {params}", { params });
-      throw new Error("Failed to mark step attempt completed");
+      return this.handleStepAttemptUpdateMiss("completed", params);
     }
 
     return updated;
   }
 
-  async failStepAttempt(params: FailStepAttemptParams): Promise<StepAttempt> {
+  async failStepAttempt(params: FailStepAttemptParams): Promise<StepAttempt | null> {
     if (!this.initialized) {
       throw new Error("Backend not initialized");
     }
@@ -788,12 +990,46 @@ export class BackendPostgres implements Backend {
       .returning("sa.*");
 
     if (!updated) {
-      logger.error("Failed to mark step attempt failed: {params}", { params });
-      throw new Error("Failed to mark step attempt failed");
+      return this.handleStepAttemptUpdateMiss("failed", params);
     }
 
     return updated;
   }
+
+  /**
+   * completeStepAttempt/failStepAttempt에서 UPDATE가 0건일 때,
+   * 외부 상태 변경(pause/cancel)에 의한 것인지 판단합니다.
+   * - 외부 상태 변경이면 해당 step의 상태도 워크플로우와 동일하게 맞추고 null을 반환합니다.
+   * - 그 외에는 예상하지 못한 상황이므로 에러를 throw합니다.
+   */
+  private async handleStepAttemptUpdateMiss(
+    method: string,
+    params: { workflowRunId: string; stepAttemptId: string; workerId: string },
+  ): Promise<null> {
+    const wr = await this.getWorkflowRun({ workflowRunId: params.workflowRunId });
+
+    // 워크플로우가 외부에서 paused/canceled된 경우 → step 상태도 동일하게 갱신하고 null 반환
+    if (wr && (wr.status === "paused" || wr.status === "canceled")) {
+      await this.knex
+        .withSchema(DEFAULT_SCHEMA)
+        .table("step_attempts")
+        .where("namespace_id", this.namespaceId)
+        .where("id", params.stepAttemptId)
+        .whereIn("status", ["running", "paused"])
+        .update({
+          status: wr.status,
+          updated_at: this.knex.fn.now(),
+        });
+      return null;
+    }
+
+    // 그 외(워크플로우가 여전히 running인데 UPDATE가 안 된 경우 등) → 예상 못한 상황
+    logger.error("Failed to mark step attempt {method}: {params}", {
+      method,
+      params,
+    });
+    throw new Error(`Failed to mark step attempt ${method}`);
+  }
 }
 
 /**

package/src/database/base.test.ts

@@ -0,0 +1,41 @@
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+
+import { describe, expect, test } from "vitest";
+
+import { createMigrationSource } from "./base";
+
+describe("createMigrationSource", () => {
+  test("preserves emitted migration filenames for knex identity", async () => {
+    const migrationsDir = await mkdtemp(path.join(tmpdir(), "sonamu-tasks-migrations-"));
+
+    try {
+      await Promise.all([
+        writeFile(
+          path.join(migrationsDir, "20251212000000_0_init.js"),
+          "export const up = async () => {}; export const down = async () => {};",
+        ),
+        writeFile(path.join(migrationsDir, "20251212000000_0_init.d.ts"), "export {};"),
+        writeFile(
+          path.join(migrationsDir, "20251212000000_1_tables.ts"),
+          "export const up = async () => {}; export const down = async () => {};",
+        ),
+        writeFile(path.join(migrationsDir, "20251212000000_2_fk.js.map"), "{}"),
+      ]);
+
+      const migrationSource = createMigrationSource(migrationsDir);
+      const migrations = await migrationSource.getMigrations([]);
+
+      expect(migrations.map((migration) => migration.fileName)).toStrictEqual([
+        "20251212000000_0_init.js",
+        "20251212000000_1_tables.ts",
+      ]);
+      expect(
+        migrations.map((migration) => migrationSource.getMigrationName(migration)),
+      ).toStrictEqual(["20251212000000_0_init.js", "20251212000000_1_tables.ts"]);
+    } finally {
+      await rm(migrationsDir, { recursive: true, force: true });
+    }
+  });
+});

package/src/database/base.ts

@@ -1,7 +1,55 @@
+import { readdir } from "node:fs/promises";
 import path from "node:path";
-import knex, { type Knex } from "knex";
+import { pathToFileURL } from "node:url";
+
+import knex from "knex";
+import { type Knex } from "knex";
 
 export const DEFAULT_SCHEMA = "sonamu_tasks";
+const MIGRATION_FILE_PATTERN = /\.(?:[cm]?[jt]s)$/;
+const TYPE_DECLARATION_FILE_PATTERN = /\.d\.[cm]?[jt]s$/;
+
+type MigrationModule = {
+  up: (knex: Knex) => Promise<void>;
+  down: (knex: Knex) => Promise<void>;
+};
+
+type MigrationEntry = {
+  canonicalName: string;
+  fileName: string;
+};
+
+function toCanonicalMigrationName(fileName: string): string {
+  return fileName.replace(/\.(?:[cm]?[jt]s)$/, ".ts");
+}
+
+async function listMigrationEntries(directory: string): Promise<MigrationEntry[]> {
+  const dirents = await readdir(directory, { withFileTypes: true });
+
+  return dirents
+    .filter(
+      (dirent) =>
+        dirent.isFile() &&
+        MIGRATION_FILE_PATTERN.test(dirent.name) &&
+        !TYPE_DECLARATION_FILE_PATTERN.test(dirent.name),
+    )
+    .map((dirent) => ({
+      canonicalName: toCanonicalMigrationName(dirent.name),
+      fileName: dirent.name,
+    }))
+    .sort((left, right) => left.canonicalName.localeCompare(right.canonicalName));
+}
+
+export function createMigrationSource(directory: string): Knex.MigrationSource<MigrationEntry> {
+  return {
+    getMigrations: async (_loadExtensions) => listMigrationEntries(directory),
+    getMigrationName: (migration) => migration.fileName,
+    getMigration: async (migration): Promise<MigrationModule> => {
+      const migrationUrl = pathToFileURL(path.join(directory, migration.fileName)).href;
+      return import(migrationUrl) as Promise<MigrationModule>;
+    },
+  };
+}
 
 /**
  * migrate applies pending migrations to the database. Does nothing if the
@@ -10,9 +58,10 @@ export const DEFAULT_SCHEMA = "sonamu_tasks";
 export async function migrate(config: Knex.Config, schema: string) {
   const instance = knex({ ...config, pool: { min: 1, max: 1 } });
   try {
+    const migrationDirectory = path.join(import.meta.dirname, "migrations");
     await instance.schema.createSchemaIfNotExists(schema);
     await instance.migrate.latest({
-      directory: path.join(import.meta.dirname, "migrations"),
+      migrationSource: createMigrationSource(migrationDirectory),
       schemaName: schema,
     });
   } finally {

package/src/database/migrations/20251212000000_0_init.ts

@@ -1,4 +1,5 @@
-import type { Knex } from "knex";
+import { type Knex } from "knex";
+
 import { DEFAULT_SCHEMA } from "../base";
 
 export async function up(knex: Knex): Promise<void> {

package/src/database/migrations/20251212000000_1_tables.ts

@@ -1,4 +1,5 @@
-import type { Knex } from "knex";
+import { type Knex } from "knex";
+
 import { DEFAULT_SCHEMA } from "../base";
 
 export async function up(knex: Knex): Promise<void> {

package/src/database/migrations/20251212000000_2_fk.ts

@@ -1,4 +1,5 @@
-import type { Knex } from "knex";
+import { type Knex } from "knex";
+
 import { DEFAULT_SCHEMA } from "../base";
 
 export async function up(knex: Knex): Promise<void> {

package/src/database/migrations/20251212000000_3_indexes.ts

@@ -1,4 +1,5 @@
-import type { Knex } from "knex";
+import { type Knex } from "knex";
+
 import { DEFAULT_SCHEMA } from "../base";
 
 export async function up(knex: Knex): Promise<void> {

package/src/database/pubsub.test.ts

@@ -1,8 +1,11 @@
-import knex, { type Knex } from "knex";
+import knex from "knex";
+import { type Knex } from "knex";
 import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import type { Result } from "../core/result";
+
+import { type Result } from "../core/result";
 import { KNEX_GLOBAL_CONFIG } from "../testing/connection";
-import { type OnSubscribed, PostgresPubSub } from "./pubsub";
+import { PostgresPubSub } from "./pubsub";
+import { type OnSubscribed } from "./pubsub";
 
 describe("PostgresPubSub", () => {
   let knexInstance: Knex;