@gobing-ai/ts-db 0.1.0

package/dist/schema/queue-jobs.d.ts

@@ -0,0 +1,225 @@
+/**
+ * Drizzle schema definition for the queue_jobs table.
+ */
+export declare const queueJobs: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: "queue_jobs";
+    schema: undefined;
+    columns: {
+        nextRetryAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "next_retry_at";
+            tableName: "queue_jobs";
+            dataType: "number";
+            columnType: "SQLiteInteger";
+            data: number;
+            driverParam: number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        lastError: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "last_error";
+            tableName: "queue_jobs";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        processingAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "processing_at";
+            tableName: "queue_jobs";
+            dataType: "number";
+            columnType: "SQLiteInteger";
+            data: number;
+            driverParam: number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        expiresAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "expires_at";
+            tableName: "queue_jobs";
+            dataType: "number";
+            columnType: "SQLiteInteger";
+            data: number;
+            driverParam: number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "created_at";
+            tableName: "queue_jobs";
+            dataType: "number";
+            columnType: "SQLiteInteger";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: true;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "updated_at";
+            tableName: "queue_jobs";
+            dataType: "number";
+            columnType: "SQLiteInteger";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: true;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "id";
+            tableName: "queue_jobs";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        type: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "type";
+            tableName: "queue_jobs";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        payload: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "payload";
+            tableName: "queue_jobs";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        status: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "status";
+            tableName: "queue_jobs";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        attempts: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "attempts";
+            tableName: "queue_jobs";
+            dataType: "number";
+            columnType: "SQLiteInteger";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        maxRetries: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "max_retries";
+            tableName: "queue_jobs";
+            dataType: "number";
+            columnType: "SQLiteInteger";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "sqlite";
+}>;
+//# sourceMappingURL=queue-jobs.d.ts.map

package/dist/schema/queue-jobs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queue-jobs.d.ts","sourceRoot":"","sources":["../../src/schema/queue-jobs.ts"],"names":[],"mappings":"AAGA;;GAEG;AACH,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgBrB,CAAC"}

package/dist/schema/queue-jobs.js

@@ -0,0 +1,18 @@
+import { index, integer, sqliteTable, text } from 'drizzle-orm/sqlite-core';
+import { standardColumns } from './common.js';
+/**
+ * Drizzle schema definition for the queue_jobs table.
+ */
+export const queueJobs = sqliteTable('queue_jobs', {
+    id: text('id').primaryKey(),
+    type: text('type').notNull(),
+    payload: text('payload').notNull(),
+    status: text('status').notNull().default('pending'),
+    attempts: integer('attempts').notNull().default(0),
+    maxRetries: integer('max_retries').notNull().default(3),
+    ...standardColumns,
+    nextRetryAt: integer('next_retry_at'),
+    lastError: text('last_error'),
+    processingAt: integer('processing_at'),
+    expiresAt: integer('expires_at'),
+}, (table) => [index('queue_jobs_ready_idx').on(table.status, table.nextRetryAt, table.createdAt)]);

package/dist/span-context.d.ts

@@ -0,0 +1,2 @@
+export type { SpanContext } from '@gobing-ai/ts-runtime';
+//# sourceMappingURL=span-context.d.ts.map

package/dist/span-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"span-context.d.ts","sourceRoot":"","sources":["../src/span-context.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC"}

package/package.json

@@ -0,0 +1,47 @@
+{
+    "name": "@gobing-ai/ts-db",
+    "version": "0.1.0",
+    "description": "@gobing-ai/ts-db — Database abstraction layer with Drizzle ORM adapters, generic DAOs, and migration tooling.",
+    "type": "module",
+    "private": false,
+    "sideEffects": false,
+    "license": "Apache-2.0",
+    "main": "./dist/index.js",
+    "types": "./dist/index.d.ts",
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.ts",
+            "import": "./dist/index.js"
+        }
+    },
+    "files": [
+        "dist",
+        "src",
+        "README.md"
+    ],
+    "scripts": {
+        "build": "tsc -p tsconfig.build.json && bun ../../scripts/fix-dist-esm-extensions.ts dist",
+        "test": "NODE_ENV=test bun test --coverage --coverage-dir=.coverage --reporter=dots",
+        "test:full": "NODE_ENV=test bun test --update-snapshots --coverage --coverage-dir=.coverage",
+        "typecheck": "tsc --noEmit",
+        "lint": "biome check . && bun run typecheck",
+        "format": "biome check . --write",
+        "check": "bun run lint && bun run test",
+        "prepublishOnly": "bun run build",
+        "release": "npm publish --access public"
+    },
+    "dependencies": {
+        "@gobing-ai/ts-runtime": "^0.1.0"
+    },
+    "peerDependencies": {
+        "drizzle-orm": ">=0.38.0"
+    },
+    "devDependencies": {
+        "@types/bun": "1.3.14",
+        "drizzle-kit": "^0.30.0",
+        "drizzle-orm": "^0.38.0"
+    },
+    "publishConfig": {
+        "access": "public"
+    }
+}

package/src/adapter.ts

@@ -0,0 +1,109 @@
+/**
+ * Minimal D1 binding interface — avoids depending on @cloudflare/workers-types.
+ */
+interface D1Binding {
+    prepare(sql: string): unknown;
+    exec(sql: string): Promise<void>;
+}
+
+/**
+ * Generic database table descriptor carrying select and insert type info.
+ */
+export interface DbTable<TSelect, TInsert = TSelect> {
+    readonly $inferSelect: TSelect;
+    readonly $inferInsert: TInsert;
+}
+
+type DbInsertBuilder<TTable extends DbTable<unknown, unknown>> = {
+    values(values: TTable['$inferInsert'] | TTable['$inferInsert'][]): PromiseLike<unknown>;
+};
+
+interface DbSelectWhereResult<TTable extends DbTable<unknown, unknown>> extends PromiseLike<TTable['$inferSelect'][]> {
+    limit(value: number): DbSelectWhereResult<TTable>;
+    offset(value: number): DbSelectWhereResult<TTable>;
+    orderBy(column: unknown): DbSelectWhereResult<TTable>;
+}
+
+type DbSelectFromResult<TTable extends DbTable<unknown, unknown>> = DbSelectWhereResult<TTable> & {
+    where(condition: unknown): DbSelectWhereResult<TTable>;
+};
+
+type DbSelectBuilder = {
+    from<TTable extends DbTable<unknown, unknown>>(table: TTable): DbSelectFromResult<TTable>;
+};
+
+type DbProjectionSelectBuilder<TProjection> = {
+    from(table: DbTable<unknown, unknown>): PromiseLike<TProjection[]> & {
+        where(condition: unknown): PromiseLike<TProjection[]>;
+    };
+};
+
+interface DbUpdateResult {
+    changes: number;
+}
+
+interface DbUpdateBuilder<TTable extends DbTable<unknown, unknown>> {
+    set(values: Partial<TTable['$inferInsert']>): { where(condition: unknown): PromiseLike<DbUpdateResult> };
+}
+
+/**
+ * Abstract database client with insert/select/update/delete query builders.
+ */
+export interface DbClient {
+    insert<TTable extends DbTable<unknown, unknown>>(table: TTable): DbInsertBuilder<TTable>;
+    select(): DbSelectBuilder;
+    select<TProjection>(projection: Record<string, unknown>): DbProjectionSelectBuilder<TProjection>;
+    update<TTable extends DbTable<unknown, unknown>>(table: TTable): DbUpdateBuilder<TTable>;
+    delete<TTable extends DbTable<unknown, unknown>>(
+        table: TTable,
+    ): {
+        where(condition: unknown): PromiseLike<DbUpdateResult>;
+    };
+}
+
+/**
+ * Database adapter providing a unified client, raw SQL exec, and lifecycle management.
+ */
+export interface DbAdapter {
+    getDb(): DbClient;
+    exec(sql: string): Promise<void>;
+    /** Parameterized write (INSERT/UPDATE/DELETE) that returns no rows. */
+    run(sql: string, ...params: unknown[]): Promise<void>;
+    queryFirst<T>(sql: string, ...params: unknown[]): Promise<T | undefined>;
+    queryAll<T>(sql: string, ...params: unknown[]): Promise<T[]>;
+    close(): void;
+}
+
+/**
+ * Discriminated-union config for creating a database adapter (bun-sqlite or D1).
+ */
+export type DbAdapterConfig =
+    | {
+          driver: 'bun-sqlite';
+          url?: string;
+          pragmas?: {
+              journalMode?: string;
+              synchronous?: string;
+              foreignKeys?: string;
+          };
+      }
+    | { driver: 'd1'; binding: D1Binding };
+
+/**
+ * Factory: creates the correct {@link DbAdapter} implementation based on driver config.
+ */
+export async function createDbAdapter(config: DbAdapterConfig): Promise<DbAdapter> {
+    switch (config.driver) {
+        case 'bun-sqlite': {
+            const { BunSqliteAdapter } = await import('./adapters/bun-sqlite');
+            return new BunSqliteAdapter({
+                ...(config.url ? { databaseUrl: config.url } : {}),
+                ...(config.pragmas ? { pragmas: config.pragmas } : {}),
+            });
+        }
+        case 'd1': {
+            const { D1Adapter } = await import('./adapters/d1');
+            return new D1Adapter(config.binding as import('./adapters/d1').D1Binding);
+        }
+    }
+}

package/src/adapters/bun-sqlite.ts

@@ -0,0 +1,108 @@
+import { Database } from 'bun:sqlite';
+import { isAbsolute, resolve } from 'node:path';
+import { type BunSQLiteDatabase, drizzle } from 'drizzle-orm/bun-sqlite';
+import type { DbAdapter, DbClient } from '../adapter';
+import * as schema from '../schema/index';
+
+type SqliteStatementLike = {
+    all: (...params: unknown[]) => unknown;
+    get: (...params: unknown[]) => unknown;
+    run: (...params: unknown[]) => unknown;
+    values?: (...params: unknown[]) => unknown;
+};
+
+/**
+ * Configuration options for the bun:sqlite adapter (path, pragmas).
+ */
+export interface BunSqliteOptions {
+    /** Database path or ":memory:". Default: ".spur/spur.db" */
+    databaseUrl?: string;
+    /** SQLite pragmas. All have sensible defaults. */
+    pragmas?: {
+        journalMode?: string;
+        synchronous?: string;
+        foreignKeys?: string;
+    };
+}
+
+const DEFAULT_PRAGMAS = {
+    journalMode: 'PRAGMA journal_mode = WAL',
+    synchronous: 'PRAGMA synchronous = NORMAL',
+    foreignKeys: 'PRAGMA foreign_keys = ON',
+} as const;
+
+const DEFAULT_DB_PATH = '.spur/spur.db';
+
+/**
+ * Bun SQLite database adapter backed by `bun:sqlite`.
+ */
+export class BunSqliteAdapter implements DbAdapter {
+    private sqlite: Database;
+    private drizzleDb: BunSQLiteDatabase<typeof schema>;
+    /**
+     * Compiled-statement cache keyed by SQL text. `bun:sqlite` statements are
+     * reusable across calls with different params, so caching collapses the
+     * per-call `prepare()` recompile that dominated bulk write loops.
+     */
+    private readonly stmtCache = new Map<string, SqliteStatementLike>();
+
+    private getStatement(sql: string): SqliteStatementLike {
+        const cached = this.stmtCache.get(sql);
+        if (cached !== undefined) {
+            return cached;
+        }
+        const stmt = this.sqlite.prepare(sql) as unknown as SqliteStatementLike;
+        this.stmtCache.set(sql, stmt);
+        return stmt;
+    }
+
+    constructor(options?: BunSqliteOptions) {
+        let dbPath = options?.databaseUrl ?? DEFAULT_DB_PATH;
+        const pragmas = { ...DEFAULT_PRAGMAS, ...options?.pragmas };
+
+        // Resolve relative paths
+        if (dbPath !== ':memory:' && !isAbsolute(dbPath)) {
+            dbPath = resolve(dbPath);
+        }
+
+        this.sqlite = new Database(dbPath, { create: true });
+
+        this.sqlite.run(pragmas.journalMode);
+        this.sqlite.run(pragmas.synchronous);
+        this.sqlite.run(pragmas.foreignKeys);
+
+        this.drizzleDb = drizzle({ client: this.sqlite, schema });
+    }
+
+    getDb(): DbClient {
+        return this.drizzleDb as unknown as DbClient;
+    }
+
+    /** Returns the underlying drizzle instance for migration operations. */
+    getDrizzleDb(): BunSQLiteDatabase<typeof schema> {
+        return this.drizzleDb;
+    }
+
+    async exec(sql: string): Promise<void> {
+        this.sqlite.prepare(sql).run();
+    }
+
+    async run(sql: string, ...params: unknown[]): Promise<void> {
+        const stmt = this.getStatement(sql);
+        (stmt as unknown as { run: (...p: unknown[]) => unknown }).run(...params);
+    }
+
+    async queryFirst<T>(sql: string, ...params: unknown[]): Promise<T | undefined> {
+        const stmt = this.getStatement(sql);
+        return (stmt as unknown as { get: (...p: unknown[]) => T | undefined }).get(...params) as T | undefined;
+    }
+
+    async queryAll<T>(sql: string, ...params: unknown[]): Promise<T[]> {
+        const stmt = this.getStatement(sql);
+        return ((stmt as unknown as { all: (...p: unknown[]) => T[] }).all(...params) as T[]) ?? [];
+    }
+
+    close(): void {
+        this.sqlite.close();
+    }
+}

package/src/adapters/d1.ts

@@ -0,0 +1,76 @@
+import { type DrizzleD1Database, drizzle } from 'drizzle-orm/d1';
+import type { DbAdapter, DbClient } from '../adapter';
+import * as schema from '../schema/index';
+
+/**
+ * Minimal D1 binding interface — avoids depending on @cloudflare/workers-types.
+ */
+export interface D1Binding {
+    prepare(sql: string): {
+        bind(...params: unknown[]): D1BoundStatement;
+        first?<T>(): Promise<T | null>;
+        run?(): Promise<{ results: unknown[]; success: boolean }>;
+    };
+    exec(sql: string): Promise<void>;
+}
+
+interface D1BoundStatement {
+    all<T>(): Promise<{ results: T[]; success: boolean }>;
+    run(): Promise<{ results: unknown[]; success: boolean }>;
+    raw<T>(): Promise<T[]>;
+    first?<T>(): Promise<T | null>;
+}
+
+/**
+ * Cloudflare D1 database adapter.
+ *
+ * Accepts a D1 binding object matching the Cloudflare Workers D1Database
+ * interface shape. No ambient @cloudflare/workers-types dependency required.
+ */
+export class D1Adapter implements DbAdapter {
+    private binding: D1Binding;
+    private drizzleDb: DrizzleD1Database<typeof schema>;
+
+    constructor(binding: D1Binding) {
+        this.binding = binding;
+        this.drizzleDb = drizzle(this.binding, { schema });
+    }
+
+    getDb(): DbClient {
+        return this.drizzleDb as unknown as DbClient;
+    }
+
+    /** Returns the non-mutating binding for advanced direct D1 calls. */
+    getBinding(): D1Binding {
+        return this.binding;
+    }
+
+    async exec(sql: string): Promise<void> {
+        await this.binding.exec(sql);
+    }
+
+    async run(sql: string, ...params: unknown[]): Promise<void> {
+        const stmt = this.binding.prepare(sql);
+        const bound = params.length > 0 ? stmt.bind(...params) : stmt;
+        await (bound as unknown as { run: () => Promise<unknown> }).run();
+    }
+
+    async queryFirst<T>(sql: string, ...params: unknown[]): Promise<T | undefined> {
+        const stmt = this.binding.prepare(sql);
+        const bound = params.length > 0 ? stmt.bind(...params) : stmt;
+        return ((await (bound as unknown as { first: <T>() => Promise<T | null> }).first<T>()) ?? undefined) as
+            | T
+            | undefined;
+    }
+
+    async queryAll<T>(sql: string, ...params: unknown[]): Promise<T[]> {
+        const stmt = this.binding.prepare(sql);
+        const bound = stmt.bind(...params);
+        const result = await (bound as unknown as { all: <T>() => Promise<{ results: T[] }> }).all<T>();
+        return result.results ?? [];
+    }
+
+    close(): void {
+        // D1 bindings are managed by the Workers runtime -- no-op
+    }
+}

package/src/base-dao.ts

@@ -0,0 +1,37 @@
+import type { DbClient } from './adapter';
+
+/**
+ * Abstract base DAO providing transaction and timestamp utilities to all entity DAOs.
+ */
+export abstract class BaseDao {
+    /**
+     * DB transaction utility for subclasses.
+     *
+     * Constructor is `protected` — instantiate through concrete DAO subclasses,
+     * not BaseDao directly. Tests must declare an explicit public constructor
+     * that calls `super(db)` to expose the protected constructor publicly.
+     */
+    protected constructor(protected readonly db: DbClient) {}
+
+    protected now(): number {
+        return Date.now();
+    }
+
+    /**
+     * Execute a function within a database transaction.
+     *
+     * Works uniformly on both D1 (async) and bun:sqlite (sync wrapped in promise).
+     * The callback receives a transaction-scoped DbClient.
+     *
+     * @param fn - Function to execute within the transaction.
+     * @returns The return value of `fn`.
+     */
+    protected async withTransaction<T>(fn: (tx: DbClient) => Promise<T>): Promise<T> {
+        // Drizzle's .transaction() works on both backends:
+        // - bun:sqlite: sync wrapped in a promise
+        // - D1: native async
+        return (this.db as unknown as { transaction: (fn: unknown) => Promise<T> }).transaction(async (tx: DbClient) =>
+            fn(tx),
+        );
+    }
+}

package/src/embedded-migrations.ts

@@ -0,0 +1,32 @@
+/**
+ * Embedded migration SQL — auto-generated from drizzle/ folder.
+ *
+ * This file bundles all migration SQL as inline strings so the compiled
+ * binary can apply migrations without needing the drizzle/ folder on disk.
+ *
+ * DO NOT EDIT MANUALLY. Regenerate with: bun run scripts/embed-migrations.ts
+ */
+
+export interface EmbeddedMigration {
+    tag: string;
+    sql: string;
+    hash: string;
+}
+
+export const embeddedMigrations: EmbeddedMigration[] = [
+    {
+        tag: '0000_init',
+        sql: "CREATE TABLE `queue_jobs` (\n\t`id` text PRIMARY KEY NOT NULL,\n\t`type` text NOT NULL,\n\t`payload` text NOT NULL,\n\t`status` text DEFAULT 'pending' NOT NULL,\n\t`attempts` integer DEFAULT 0 NOT NULL,\n\t`max_retries` integer DEFAULT 3 NOT NULL,\n\t`created_at` integer NOT NULL,\n\t`updated_at` integer NOT NULL,\n\t`next_retry_at` integer,\n\t`last_error` text,\n\t`processing_at` integer\n);\n",
+        hash: '558dea3834348925f79b4d30ca79d0afd0d990b2883341377d369444d50ce76e',
+    },
+    {
+        tag: '0001_salty_red_ghost',
+        sql: 'CREATE INDEX `queue_jobs_ready_idx` ON `queue_jobs` (`status`,`next_retry_at`,`created_at`);',
+        hash: 'f842da3f49edeec8a17bcab399669410db09996ab258dc4fa781357d0400ddbf',
+    },
+    {
+        tag: '0002_nasty_namora',
+        sql: 'ALTER TABLE `queue_jobs` ADD `expires_at` integer;',
+        hash: '7380f8c162352a61b15205af5a87e0e7313a499203dae98fe62151a1dc7fec0e',
+    },
+];